<?php namespace ProcessWire;

/**
 * Class that provides information about selectors for Fieldtypes
 *
 * This is primarily a helper for the base Fieldtype class getSelectorInfo method
 *
 * This originated with the InputfieldSelector module and the need for Fieldtypes to
 * provide information about what properties can be selected, what operators, are used,
 * and so on. In the future this class will likely come in handy in providing selector
 * validation and improved help and error messaging when building/testing selectors. 
 * 
 * This file is licensed under the MIT license
 * https://processwire.com/about/license/mit/
 *
 * ProcessWire 3.x, Copyright 2020 by Ryan Cramer
 * https://processwire.com
 * 
 */
class FieldSelectorInfo extends Wire {

	/**
	 * Template of info, as returned by getSelectorInfo()
	 *
	 */
	protected $infoTemplate = array();

	/**
	 * Operators indexed by input type
	 *
	 */
	protected $operators = array();

	/**
	 * Labels for all the above operators
	 *
	 */
	protected $operatorLabels = array();

	/**
	 * CSV keywords from schema mapped to input types to auto-determine input type from schema
	 *
	 */
	protected $schemaToInput = array();

	/**
	 * Construct
	 * 
	 */
	public function __construct() {

		$ftNops = array();
		$ftOps = Selectors::getOperators(array(
			'compareType' => Selector::compareTypeFind,
			'getValueType' => 'operator',
			'getIndexType' => 'none',
		));
		
		foreach($ftOps as $op) {
			$ftNops[] = "!$op";
		}
		
		$this->operators = array(
			'number' => array('=', '!=', '>', '<', '>=', '<=', '=""', '!=""'),
			'text' => array('=', '!=', '%=', '%^=', '%$=', '=""', '!=""'),
			'fulltext' => array_merge($ftOps, array('=', '!=', '=""', '!=""'), $ftNops),
			'select' => array('=', '!=')
		);

		$this->infoTemplate = array(
			// name of the field
			'name' => '', 
			// label for this field 
			'label' => '', 
			// operators accepted
			'operators' => $this->operators['number'],
			// type of input required: text, number, date, datetime, select, page, none
			'input' => 'number', 
			// optional text hint about what to provide for input (for user)
			'hint' => '', 
			// when input=select, page or checkbox, this contains the selectable options (value => label)
			'options' => array(), 
			// if field has subfields, this contains array of all above, indexed by subfield name (blank if not applicable)
			'subfields' => array(), 
		);

		$this->schemaToInput = array(
			'TEXT,TINYTEXT,MEDIUMTEXT,LONGTEXT,VARCHAR,CHAR' => 'text', 
			'DATETIME,TIMESTAMP' => 'datetime', 
			'DATE' => 'date', 
			'INT,DECIMAL,FLOAT,DOUBLE' => 'number',
			'ENUM,SET' => 'select',
		);
	}

	/**
	 * Return array with information about what properties and operators can be used with this field
	 * 
	 * @param Field $field
	 * @return array
	 *
	 */
	public function getSelectorInfo(Field $field) {

		$info = $this->infoTemplate; 
		$info['name'] = $field->name; 
		$info['label'] = $field->label ? $field->label : $field->name; 
		$schema = $field->type->getDatabaseSchema($field);

		foreach($schema as $name => $schemaType) {

			// skip over native properties that aren't used in selectors
			if(in_array($name, array('pages_id', 'keys', 'xtra', 'sort'))) continue; 
			if(!is_string($schemaType)) continue;

			if($name == 'data') {
				// base property
				$target =& $info;
			} else {
				// subfield property
				$info['subfields'][$name] = $this->infoTemplate; 
				$target =& $info['subfields'][$name]; 
				$target['name'] = $name; 
				$target['label'] = $name; 
			}

			// determine the 'input' type based on the DB schema definition
			foreach($this->schemaToInput as $types => $input) {
				foreach(explode(',', $types) as $type) {
					if(stripos($schemaType, $type) !== 0) continue; 
					$target['input'] = $input; 
					break;
				}
			}

			// determine the operators based on the $input
			$input = $target['input'];
			if(isset($this->operators[$input])) $target['operators'] = $this->operators[$input]; 

			// determine selectable options if schema uses ENUM or SET fields
			if($input == 'select' && stripos($schemaType, 'ENUM(') !== false || stripos($schemaType, 'SET(') !== false) {
				if(preg_match('/^(ENUM|SET)\s*\(([^)]+)\)/i', $schemaType, $matches)) {
					$options = array();
					foreach(explode(',', $matches[2]) as $option) {
						$option = trim($option, '\'" '); 
						$options[$option] = $option; 
					}
					$target['options'] = $options; 
				}
			}

			// use fulltext operators if schema uses a fulltext index	
			if(isset($schema['keys'][$name])) {
				if(stripos($schema['keys'][$name], 'FULLTEXT') !== false) {
					$target['operators'] = $this->operators['fulltext'];
				}
			}
		}

		// if there are subfields, add the 'data' property back in there
		if(count($info['subfields'])) {
			$copy = $info; 
			$copy['subfields'] = array();
			$info['subfields']['data'] = $copy; 
		}

		return $info;
	}

	/**
	 * Return the default selector info template array
	 *
	 * @return array
	 *
	 */
	public function getSelectorInfoTemplate() {
		return $this->infoTemplate; 
	}

	/**
	 * Get array of operators
	 *
	 * @param string $inputType Specify: number, text, fulltext or select, or omit to return all possible operators at once
	 * @return array of operators or blank array if invalid type specified
	 *
	 */
	public function getOperators($inputType = '') {
		if(empty($inputType)) {
			$operators = array(); 
			foreach($this->operators as $o) $operators = array_merge($operators, $o); 
			return $operators; 
		}
		if(isset($this->operators[$inputType])) return $this->operators[$inputType];
		return array();
	}

	/**
	 * Get array of operators mapped to text labels
	 *
	 * @return array 
	 *
	 */
	public function getOperatorLabels() {
		if(!empty($this->operatorLabels)) return $this->operatorLabels;
		$this->operatorLabels = Selectors::getOperators(array(
			'getIndexType' => 'operator',
			'getValueType' => 'label', 
		));
		$this->operatorLabels['=""'] = $this->_('Is Empty');
		$this->operatorLabels['!=""'] = $this->_('Is Not Empty');
		foreach($this->operators as $operator) {
			if(isset($this->operatorLabels[$operator])) continue; 
			if(strpos($operator, '!') !== 0) continue;
			$op = ltrim($operator, '!'); 
			$this->operatorLabels[$operator] = sprintf($this->_('Not: %s'), $this->operatorLabels[$op]); 
		}
		return $this->operatorLabels;
	}
}
