<?php

//
// Open Web Analytics - An Open Source Web Analytics Framework
//
// Copyright 2006 Peter Adams. All rights reserved.
//
// Licensed under GPL v2.0 http://www.gnu.org/copyleft/gpl.html
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// $Id$
//

require_once(OWA_BASE_CLASS_DIR.'pagination.php');
require_once(OWA_BASE_CLASS_DIR.'timePeriod.php');
require_once(OWA_DIR.'owa_template.php');

/**
 * Result Set Manager
 *
 * Responsible for creating a data result set from various metrics and dimensions
 * 
 * @author      Peter Adams <peter@openwebanalytics.com>
 * @copyright   Copyright &copy; 2006 Peter Adams <peter@openwebanalytics.com>
 * @license     http://www.gnu.org/copyleft/gpl.html GPL v2.0
 * @category    owa
 * @package     owa
 * @version		$Revision$	      
 * @since		owa 1.3.0
 */

class owa_resultSetManager extends owa_base {

	/**
	 * The params of the caller, either a report or graph
	 *
	 * @var array
	 */
	var $params = array();
		
	/**
	 * The lables for calculated measures
	 *
	 * @var array
	 */
	var $labels = array();
		
	/**
	 * Data Access Object
	 *
	 * @var object
	 */
	var $db;
	
	/**
	 * The dimensions to groupby
	 *
	 * @var array
	 */
	var $dimensions = array();
	
	/**
	 * The Number of Dimensions to groupby
	 *
	 * @var integer
	 */
	var $dimensionCount;
	
	/**
	 * The table/column or denormalized dimensions 
	 * associated with this metric
	 *
	 * @var array
	 */
	var $denormalizedDimensions = array();
	
	var $_default_offset = 0;
	var $page;
	var $limit;
	var $order;
	var $format;
	var $constraint_operators = array('==','!=','>=', '<=', '>', '<', '=~', '!~', '=@','!@');
	var $related_entities = array();
	var $related_dimensions = array();
	var $related_metrics = array();
	var $resultSet;
	var $base_table;
	var $metrics = array();
	var $metricsByTable = array();
	var $childMetrics = array();
	var $calculatedMetrics = array();
	var $query_params = array();
	var $baseEntity;
	var $metricObjectsByEntityMap = array();
	var $errors = array();
	var $formatters = array();
	
	function __construct($db = '') {
		
		if ($db) {
			$this->db = $db;	
		} else {
			$this->db = owa_coreAPI::dbSingleton();
		}
		
		$this->formatters = array(
			//'yyyymmdd' => array($this, 'dateFormatter'),
			'timestamp'		=> array($this, 'formatSeconds'),
			'percentage' 	=> array($this, 'formatPercentage'), 
			'integer' 		=> array($this, 'numberFormatter'),
			'currency'		=> array($this, 'formatCurrency')
		);
		
		return parent::__construct();
	}
	
		
	function setConstraint($name, $value, $operator = '') {
		
		if (empty($operator)) {
			$operator = '=';
		}
		
		if (!empty($value)) {
			$this->params['constraints'][] = array('operator' => $operator, 'value' => $value, 'name' => $name);
		}
	}
	
	function setConstraints($array) {
		
		if (is_array($array)) {
			
			if (is_array($this->params['constraints'])) {
				$this->params['constraints'] = array_merge($array, $this->params['constraints']);
			} else {
				$this->params['constraints'] = $array;
			}
		}
	}
	
	function constraintsStringToArray($string) {
		
		if ($string) {
			//print_r($string);
			// add string to query params array for use in URLs.
			$this->query_params['constraints'] = $string;
			
			$constraints = explode(',', $string);
			//print_r($constraints);
			$constraint_array = array();
			
			foreach($constraints as $constraint) {
				
				foreach ($this->constraint_operators as $operator) {
					
					if (strpos($constraint, $operator)) {
						list ($name, $value) = split($operator, $constraint);
						
						$constraint_array[] = array('name' => $name, 'value' => $value, 'operator' => $operator);
					

						break;
					}
				}
			}
			//print_r($constraint_array);
			return $constraint_array;
		}
	}
	
	function getConstraints() {
	
		return $this->params['constraints'];
	}
	
	function applyConstraints() {
		
		$nconstraints = array();
		
		foreach ($this->getConstraints() as $k => $constraint) {
			
			$dim = $this->lookupDimension($constraint['name'], $this->baseEntity);
			
			//$dimEntity = owa_coreAPI::entityFactory($dim['entity']);
			
			
			$col = $dim['column'];
			$constraint['name'] = $col;
			$nconstraints[$col] = $constraint;
			$this->db->multiWhere($nconstraints);
			//print_r($nconstraints);
		
		}
		
	}
	
	
	function chooseBaseEntity() {
		
		$metric_imps = array();
		
		// load metric implementations
		foreach ($this->metrics as $metric_name) {
			
			$metric_imps = array_merge($this->getMetricEntities($metric_name), $metric_imps);
			
			
		}
		//print_r($metric_imps);
		owa_coreAPI::debug('pre-reduce set of entities to choose from: '.print_r($metric_imps, true));
		
		$entities = array();
		// reduce entities	
		foreach ($metric_imps as $mimp) {
			
			if (empty($entities)) {
				$entities = $mimp;
			}
			
			$entities = $this->reduceTables($mimp, $entities);
			
			if (empty($entities)) {
				return $this->addError('illegal metric combination');
			}
		}
		
		owa_coreAPI::debug('post-reduce set of entities to choose from: '.print_r($entities, true));
		
		// check summary level of entities
		$niceness = array();
		
		foreach ($entities as $entity) {
			
			$niceness[$entity] = owa_coreAPI::entityFactory($entity)->getSummaryLevel();
		}
		//sort by summary level
		arsort($niceness);
		
		owa_coreAPI::debug('Entities summary levels: '.print_r($niceness, true));
		
		$entity_count = count($niceness);
		$i = 1;
		//check entities for dimension relations
		foreach ($niceness as $entity_name => $summary_level) {
			
			$error = false;
			
			//cycle through each dimension frm dim list and those found in constraints.
			$dims = array_unique(array_merge($this->dimensions, $this->getDimensionsFromConstraints()));
			
			owa_coreAPI::debug(sprintf('Dimensions: %s',print_r($this->dimensions, true)));
			
			owa_coreAPI::debug(sprintf('Checking the following dimensions for relation to %s: %s',$entity_name, print_r($dims, true)));
			
			foreach ($dims as $dimension) {
				
				$check = $this->isDimensionRelated($dimension, $entity_name);
				
				// is the realtionship check fails then move onto the next entity.
				if (!$check) {
					$error = true;
					owa_coreAPI::debug("$dimension is not related to $entity_name. Moving on to next entity...");
					break;
				} else {
					owa_coreAPI::debug("Dimension: $dimension is related to $entity_name.");
				}
			}
			
			// is no error then everythig is related and we are good to go.
			if (!$error) {
				owa_coreAPI::debug('optimal base entity is: '.$entity_name);
				$this->baseEntity = owa_coreAPI::entityFactory($entity_name);
				return $this->baseEntity;
			}
			
			if ($i === $entity_count) {
				$this->addError('illegal dimension combination: '.$dimension);
			} else {
				$i++;
			}
		}
	}
	
	function getDimensionsFromConstraints() {
		
		$dims = array();
		
		$constraints = $this->getConstraints();
		//print_r($constraints);
		if (!empty($constraints)) {
				
			foreach ($constraints as $carray) {
				
				$dims[] = $carray['name'];
			}
		}
		
		return $dims;
	}
		
	function isDimensionRelated($dimension_name, $entity_name) {
		
		$entity = owa_coreAPI::entityFactory($entity_name);
		
		$dimension = $this->lookupDimension($dimension_name, $entity);
		
		if ($dimension['denormalized'] === true) {
			$this->related_dimensions[$dimension['name']] = $dimension;
			owa_coreAPI::debug("Dimension: $dimension_name is denormalized into $entity_name");
			return true;
		} else {
		
			$fk = $this->getDimensionForeignKey($dimension, $entity);
			
			if ($fk) {
				owa_coreAPI::debug("Dimension: $dimension_name is related to $entity_name");
				$this->related_dimensions[$dimension['name']] = $dimension;
				return true;
			} else {
				owa_coreAPI::debug("Could not find a foreign key for $dimension_name in $entity_name");
			}
		}
	}
	
	function getMetricEntities($metric_name) {
		
		//get the class implementations
		$s = owa_coreAPI::serviceSingleton();
		$classes = $s->getMetricClasses($metric_name);
		
		$entities = array();
		
		// cycles through metric classes and get their entity names
		foreach ($classes as $name => $map) {
			$m = owa_coreAPI::metricFactory($map['class'], $map['params']);
			
			// check to see if this is a calculated metric
				if ($m->isCalculated()) {
					
					foreach ($m->getChildMetrics() as $cmetric_name) {
						$this->addCalculatedMetric($m);
						$entities = array_merge($this->getMetricEntities($cmetric_name), $entities);
					}
					
				} else {
					$this->metricObjectsByEntityMap[$m->getEntityName()][$metric_name] = $m;
					$entities[$metric_name][] = $m->getEntityName();	
				}
			
		}
		
		return $entities;
	}
	
	function reduceTables($new, $old) {
		
		return array_intersect($new, $old);
	}
	
	function getDimensionForeignKey($dimension, $entity) {

		if ($dimension) {
			//$entity = ;
			$dim = $dimension;
			$fk = array();
			// check for foreign key column by name if dimension specifies one
			if (array_key_exists('foreign_key_name', $dim) && !empty($dim['foreign_key_name'])) {
				// get foreign key col by 
				if ($entity->isForeignKeyColumn($dim['foreign_key_name'])){
					$fk = array('col' => $dim['foreign_key_name'], 'entity' => $entity);
				}
				
			} else {
				// if not check for foreign key by entity name
			    //check to see if the metric's entity has a foreign key to the dimenesion table.
				$fk = array(); 
				
				$fkcol = $entity->getForeignKeyColumn($dim['entity']);
				owa_coreAPI::debug("Foreign Key check: ". print_r($fkcol, true));
				if ($fkcol) {
					$fk['col'] = $fkcol;
					$fk['entity'] = $entity;
				} 
			}

			return $fk;
		}
	}
		
	function lookupDimension($name, $entity) {
		
		// check dimensions
		if (array_key_exists($name, $this->related_dimensions)) {
			//return $this->related_dimensions[$name];
		}
		//print_r($this->metrics[0]);
		// check for denormalized 
		
		$service = owa_coreAPI::serviceSingleton();
		$dim = $service->getDenormalizedDimension($name, $entity->getName());
		
		if ($dim) {
			//apply table aliasing to dimension column
			$dim['column'] = $entity->getTableAlias().'.'.$dim['column'];
		} else {
		
			// check for normalized dim
			if (array_key_exists($name, $this->related_dimensions)) {
				$dim = $this->related_dimensions[$name];
			} else {
				
				$dim = $service->getDimension($name);
				
				if ($dim) {
					$dimEntity = owa_coreAPI::entityFactory($dim['entity']);
					// alias needs to use fk name in case there are two joins on the
					// same table. This is also used in addRelation method
					$alias = $dimEntity->getTableAlias().'_via_'.$dim['foreign_key_name'];
					//$dim['column'] = $dimEntity->getTableAlias().'.'.$dim['column'];
					$dim['column'] = $alias.'.'.$dim['column'];
				} else {
					$msg = "$name is not a registered dimension.";
					owa_coreAPI::debug($msg);
					$this->addError($msg);
				}
				
			}
		}
		
		return $dim;
	}
	
	function setLimit($value) {
		
		if (!empty($value)) {
		
			$this->limit = $value;
		}
	}
	
	function setOrder($value) {
		
		if (!empty($value)) {
			$this->params['order'] = $value;
		}
	}
	
	function getOrder() {
	
		if (array_key_exists('order', $this->params)) {
			return $this->params['order'];
		}
	}
	
	function setSort($column, $order) {
		
		//$this->params['orderby'][] = array($this->getColumnName($column), $order);
	}
	
	function setSorts($array) {
		
		if (is_array($array)) {
			
			if (!empty($this->params['orderby'])) {
				$this->params['orderby'] = array_merge($array, $this->params['orderby']);

			} else {
				$this->params['orderby'] = $array;
			}
		}
	}
	
	function sortStringToArray($string) {
		
		if ($string) {
		
			// add string to query params array for use in URLs.
			$this->query_params['sort'] = $string;
		
			$sorts = explode(',', $string);
			
			$sort_array = array();
			
			foreach ($sorts as $sort) {
				
				if (strpos($sort, '-')) {
					$column = substr($sort, 0, -1);
					$order = 'DESC';
				} else {
					$column = $sort;
					$order = 'ASC';
				}
		
				//$col_name = $this->getColumnName($column);
				$check = $this->isSortValid($column);
				
				if ($check) {
								
					$col_name = $column;
					
					if ($col_name) {
						$sort_array[$sort][0] = $col_name;
						$sort_array[$sort][1] = $order;
						
					} else {
						$this->addError("$column is not a valid column to sort on");
					}	
				}	
			}
			
			return $sort_array;
		}
	}
	
	function isSortValid($needle) {
		
		$haystack = array_merge($this->metrics, $this->dimensions);
		return in_array($needle, $haystack);
	}
	
	function setPage($value) {
		
		if (!empty($value)) {
		
			$this->page = $value;
			
			if (!empty($this->pagination)) {
				$this->pagination->setPage($value);
			}			
		}
	}
	
	function setOffset($value) {
		
		if (!empty($value)) {
			$this->params['offset'] = $value;
		}
	}
	
	function setFormat($value) {
		if (!empty($value)) {
			$this->format;
			$this->params['result_format'] = $value;
		}
	}
	
	function setPeriod($value) {
		if (!empty($value)) {
			$this->params['period'] = $value;
		}
	}
	
	function setTimePeriod($period_name = '', $startDate = null, $endDate = null, $startTime = null, $endTime = null) {
		
		$map = false;
		
		if ($startDate && $endDate) {
			$period_name = 'date_range';
			$map = array('startDate' => $startDate, 'endDate' => $endDate);
			$dimension_name = 'date';
			$format = 'yyyymmdd';
		} elseif ($startTime && $endTime) {
			$period_name = 'time_range';
			$map = array('startTime' => $startTime, 'endTime' => $endTime);
			$dimension_name = 'timestamp';
			$format = 'timestamp';
		} else {
			owa_coreAPI::debug('no start/end params passed to owa_metric::setTimePeriod');
			$dimension_name = 'date';
			$format = 'yyyymmdd';
		}
	
		// add to query params array for use in URL construction		
		if ($map) {
			$this->query_params = array_merge($map, $this->query_params);
		} else {
			$this->query_params['period'] = $period_name;
		}
		
		$p = owa_coreAPI::supportClassFactory('base', 'timePeriod');
		
		$p->set($period_name, $map);
		
		$this->setPeriod($p);
		
		$start = $p->startDate->get($format);
		$end = $p->endDate->get($format);
		
		$this->setConstraint($dimension_name, array('start' => $start, 'end' => $end), 'BETWEEN');

		
	}
	
	function setStartDate($date) {
	
		if (!empty($date)) {
			$this->params['startDate'] = $date;
		}
	}
	
	function setEndDate($date) {
		if (!empty($date)) {
			$this->params['endDate'] = $date;
		}
	}
		
	function applyMetaDataToResults($results) {
		
		$new_rows = array();
		
		foreach ($results as $row) {
			
			$new_rows[] = $this->applyMetaDataToSingleResultRow($row);
		}
		
		return $new_rows;
	}
	
	function applyMetaDataToSingleResultRow($row) {
		
		$new_row = array();
		
		foreach ($row as $k => $v) {
				
			if (in_array($k, $this->dimensions)) {
				$type = 'dimension';
				$dim = $this->lookupDimension($k, $this->baseEntity);
				$data_type = $dim['data_type'];
			} elseif (in_array($k, $this->metrics)){
				$type = 'metric';
				$data_type = $this->getMetric($k)->getDataType();
			}
			
			
			
			$new_row[$k] = array(
				'result_type' => $type, 
				'name' 		  => $k, 
				'value' 	  => $v,
				'formatted_value' => $this->formatValue($data_type, $v),
				'label' => $this->getLabel($k), 'data_type' => $data_type);	
		}
		
		return $new_row;
	}
	
	function formatValue($type, $value) {
		
		if (array_key_exists($type, $this->formatters)) {
			
			$formatter = $this->formatters[$type];
			
			if (!empty($formatter)) {
				
				$value = call_user_func($formatter, $value);
			}
		}
		 
		
		return $value;
	}
	
	function numberFormatter($value) {
		
		return number_format($value);
	}
	
	function formatSeconds($value) {
		
		return date("G:i:s",mktime(0,0,($value)));
	}
	
	function formatPercentage($value) {
		
		return number_format($value * 100, 2).'%';
	}
	
	function formatCurrency($value) {
	
		return owa_lib::formatCurrency( $value, owa_coreAPI::getSetting( 'base', 'currencyLocal' ) );
	}
	
	/**
	 * Sets an individual label
	 * return the key so that it can be nested
	 * @return $key string
	 */
	function addLabel($key, $label) {
		
		$this->labels[$key] = $label;
		return $key;
	}
	
	function getLabel($key = '') {
		
		if (array_key_exists($key, $this->labels)) {
			return $this->labels[$key];
		} else {
			//owa_coreAPI::debug("No label found for $key.");
		}
		
	}
	
	/**
	 * Retrieve the labels of the measures
	 *
	 */
	function getLabels() {
	
		return $this->labels;
	}
	
	/**
	 * Sets an individual label
	 * return the key so that it can be nested
	 * @return $key string
	 */
	function setLabel($label) {
		
		$this->labels[$this->getName()] = $label;
	}
	
	/**
	 * Set the labels of the measures
	 *
	 */
	function setLabels($array) {
	
		$this->labels = $array;
	}
		
	function getPeriod() {
	
		return $this->params['period'];
	}

	function getLimit() {
		
		return $this->limit;
	}
	
	/**
	 * Adds a dimension to the dimension map
	 * 
	 * Retrieves dimension info from service layer and checks to see if 
	 * dimension is denromalized or if it is a valid relation
	 */
	function setDimension($name) {
		
		if ($name) {
			$this->dimensions[] = $name;
		}
	}
	
	function setDimensions($array) {
		
		if ($array) {
		
			foreach($array as $name) {
				
				$this->setDimension($name);
			}	
		}
	}
	
	function dimensionsStringToArray($string) {
		
		// add string to query params array for use in URLs.
		$this->query_params['dimensions'] = $string;
		return explode(',', $string);
	}
	
	function metricsStringToArray($string) {
		
		// add string to query params array for use in URLs.
		$this->query_params['metrics'] = $string;
		return explode(',', $string);
	}

	
	function dimensionsArrayToString($array) {
		
		return implode(',', $array);
	}
	
	/**
	 * Applies dimensional sql to dao object
	 */
	function applyDimensions() {
		
		foreach ($this->dimensions as $dimension_name) {
			$dim = $this->lookupDimension($dimension_name, $this->baseEntity);
			// add column name to select statement
			$this->db->selectColumn($dim['column'], $dim['name']);
			// add groupby
			$this->db->groupBy($dim['column']);
			$this->addLabel($dim['name'], $dim['label']);
		}
	}
	
	function applyJoins() {
		
		foreach($this->related_dimensions as $dim) {
			$this->addRelation($dim);
		}		
	}
		
	function addRelation($dim) {
			
			// if denomalized, skip
			if ($dim['denormalized'] === true) {
				return;
			}
			
			// have already determined base enttiy at this point so use that.
			$fk = $this->getDimensionForeignKey($dim, $this->baseEntity);
			//print_r($fk);
			//print $fk;
			if ($fk) {
				
				// create dimension entity
				$dimEntity = owa_coreAPI::entityFactory($dim['entity']);
				// get foreign key column
				//$bm = $this->getBaseMetric();
				//$fpk_col = $bm->entity->getProperty($fk);
				$fpk_col = $fk['entity']->getProperty($fk['col']);
				//$fpk_col = $this->baseEntity->getProperty($fk['col']);

				//print_r($fk['col']);
				$fpk = $fpk_col->getForeignKey();
				// add join
				//print_r($fpk);
				// needed to make joins unique in cases where there are 
				// two joins onthe same table using different foreign keys.
				$alias = $dimEntity->getTableAlias().'_via_'.$dim['foreign_key_name'];	
				//$this->db->join(OWA_SQL_JOIN, $dimEntity->getTableName(), $dimEntity->getTableAlias(), $fk['entity']->getTableAlias().'.'.$fk['col'], $dimEntity->getTableAlias().'.'.$fpk[1]);
				$this->db->join(OWA_SQL_JOIN, $dimEntity->getTableName(), $alias, $fk['entity']->getTableAlias().'.'.$fk['col'], $alias.'.'.$fpk[1]);
				
				//$this->addColumn($dim['name'], $dimEntity->getTableAlias().'.'.$dim['column']);
				$this->addColumn($dim['name'], $alias.'.'.$dim['column']);

			} else {
				// add error result set
				owa_coreAPI::debug(sprintf('%s metric does not have relation to dimension %s', $fk['entity']->getName(), $dim['name'])); 
			}
		
	}
	
	// remove
	function addMetric($metric_name, $child = false) {
		
		$ret = false;
		
		$m = $this->getMetric($metric_name);
		
		if (!$m) {
			$m = owa_coreAPI::metricFactory($metric_name);
		
			if ($m) {
			
				
				// necessary if the metric was first added as a child but later added as a parent.
				if (!$child) {
					
					if (array_key_exists($metric_name, $this->childMetrics)) {
						unset ($this->childMetrics[$metric_name]);
					}
				} else {
					// add child metrics to child metric maps
					// check to see if it wasn't already added as a non-child metric.
					if (!array_key_exists($metric_name, $this->metrics)){
						$this->childMetrics[$metric_name] = $metric_name;
					}
				}
			
				// check to see if this is a calculated metric
				if ($m->isCalculated()) {
					
					return $this->addCalculatedMetric($m);
				}
			
				if ($this->checkForFactTableRelation($m)) {
			 		
					$this->metrics[$metric_name] = $m;
					$this->metricsByTable[$m->getTableName()] = $metric_name;
					$this->addSelect($m->getSelect());
					$this->addLabel($m->getName(), $m->getLabel());
					
					$ret = true;
				}
			
			} else {
				$this->addError("$metric_name is not a metric.");
			}
		} else {
			$ret =  true;
		}
		
		
		
		return $ret;		
	}
	
	function addCalculatedMetric($calc_metric_obj) {
		
		// add label of calculated metric obj
		$this->addLabel($calc_metric_obj->getName(),$calc_metric_obj->getLabel());
		// add to calculated metric map
		$this->calculatedMetrics[$calc_metric_obj->getName()] = $calc_metric_obj; 
		
	}
	
	function getCalculatedMetricByName($name) {
		
		return $this->calculatedMetrics[$name];
	}
	
	function addSelect($select_array) {
	
		$this->params['selects'][] = $select_array; 
	}
	
	function getSelects() {
	
		if (array_key_exists('selects', $this->params)) {
			return $this->params['selects'];
		}
	}
	
	function applySelects() {
		//print_r($this->metrics);
		foreach($this->metrics as $k => $metric_name) {
			
			if (!array_key_exists($metric_name, $this->calculatedMetrics)) {
			
				$m = $this->metricObjectsByEntityMap[$this->baseEntity->getName()][$metric_name];
						
				$select = $m->getSelect();
				//print_r ($select);
				$this->db->selectColumn($select[0], $select[1]);
			} else {
				$m = $this->getCalculatedMetricByName($metric_name);
			}
			
			$this->addLabel($m->getName(), $m->getLabel());
		}
		
		// add selects for calculated metrics
		if (!empty($this->calculatedMetrics)) {

			// loop through calculated metric objects
			foreach ($this->calculatedMetrics as $cmetric) {
				//create child metrics
				foreach( $cmetric->getChildMetrics() as $child_name) {
					// check to see if the metric has already been added
					if (!in_array($child_name, $this->metrics)) {
					
						$child = $this->metricObjectsByEntityMap[$this->baseEntity->getName()][$child_name];
						$select = $child->getSelect();
						//print_r ($select[0]);
						$this->db->selectColumn($select[0], $select[1]);
						// needed so we can remove this temp metric later
						$this->childMetrics[] = $child_name;
						owa_coreAPI::debug("Added $child_name to ChildMetrics array");
					}
				}
			}
		}
	}
	
	function getFormat() {
		
		if (array_key_exists('result_format', $this->params)) {
			return $this->params['result_format'];
		}
	}
	
	function getColumnName($string) {
		
		//$string = trim($string);
		if (array_key_exists($string, $this->related_dimensions)) {
			return $this->related_dimensions[$string]['column'];
		}
		
		if (array_key_exists($string, $this->related_metrics)) {
			return $string;
		}
		
		
		//return $string;
		
	}
	
	/**
	 * Sets a metric's column name into the all_columns map
	 *
	 * this is needed when combining metrics so that sort and
	 * constraint column names can be looked up fro ma single map.
	 */
	function addColumn($name, $col) {
		
		$this->all_columns[$name] = $col;
	}
	
	function addError($msg) {
		
		$this->errors[] = $msg;
		owa_coreAPI::debug($msg);
	}
	
	/**
	 * Generates a result set for the metric
	 *
	 */
	function getResults() {
		
		// get paginated result set object
		$rs = owa_coreAPI::supportClassFactory('base', 'paginatedResultSet');
		
		$bm = $this->chooseBaseEntity();
				
		if ($bm) {
			
			$bname = $bm->getName();
		
			owa_coreAPI::debug("Using $bname as base entity for making result set.");
	
			// set constraints
			$this->applyJoins();
			$this->applyConstraints();
			$this->applySelects();
		
			$this->db->selectFrom($bm->getTableName(), $bm->getTableAlias());
			// generate aggregate results
			$results = $this->db->getOneRow();
			// merge into result set
			if ($results) {
				$rs->aggregates = array_merge($this->applyMetaDataToSingleResultRow($results), $rs->aggregates);
			}
			
			// setup dimensional query
			if (!empty($this->dimensions)) {
				$this->applyJoins();
				// apply dimensional SQL
				$this->applyDimensions();
				
				$this->applySelects();
			
				$this->db->selectFrom($bm->getTableName(), $bm->getTableAlias());
				
				// pass limit to db object if one exists
				if (!empty($this->limit)) {
					$rs->setLimit($this->limit);
				}
				// pass limit to db object if one exists
				if (!empty($this->page)) {
					$rs->setPage($this->page);
				}
				
				$this->applyConstraints();
				
				if (array_key_exists('orderby', $this->params)) {
					$sorts = $this->params['orderby'];
					// apply sort by
					if ($sorts) {
						foreach ($sorts as $sort) {
							$this->db->orderBy($sort[0], $sort[1]);
							$rs->sortColumn = $sort[0];
							if (isset($sort[1])){
								$rs->sortOrder = strtolower($sort[1]);
							} else {
								$rs->sortOrder = 'asc';
							}
						}
					}
				}				
				
				// add labels
				$rs->setLabels($this->getLabels());	
			
				// generate dimensonal results
				$results = $rs->generate($this->db);
				
				$rs->resultsRows = $this->applyMetaDataToResults($results);
			}
			
			// add labels
			$rs->setLabels($this->getLabels());
			
			// add period info
			
			$rs->setPeriodInfo($this->params['period']->getAllInfo());
			
			$rs = $this->computeCalculatedMetrics($rs);
			
			// add urls
			$urls = $this->makeResultSetUrls();
			$rs->self = $urls['self'];
			
			if ($rs->more) {
			
				$rs->next = $urls['next'];
			}
			
			if ($this->page >=2) {
				$rs->previous = $urls['previous'];
			}
			
			$rs->createResultSetHash();
		}
		
		$rs->errors = $this->errors;
				
		return $rs;
	}
	
	function computeCalculatedMetrics($rs) {
		
		foreach ($this->calculatedMetrics as $cm) {
			
			// add aggregate metric
			$formula = $cm->getFormula();
			$div_by_zero = false;
			
			//owa_coreAPI::debug( "checking calculated metrics..." );
			//owa_coreAPI::debug( $rs->aggregates );
			foreach ($cm->getChildMetrics() as $metric_name) {
				
				$ag_value = $rs->getAggregateMetric($metric_name);
				
				if (empty($ag_value) || $ag_value == 0) {
					$ag_value = 0;
					$div_by_zero = true;
				}
				
				$formula = str_replace($metric_name, $ag_value, $formula);
			}
			
			if ( ! $div_by_zero ) {
				$value = $this->evalFormula($formula);
			} else {
				$value = 0;
			}
			
			$rs->setAggregateMetric($cm->getName(), $value, $cm->getLabel(), $cm->getDataType(), $this->formatValue($cm->getDataType(), $value));
			
			// add dimensional metric
			
			if ($rs->getRowCount() > 0) {
				
				foreach ($rs->resultsRows as $k => $row) {
					
					// add aggregate metric
					$formula = $cm->getFormula();
					$row_div_by_zero = false;
					foreach ($cm->getChildMetrics() as $metric_name) {
						
						if (array_key_exists($metric_name, $row)) {
							$row_value = $row[$metric_name]['value'];
						} else {
							$row_value = '';
						}
						if (empty($row_value) || $row_value == 0) {
							$row_value = 0;
							$row_div_by_zero = true;
						}
					
						$formula = str_replace($metric_name, $row_value, $formula);	
					
					}
					
					if ( ! $row_div_by_zero ) {
						$value = $this->evalFormula($formula);
					} else {
						$value = 0;
					}
					
					$rs->appendRow($k, 'metric', $cm->getName(), $value, $cm->getLabel(), $cm->getDataType(), $this->formatValue($cm->getDataType(), $value));
				}
			}
		}
		
		// clean up by removing child metrics before returning the result set.
		foreach ($this->childMetrics as $metric_name) {
				
			$rs->removeMetric($metric_name);
		}
		
		return $rs;
	}
	
	function evalFormula($formula) {
		
		//safety first. should only be computing numbers.
			$formula = str_replace('$','', $formula);
			
			// need parens and @ to handle divsion by zero errors
			$formula = '$value = ('.$formula.');';
			//print $formula;
			// calc
			@ eval($formula);
			
			if (!$value) {
				$value = 0;
			}
			
			return $value;
	}
	
	function getMetric($name) {
		
		if (in_array($name, $this->metrics)) {
			return $this->metricObjectsByEntityMap[$this->baseEntity->getName()][$name];
		} 
	}
	
	function setQueryStringParam($name, $string) {
		
			$this->query_params[$name] = $string;
	}
	
	function makeResultSetUrls() {
		
		$urls = array();
		// get api url
		$api_url = owa_coreAPI::getSetting('base', 'api_url');
		// get base query params
		$query_params = $this->query_params;
		// add api command
		$query_params['do'] = 'getResultSet';
		//add format
		if ($this->format) {
			$query_params['format'] = $this->format;
		} else {
			$query_params['format'] = 'json';
		}
		// add current page if any
		if ($this->page) {
			$query_params['page'] = $this->page;
		}
		// add limit
		if ($this->limit) {
			$query_params['resultsPerPage'] = $this->limit;
		}
		
		// build url for this result set
		$link_template = owa_coreAPI::getSetting('base', 'link_template');
		$q = $this->buildQueryString($query_params);
		$urls['self'] = sprintf($link_template, $api_url, $q);
		
		// build url for next page of result set
		$next_query_params = $query_params;
		if ($this->page) {
			$next_query_params['page'] = $query_params['page'] + 1;
		} else {
			$next_query_params['page'] = 2;
		} 
		
		$nq = $this->buildQueryString($next_query_params);
		$urls['next'] = sprintf($link_template, $api_url, $nq);
		
		// build previous url if page is greater than 2	
		if ($this->page >= 2) {
			$previous_query_params = $query_params;
			$previous_query_params['page'] = $query_params['page'] - 1;
			$pq = $this->buildQueryString($previous_query_params);
			$urls['previous'] = sprintf($link_template, $api_url, $pq);
		}
		
		$base_query_params = $this->query_params;
		$base_query_params['format'] = $this->format;
		
		// build pagination url template for use in constructing 
		$q = $this->buildQueryString($base_query_params);
		$url['base_url'] = sprintf($link_template, $api_url, $q);
		
		return $urls;
	}
	
	function buildQueryString($params, $seperator = '&') {
		
		$new = array();
		//get namespace
		$ns = owa_coreAPI::getSetting('base', 'ns');
		foreach ($params as $k => $v) {
			
			$new[$ns.$k] = $v;
		}
		
		return http_build_query($new,'', $seperator);
	}

}

?>