<?php

/**
 * $header
 * @copyright Copyright 2007, Peter Goodman
 * @package valkyrie
 * @subpackage Database.activerecord
 * @author Peter Goodman
 */

if(!defined('IN_VALKYRIE')) {
	exit;
}

/**
 * A decorator class for an individual row in the database. This class extends
 * VK_Overload.
 */
class VK_DatabaseRecord extends VK_Overload implements VK_Record, IteratorAggregate {
	
	/**
	 * A reference to the database abstraction layer
	 * @see Database
	 * @internal
	 */
	protected $dba;
	
	/**
	 * A reference to this table's model definition
	 * @see ModelDefinition
	 * @internal
	 */
	private $model;
	
	/**
	 * A boolean of whether or not this row/record exists in the database yet.
	 * @internal
	 */
	private $saved = FALSE;
	
	/**
	 * An array holding saved data from the database. If a database row for this
	 * record does not exist, this array will be empty.
	 * @internal
	 */
	private $data = array();
	
	/**
	 * An array of all user-set values to this table row that don't exist in the database
	 * yet and haven't been validated.
	 * @internal
	 */
	private $dirty = array();
	
	/**
	 * A cache of the return values of getter functions in this class. all functions prefixed
	 * by 'get' are available to the template engine via {$record.func_name} (refers to getFuncName)
	 * @internal
	 */
	private $cache = array();
	
	/**
	 * Constructor, bring in references to the database abstraction layer, model definition, and an
	 * array of saved data. If that array is empty, then VK_DatabaseRecord::$saved will remain false.
	 * @param array $data An array containing initial saved data (if the row is saved).
	 * @param mixed $dba A reference to the database abstractin layer.
	 * @param mixed $model A reference to the model definition for this database table.
	 * @see Database, ModelDefinition
	 * @internal
	 */
	final public function __construct(array $data = array(), DatabaseDriver $dba, DatabaseModelDefinition $definition) {
		$this->dba = $dba;
		$this->definition = $definition;
		
		if(!empty($data)) {
			$this->saved = TRUE;
		}
		
		$this->data = $data;
	}
	
	/**
	 * Quick accessor for the value of the primary key.
	 */
	final public function getId() {
		return isset($this->data[$this->definition->getPrimaryKey()]) ? $this->data[$this->definition->getPrimaryKey()] : FALSE;
	}
	
	/**
	 * Get the value of a row from the record. First it will look in the dirty array, then the data (saved)
	 * array, then the cache from functions, then it will check if a $key 'func_name' function exists as 
	 * 'getFuncName', and if so, cache that result.
	 * @param string $key The table column name or cache result to get.
	 * @return mixed
	 * @see VK_Overload
	 * @see VK_DatabaseRecord::__set(), VK_DatabaseRecord::__isset(), VK_DatabaseRecord::__unset()
	 */
	final public function __get($key = '') {
		$ret = NULL;
		
		// dirty first, important
		if(isset($this->dirty[$key])) {
			$ret = $this->dirty[$key];
		} else if(isset($this->data[$key])) {
			$ret = $this->data[$key];
		} else if(isset($this->cache[$key])) {
			$ret = $this->cache[$key];
		} else {
			$method_name = 'get'. camelize($key);
			
			// call a function
			if(is_callable($this, $method_name)) {
				
				$ret = $this->cache[$key] = $this->$method_name();
				
			// get a relation
			} else if($relation = $this->definition->getRelation($key)) {
				echo "\n\n". get_class($relation) ."\n\n";
				$finder = $relation->getModel()->getFinder($relation->getModelId());
				$func = $relation instanceof VK_ToOneRelation ? 'findByQuery' : 'findAllByQuery';
				$ret = $this->cache[$key] = $finder->$func($relation->getQuery(), array($this->getId()));
			}
		}
		
		return $ret;
	}
	
	/**
	 * Call a relation so that extra parameters can be passed to it.
	 */
	public function __call($key, array $args = array()) {
		if(!isset($this->cache[$key]) && isset($args[0]) && $relation = $this->definition->getRelation($key)) {
			
			call_user_func_array(array($relation, 'setSelect'), $args);
			
			$finder = $relation->getModel()->getFinder($relation->getModelId());
			$func = $relation instanceof ToOneRelation ? 'findByQuery' : 'findAllByQuery';				
			$this->cache[$key] = $finder->$func($relation->getQuery(), array($this->getId()));
		}
		
		return isset($this->cache[$key]) ? $this->cache[$key] : NULL;
	}
	
	/**
	 * Set a value to the array of dirty data.
	 * @param string $key The key (column name) to set the the dirty array
	 * @param string $val The value to set the the dirty array for this column
	 * @see VK_Overload
	 * @see VK_DatabaseRecord::__get(), VK_DatabaseRecord::__isset(), VK_DatabaseRecord::__unset()
	 */
	final public function __set($key = '', $val) {
		$this->dirty[$key] = $val;
	}
	
	/**
	 * Check if a value for a column name exists
	 * @param string $key The key (column name) check
	 * @todo Do I want to have to pre-fetch here? It's the only way for it to work with the template engine :(
	 * @see VK_Overload
	 * @see VK_DatabaseRecord::__get(), VK_DatabaseRecord::__set(), VK_DatabaseRecord::__unset()
	 */
	final public function __isset($key = '') {
		//return isset($this->dirty[$key]) || isset($this->data[$key]) || isset($this->cache[$key]);
		return $this->__get($key) !== NULL;
	}
	
	/**
	 * Unset the value for a column name
	 * @param string $key The key (column name) to unset
	 * @see VK_Overload
	 * @see VK_DatabaseRecord::__get(), VK_DatabaseRecord::__set(), VK_DatabaseRecord::__isset()
	 */
	final public function __unset($key = '') {
		unset($this->dirty[$key], $this->data[$key]);
	}
	
	/**
	 * Bind an array to the dirty values.
	 */
	final public function bindArray($array = array()) {
		if(is_array($array)) {
			$this->dirty = array_merge($this->dirty, $array);
		} else if($array instanceof DatabaseRecord) {
			foreach($array as $key => $val) {
				$this->$key = $val;
			}
		}
	}
	
	/**
	 * Get a database finder.
	 */
	final public function getFinder($id) {
		return $this->definition->getModel()->getFinder($id);
	}
	
	/**
	 * Overrideable function (in custom record classes) to execute before a record is
	 * saved. This is particularly useful if you want to do any sort of operations on the
	 * values of columns before saving, eg: special validation/cleaning.
	 */
	public function preSave() { }
	
	/**
	 * Overrideable function (in custom record classes) to execute after a record has
	 * been saved. I haven't thought of a use case for this, but because preSave exists,
	 * I thought: "why not postSave?", and so it is here.
	 */
	public function postSave() { }
	
	/**
	 * Validate the dirty fields.
	 * @see VK_ModelDefinition::validateField()
	 * @internal
	 */
	final private function validate() {
		foreach($this->dirty as $field => $val) {
			if(FALSE !== ($val = $this->definition->validateField($field, $val))) {
				$this->dirty[$field] = $val;
			} else {
				unset($this->dirty[$field]);
			}
		}
	}
	
	/**
	 * Save a record to the database. If the record already exists in the database, then this
	 * will perform an UPDATE query, otherwise it will perform an INSERT query.
	 */
	final public function save() {
		
		// call the pre-save hook
		$this->preSave();
		
		$insert_vals = array();
		
		// validate the dirty things against the model
		$this->validate();
		
		// get dirty things
		$keys = array_keys($this->dirty);
		$vals = array_values($this->dirty);
				
		// update
		if($this->saved) {
			$sql = 'UPDATE '. $this->definition->getTable('name') .' SET ';
			
			$sep = '';
			foreach($keys as $key) {
				$sql .= $sep . $key .'=?';
				$sep = ',';
			}
			
			$sql .= ' WHERE '. $this->definition->getPrimaryKey() .'=?';
			
			$vals[] = $this->getId();
			
			$this->dba->update($sql, $vals);
		
		// insert
		} else {
			$this->dba->update($this->dba->buildInsert($this->definition->getTable('name'), $keys, $vals), $vals);
			
			if($this->definition->getPrimaryKey() !== NULL) {
				$this->data[$this->definition->getPrimaryKey()] = $this->dba->insertId();
			}
		}
			
		$this->saved = TRUE;
		$this->data = array_merge($this->data, $this->dirty);
		$this->dirty = array();
		
		// call the post-save hook
		$this->postSave();
		
		return TRUE;
	}
	
	/**
	 * Delete a record from the database if it exists there already.
	 */
	final public function delete() {
		if($this->saved) {
			if($this->definition->getPrimaryKey() !== NULL) {
				$this->dba->update('DELETE FROM '. $this->definition->getTable('name') .' WHERE '. $this->definition->getPrimaryKey() .'=?', array($this->getId()));
			} else {
				// hrm.
			}
		}
	}
	
	/**
	 * Iterate through the dirty/data arrays.
	 */
	public function getIterator() {
		return new ArrayIterator(array_merge($this->data, $this->dirty));
	}
}

/**
 * A class it iterate over a result set. Each iteration will return a VK_DatabaseRecord
 * decorator class for the row. This class extends IteratorIterator because the
 * database result sets passed in implement Iterator.
 * @see VK_DatabaseRecord, IteratorIterator, DatabaseResultSet
 */
class VK_DatabaseRecordSet extends IteratorIterator implements VK_RecordSet, Countable {
	
	/**
	 * A reference to the current database abstraction layer
	 * @see Database
	 * @internal
	 */
	private $dba;
	
	/**
	 * A reference to this tables model definition
	 * @see DatabaseModelDefinition
	 * @internal
	 */
	private $definition;
	
	/**
	 * An array of cached record classes. The record classes are cached because
	 * if one decides to iterate over this result set multiple times then each
	 * time we want to return to them the same record class for each database row.
	 * @internal
	 */
	private $cache = array();
	
	/**
	 * Constructor, bring in the result set, the database layer and the model definition.
	 * @param mixed $result A reference to a DatabaseResultSet
	 * @param mixed $dba A reference to the current database abstraction layer
	 * @param mixed $model A reference to the this tables model definition
	 * @see DatabaseResultSet, Database, ModelDefinition
	 * @internal
	 */
	final public function __construct(DatabaseResultSet $result, DatabaseDriver $dba, DatabaseModelDefinition $definition) {
		$this->dba = $dba;
		$this->definition = $definition;
		
		parent::__construct($result);
	}
	
	/**
	 * The current function of the iterator, called in each loop. This function returns
	 * a cached version of the VK_DatabaseRecord decorator class for the current row in the database
	 * result set.
	 * @return mixed A cached instance of VK_DatabaseRecord
	 * @see VK_DatabaseRecord
	 * @internal
	 */
	public function current() {

		if(!isset($this->cache[$this->key()])) {
			$record = $this->definition->getName() .'Record';
			$record = class_exists($record, FALSE) ? $record : 'VK_DatabaseRecord';
			$this->cache[$this->key()] = new $record(parent::current(), $this->dba, $this->definition);
		}
		
		return $this->cache[$this->key()];
	}
	
	/**
	 * Return the number of rows in the internal result set
	 * @see DatabaseResultSet::numRows()
	 */
	final public function numRows() {
		return $this->getInnerIterator()->numRows();
	}
	
	/**
	 * Return the number of rows.
	 */
	final public function count() {
		return $this->numRows();
	}
	
	/**
	 * Delete all items in this record set, also cause a cascade delete if necessary.
	 */
	final public function delete() {
		
	}
}