<?php
/**
 * Allows easy indexing and searching for Active Records using Solr.
 *
 * Usage:
 * <pre>
 * $model = User::model()->find();
 * $behavior = new ASolrSearchable();
 * $behavior->attributes = array(
 *  "name", "skills", "country.name"
 * );
 * $model->attachBehavior("ASolrSearchable", $behavior);
 * $model->index(); // adds the user to the solr index
 *
 * $model->name = "Test User";
 * $model->save(); // document is automatically reindexed
 * $model->address = "123 Fake Street";
 * $model->save(); // document is not reindexed because we don't care about the address field
 *
 * $criteria = new ASolrCriteria;
 * $criteria->query = "name:'Test User'";
 * $users = $model->findAllBySolr($criteria); // all the users with the name "Test User"
 *
 * $model->delete(); // document is automatically deleted from solr after the model is deleted
 * </pre>
 * @package packages.solr
 * @author Charles Pick / PeoplePerHour.com
 */
class ASolrSearchable extends CActiveRecordBehavior {
	/**
	 * The class name of the solr document to instantiate
	 * 
	 * @var string
	 */
	public $documentClass = "ASolrDocument";
	
	/**
	 * Whether to automatically index or reindex the document when it changes.
	 * Defaults to true.
	 * You can also pass a method that will be evaluated in order to decide if
	 * the current model should be indexed or not
	 * eg: autoIndex => function() { return true; },
	 * while in the definition of attributes in the models behaviors() method
	 * 
	 * @var boolean | callable
	 */
	public $autoIndex = true;
	
	/**
	 * Whether to be smart about when to reindex documents.
	 * If this is true, changes will be pushed to solr only if attributes that
	 * we care about have changed.
	 * 
	 * @var boolean
	 */
	public $smartIndex = true;
	
	/**
	 * The configuration for the associated ASolrDocument class
	 * 
	 * @var array
	 */
	public $solrDocumentConfig = array ();
	/**
	 * The solr document associated with this model instance
	 * 
	 * @var ASolrDocument
	 */
	protected $_solrDocument;
	
	/**
	 * The solr criteria associated with this model instance
	 * 
	 * @var ASolrCriteria
	 */
	protected $_solrCriteria;
	
	/**
	 * The attributes that should be indexed in solr
	 * 
	 * @var array
	 */
	protected $_attributes;
	
	/**
	 * Stores the attributes of the model after it is found.
	 * Used to determine whether any of the attributes we care about have changed or not
	 * 
	 * @var array
	 */
	protected $_oldAttributes = array ();
	
	/**
	 * Sets the attributes that should be indexed in solr
	 * 
	 * @param array $attributes        	
	 */
	public function setAttributes($attributes) {
		$a = array ();
		foreach ( $attributes as $key => $value ) {
			if (is_integer ( $key )) {
				$key = $value;
			}
			$a [$key] = $value;
		}
		$this->_attributes = $a;
	}
	
	/**
	 * Gets the attributes that should be indexed in solr
	 * 
	 * @return array
	 */
	public function getAttributes() {
		if ($this->_attributes === null) {
			$names = $this->getOwner ()->attributeNames ();
			$this->_attributes = array_combine ( $names, $names );
		}
		return $this->_attributes;
	}
	/**
	 * Gets a list of objects and attributes that
	 * 
	 * @return array a multidimensional array of objects and attributes
	 */
	protected function resolveAttributes() {
		$names = array ();
		foreach ( $this->getAttributes () as $modelAttribute => $docAttribute ) {
			if (! strstr ( $modelAttribute, "." )) {
				$names [$modelAttribute] = array (
						$this->getOwner (),
						$modelAttribute 
				);
				continue;
			}
			$reference = $this->getOwner (); /* @var CActiveRecord $reference */
			$pointers = explode ( ".", $modelAttribute );
			$lastItem = array_pop ( $pointers );
			foreach ( $pointers as $pointer ) {
				$reference = $reference->{$pointer};
			}
			$names [$modelAttribute] = array (
					$reference,
					$lastItem 
			);
		}
		return $names;
	}
	
	/**
	 * Resolves the attribute name to the field name on solr.
	 * Default implementation replaces "." with "__" (double underscore)
	 * <pre>
	 * echo $behavior->resolveAttributeName("name"); // "name"
	 * echo $behavior->resolveAttributeName("country.name"); // "country__name"
	 * </pre>
	 * 
	 * @param
	 *        	$attributeName
	 * @return mixed
	 */
	protected function resolveAttributeName($attributeName) {
		$attributes = $this->getAttributes ();
		$attributeName = $attributes [$attributeName];
		return str_replace ( ".", "__", $attributeName );
	}
	
	/**
	 * Resolves the value of an attribute on an owner object.
	 *
	 * @param mixed $owner
	 *        	the object or array of objects that the attribute belongs to
	 * @param string $attribute
	 *        	the name of the attribute to get the value for
	 * @return mixed the attribute value
	 */
	protected function resolveAttributeValue($owner, $attribute) {
		if (is_array ( $owner )) {
			$value = array ();
			foreach ( $owner as $item )
				if (is_array ( $item ) && isset ( $item [$attribute] ))
					$value [] = $item [$attribute];
				else if (is_object ( $item ) && isset ( $item->{$attribute} ))
					$value [] = $item->{$attribute};
			return $value;
		}
		return isset ( $owner->{$attribute} ) ? $owner->{$attribute} : null;
	}
	
	/**
	 * Sets the solr document associated with this model instance
	 * 
	 * @param ASolrDocument $solrDocument
	 *        	the solr document
	 */
	public function setSolrDocument($solrDocument) {
		$this->_solrDocument = $solrDocument;
	}
	
	/**
	 * Gets the solr document associated with this model instance.
	 * 
	 * @param boolean $refresh
	 *        	whether to refresh the document, defaults to false
	 * @return ASolrDocument the solr document
	 */
	public function getSolrDocument($refresh = false) {
		if ($this->_solrDocument === null || $refresh) {
			$config = $this->solrDocumentConfig;
			$config ['class'] = $this->documentClass;
			$this->_solrDocument = Yii::createComponent ( $config );
			
			foreach ( $this->resolveAttributes () as $attribute => $item ) {
				list ( $object, $property ) = $item;
				$resolvedAttributeName = $this->resolveAttributeName ( $attribute );
				$this->_solrDocument->{$resolvedAttributeName} = $this->resolveAttributeValue ( $object, $property );
			}
		}
		return $this->_solrDocument;
	}
	
	/**
	 * Adds the solr document to the index
	 * 
	 * @return boolean true if the document was indexed successfully
	 */
	public function index() {
		if (! $this->isIndexable ())
			return true;
		$document = $this->getSolrDocument ( true );
		if (! $document->save ()) {
			return false;
		}
		if ($this->smartIndex) {
			$this->_oldAttributes = array ();
			foreach ( $this->resolveAttributes () as $key => $item ) {
				list ( $object, $property ) = $item;
				$this->_oldAttributes [$key] = $this->resolveAttributeValue ( $object, $property );
			}
		}
		return true;
	}
	/**
	 * Triggered after the attached model is found.
	 * Stores the current state of attributes we care about to see if they have changed.
	 * 
	 * @param CEvent $event
	 *        	the event raised
	 */
	public function afterFind($event) {
		if ($this->smartIndex) {
			$this->_oldAttributes = array ();
			foreach ( $this->resolveAttributes () as $key => $item ) {
				list ( $object, $property ) = $item;
				$this->_oldAttributes [$key] = $this->resolveAttributeValue ( $object, $property );
			}
		}
	}
	
	/**
	 * Deletes the relevant document from the solr index after the model is deleted
	 * 
	 * @param CEvent $event
	 *        	the event raised
	 */
	public function afterDelete($event) {
		$this->getSolrDocument ()->delete ();
	}
	/**
	 * Adds the relevant document to the solr index after the model is saved if $this->autoIndex is true.
	 * For existing records, the document will only be re-indexed if attributes we care about have changed.
	 * 
	 * @param CEvent $event
	 *        	the event raised
	 */
	public function afterSave($event) {
		if (! $this->isIndexable () || ! $this->getIsModified ()) {
			return;
		}
		$this->index ();
	}
	/**
	 * Finds an active record that matches the given criteria using solr
	 * 
	 * @param ASolrCriteria $criteria
	 *        	the solr criteria to use for searching
	 * @return CActiveRecord|null the found record, or null if nothing was found
	 */
	public function findBySolr($criteria = null) {
		$c = new ASolrCriteria ();
		$c->mergeWith ( $this->getSolrCriteria () );
		if ($criteria !== null) {
			$c->mergeWith ( $criteria );
		}
		if ($c->getQuery () == "") {
			$c->setQuery ( "*:*" );
		}
		$document = $this->getSolrDocument ()->find ( $c );
		if (! is_object ( $document )) {
			return null;
		}
		return $this->populateFromSolr ( $document, false );
	}
	
	/**
	 * Finds all active records that matches the given criteria using solr
	 * 
	 * @param ASolrCriteria $criteria
	 *        	the solr criteria to use for searching
	 * @return CActiveRecord[] an array of results
	 */
	public function findAllBySolr($criteria = null) {
		$c = new ASolrCriteria ();
		$c->mergeWith ( $this->getSolrCriteria () );
		if ($criteria !== null) {
			$c->mergeWith ( $criteria );
		}
		if ($c->getQuery () == "") {
			$c->setQuery ( "*:*" );
		}
		return $this->populateFromSolr ( $this->getSolrDocument ()->findAll ( $c ), true );
	}
	
	/**
	 * Populates active record objects from solr
	 * 
	 * @param ASolrDocument|array $document
	 *        	the document(s) to populate the records from
	 * @param boolean $all
	 *        	whether to populate a list of records instead of just one, defaults to false
	 * @return CActiveRecord|array the active record(s) populated from solr
	 */
	public function populateFromSolr($document, $all = false) {
		if ($all) {
			$results = array ();
			foreach ( $document as $doc ) {
				$results [] = $this->populateFromSolr ( $doc, false );
			}
			return $results;
		}
		$relations = $this->getOwner ()->getMetaData ()->relations;
		$attributes = array ();
		$relationAttributes = array ();
		foreach ( $this->getAttributes () as $modelAttribute => $docAttribute ) {
			$resolved = $this->resolveAttributeName ( $modelAttribute );
			if (! strstr ( $modelAttribute, "." )) {
				$attributes [$modelAttribute] = $document->{$resolved};
				continue;
			}
			$reference = &$relationAttributes;
			$pointers = explode ( ".", $modelAttribute );
			$last = array_pop ( $pointers );
			foreach ( $pointers as $pointer ) {
				if (! isset ( $reference [$pointer] )) {
					$reference [$pointer] = array ();
				}
				$reference = & $reference [$pointer];
			}
			$reference [$last] = $document->{$resolved};
		}
		$modelClass = get_class ( $this->getOwner () );
		$model = $modelClass::model ()->populateRecord ( $attributes );
		if (count ( $relationAttributes )) {
			foreach ( $relationAttributes as $relationName => $attributes ) {
				$relationClass = $relations [$relationName]->className;
				$model->{$relationName} = $relationClass::model ()->populateRecord ( $attributes );
			}
		}
		return $model;
	}
	
	/**
	 * Determines whether any attributes that we care about on the model have been modified or not.
	 * 
	 * @return boolean true if the item has been modified, otherwise false
	 */
	public function getIsModified() {
		if (! $this->smartIndex || count ( $this->_oldAttributes ) == 0) {
			return true;
		}
		foreach ( $this->resolveAttributes () as $key => $item ) {
			if (! isset ( $this->_oldAttributes [$key] )) {
				return true;
			}
			list ( $object, $property ) = $item;
			
			if ($this->_oldAttributes [$key] != $this->resolveAttributeValue ( $object, $property )) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Resets the scope
	 * 
	 * @return ASolrSearchable $this with the scope reset
	 */
	public function resetScope() {
		$this->_solrCriteria = null;
		return $this;
	}
	
	/**
	 * Sets the solr criteria associated with this model
	 * 
	 * @param ASolrCriteria $solrCriteria
	 *        	the solr criteria
	 */
	public function setSolrCriteria($solrCriteria) {
		$this->_solrCriteria = $solrCriteria;
	}
	
	/**
	 * Gets the solr criteria associated with this model
	 * 
	 * @return ASolrCriteria the solr criteria
	 */
	public function getSolrCriteria() {
		if ($this->_solrCriteria === null) {
			$this->_solrCriteria = new ASolrCriteria ();
		}
		return $this->_solrCriteria;
	}
	
	/**
	 * Checks whether the current model should be indexed or not.
	 * 
	 * @return bool
	 */
	protected function isIndexable() {
		return is_callable ( $this->autoIndex ) ? call_user_func ( $this->autoIndex ) : $this->autoIndex;
	}
}