<?php
/**
 * To implment tagging behavior to be able to plug into any data model in the system
 *
 * Requirements
 *  You are required to create "tags" table to hold all tag entries (id:int, name:string)
 *  You are required to create a "[tableName]_tags" table for each object you
 *  want to tag. for example, to implement tags for pages u need this table
 * 	pages_tags (page_id : int, tag_id:int)
 *
 *
 * Example Setup
 * 	class Page extends AppModel {
 * 		var $actsAs = array('Taggable');
 * 		var $hasAndBelongsToMany => array('Tag' => array('with'=>'PageTag','joinTable'=>'pages_tags');
 * }
 *
 * Done
 * 	now all tagging related features can be used in your models.
 * 	$this->Page->findPopularTags();
 *  $this->Page->findRelatedTags(array('news'));
 *
 * Once $this->Page->id is set, you can all pages related to current page.
 * 	$this->Page->findRelatedTagged(10);
 *
 *
 */
class TaggableBehavior extends ModelBehavior {

    function tag(&$model, $name = null) {
        if (is_null($name)) return false;
        if ($existing = $model->Tag->find(array('name'=>$name), array('id'))) {
            return $existing['Tag']['id'];
        } else {
            $handle = Inflector::slug($name, '-');
            $model->Tag->create(array('name'=>$name,'handle'=>$handle));
            $model->Tag->save();
            return $model->Tag->getLastInsertId();
        }
    }

    function afterFind(&$model, $results, $primary = false) {
        foreach($results as &$result) {
            if (isset($result['Tag'])) {
                $tags = join(', ', Set::extract($result['Tag'], '{n}.name'));
                $result[$model->alias]['tags'] = $tags;
            }
        }
        return $results;
    }

    function beforeSave(&$model) {
        if (isset($model->data[$model->alias]['tags'])) {
            $tags = Set::normalize($model->data[$model->alias]['tags'], false);
            $ids = array();
            foreach ($tags as $tag) {
                $ids[] = $this->tag($model, $tag);
            }
            $model->data['Tag']['Tag'] = $ids;
        }
        return true;
    }

    /**
     * Finds other records that share the most tags with the record passed as the
     * related parameter.
     * Useful for constructing æRelatedÆ or æSee AlsoÆ boxes and lists.
     *
     * Require Model::$data to be set so it points to current entry.
     * @param Model $model
     * @param integer $limit
     * @param integer $page
     * @return array - list of related entries
     */
    function findRelatedTagged(&$model, $limit = 20, $page = 1) {
        if (!isset($model->hasAndBelongsToMany['Tag']) || !$model->id) {
            return false;
        }
        extract($model->hasAndBelongsToMany['Tag'], EXTR_SKIP);
        $prefix = $model->tablePrefix;
        $tableName = Inflector::tableize($className);
        $offset = $limit * ($page-1);

        # SQL query to get related items share most of tags.
        $sql = "SELECT {$model->alias}.*, COUNT( joinTable2.{$foreignKey} ) AS count
                FROM {$prefix}{$model->useTable} {$model->alias},
                    {$prefix}{$joinTable} joinTable,
                    {$prefix}{$joinTable} joinTable2,
                    {$prefix}{$tableName} Tag
                WHERE joinTable.{$foreignKey} = {$model->id}
                    AND Tag.{$model->primaryKey} = joinTable.{$associationForeignKey}
                    AND joinTable2.{$foreignKey} != joinTable.{$foreignKey}
                    AND joinTable2.{$associationForeignKey} = joinTable.{$associationForeignKey}
                    AND {$model->alias}.{$model->primaryKey} = joinTable2.{$foreignKey}
                GROUP BY joinTable2.{$foreignKey} ORDER BY count DESC
                LIMIT {$offset}, {$limit};";
        $related = $model->query($sql);
        # Filter out count field from result
        if (!empty($related)) {
            $related = Set::remove($related, "{n}.0");
        }
        return $related;
    }

    /**
     * Finds other tags that are related to the tags passed thru the tags parameter,
     * by finding common records that share similar sets of tags.
     * Useful for constructing æRelated tagsÆ lists.
     *
     * @param Model $model - instance of target model
     * @param mixed $tags - list of tags in string or array format
     * @return array - list of related Tags
     */
    function findRelatedTags(&$model, $tags = array()) {
        if (!isset($model->hasAndBelongsToMany['Tag']) || !$tags ) {
            return false;
        }
        extract($model->hasAndBelongsToMany['Tag'], EXTR_SKIP);
        if (is_string($tags)) {
            $tags = Set::normalize($tags, false);
        }
        $prefix = $model->tablePrefix;
        $tableName = Inflector::tableize($className);
        $tagsString = "'".join("', '", $tags)."'";
        $tagsCount = count($tags);

        # Sql find related tags
        $sql = "SELECT Tags.*, COUNT(joinTable.{$foreignKey}) AS count
                FROM {$prefix}{$joinTable} joinTable,
                    {$prefix}{$tableName} Tags
                WHERE joinTable.{$foreignKey} IN (
                        SELECT joinTable.{$foreignKey}
                        FROM {$prefix}{$joinTable} joinTable,
                            {$prefix}{$tableName} Tags
                        WHERE joinTable.{$associationForeignKey} = Tags.id
                            AND Tags.name IN ({$tagsString})
                        GROUP BY joinTable.{$foreignKey}
                        HAVING COUNT(joinTable.{$foreignKey}) = {$tagsCount}
                    )
                    AND Tags.name NOT IN ({$tagsString})
                    AND Tags.id = joinTable.{$associationForeignKey}
                GROUP BY joinTable.{$associationForeignKey}
                ORDER BY count DESC";
        $related = $model->query($sql);

        # Filter out count field from result
        if (!empty($related)) {
            $related = Set::remove($related, "{n}.0");
        }
        return $related;
    }


/**
 * Find most popular tags in relation to current model
 *
 * @param unknown_type $model
 * @param unknown_type $limit
 * @param unknown_type $page
 * @return unknown
 */
    function findPopularTags(&$model, $limit = 20, $page = 1) {
        extract($model->hasAndBelongsToMany['Tag'], EXTR_SKIP);
        $prefix = $model->tablePrefix;
        $tableName = Inflector::tableize($className);
        $offset = $limit * ($page-1);

        $sql = "SELECT Tag.*, COUNT( joinTable.{$foreignKey} ) AS popularity
                FROM {$prefix}{$joinTable} joinTable,
                    {$prefix}{$tableName} Tag
                WHERE Tag.{$model->primaryKey} = joinTable.{$associationForeignKey}
                GROUP BY joinTable.{$associationForeignKey}
                ORDER BY popularity DESC
                LIMIT {$offset}, {$limit};";
        $popular = $model->query($sql);

        # Filter out popular field
        if (!empty($popular)) {
            $popular = Set::remove($related, "{n}.0");
        }
        return $popular;
    }

/**
 * 	Find all associated entry with tags
 *
 * @param Model $model
 * @param Array $tags - Find entries with these tags
 * @return $results
 */
    function findTaggedWith(&$model, $tags) {
    	extract($model->hasAndBelongsToMany['Tag'], EXTR_SKIP);

    	$Tag = ClassRegistry::init('Tag');
    	$ids = Set::extract($Tag->findAll(array('name'=>$tags), array('id')), '{n}.Tag.id');

    	$model->{$with}->bindModel(array(
    		'belongsTo'=>array($model->name, 'Tag'))
    	);
		$results = $model->{$with}->findAll(array("{$with}.tag_id"=>$ids));
		return $results;
	}


/**
 * Count the number of tags associated to current Model entry
 * Require Model::$data to be set so it points to current entry.
 *
 * @param Model $model
 * @return integer - Number of tags
 */
    function TagsCount(&$model) {
        if(!isset($model->id)) {
        	return 0;
        }
        extract($model->hasAndBelongsToMany['Tag'], EXTR_SKIP);

        $results = $model->{$with}->findCount(array(
        	"{$with}.page_id" => $model->id
        ));
        return $results;
    }

}
?>