<?php namespace ProcessWire;

/**
 * ProcessWire Text Fieldtype
 *
 * Basic Field that stores text, typically a single line. 
 *
 * For documentation about the fields used in this class, please see:  
 * /wire/core/Fieldtype.php
 * 
 * ProcessWire 3.x, Copyright 2023 by Ryan Cramer
 * https://processwire.com
 *
 *
 */

class FieldtypeText extends Fieldtype {

	public static function getModuleInfo() {
		return array(
			'title' => 'Text',
			'version' => 102,
			'summary' => 'Field that stores a single line of text',
			'permanent' => true, 
		);
	}

	/**
	 * Are text formatters allowed for this Fieldtype?
	 *
	 * Descending classes can override with the allowTextFormatters(false) method. 
	 *
	 */
	private $allowTextFormatters = true; 

	/**
	 * Provides a way for descending classes to disable text formatters where they aren't applicable
	 *
	 * @param bool|null $allow True to allow them, false to disallow or NULL not to do anything
	 * @return bool Current state of $allowTextFormatters
	 *
	 */
	protected function allowTextFormatters($allow = null) {
		if(!is_null($allow)) $this->allowTextFormatters = $allow ? true : false;
		return $this->allowTextFormatters; 
	}

	/**
	 * Return all Fieldtypes derived from FieldtypeText, which we will consider compatible
	 * 
	 * @param Field $field
	 * @return Fieldtypes
	 *
	 */
	public function ___getCompatibleFieldtypes(Field $field) {
		$fieldtypes = $this->wire(new Fieldtypes());
		foreach($this->wire()->fieldtypes as $fieldtype) {
			if($fieldtype instanceof FieldtypeText) {
				$fieldtypes->add($fieldtype);
			} else {
				$className = $fieldtype->className();
				if($className == 'FieldtypeSelector') $fieldtypes->add($fieldtype);
			}
		}
		return $fieldtypes; 
	}

	/**
	 * Sanitize value for storage
	 * 
	 * @param Page $page
	 * @param Field $field
	 * @param string $value
	 * @return string
	 *
	 */
	public function sanitizeValue(Page $page, Field $field, $value) {
		return $value; 
	}

	/**
	 * Format value for output
	 * 
	 * @param Page $page
	 * @param Field $field
	 * @param string $value
	 * @return string
	 *
	 */
	public function ___formatValue(Page $page, Field $field, $value) {

		$value = (string) $value; 
		$textformatters = $field->get('textformatters');

		if($this->allowTextFormatters() && is_array($textformatters)) {
			$modules = $this->wire()->modules;
			foreach($textformatters as $name) {
				/** @var Textformatter $textformatter */
				$textformatter = $modules->get($name);
				if($textformatter) $textformatter->formatValue($page, $field, $value); 
			}
		}

		return $value; 
	}

	/**
	 * Return whether the given value is considered empty or not
	 *
	 * This an be anything that might be present in a selector value and thus is
	 * typically a string. However, it may be used outside of that purpose so you
	 * shouldn't count on it being a string.
	 *
	 * @param Field $field
	 * @param mixed $value
	 * @return bool
	 *
	 */
	public function isEmptyValue(Field $field, $value) {
		return !strlen("$value"); 
	}

	/**
	 * Return the associated Inputfield
	 * 
	 * @param Page $page
	 * @param Field $field
	 * @return Inputfield
	 *
	 */
	public function getInputfield(Page $page, Field $field) {
		$modules = $this->wire()->modules;
		$inputfieldClass = $field->get('inputfieldClass');
		/** @var Inputfield $inputfield */
		$inputfield = $inputfieldClass ? $modules->getModule($inputfieldClass) : null;
		if(!$inputfield) $inputfield = $modules->get('InputfieldText');
		return $inputfield;
	}

	/**
	 * Update a query to match the text with a fulltext index
	 * 
	 * @param PageFinderDatabaseQuerySelect $query
	 * @param string $table
	 * @param string $subfield
	 * @param string $operator
	 * @param int|string $value
	 * @return DatabaseQuerySelect
	 *
	 */
	public function getMatchQuery($query, $table, $subfield, $operator, $value) {
		$ft = new DatabaseQuerySelectFulltext($query); 
		$ft->match($table, $subfield, $operator, $value); 
		return $query; 
	}

	/**
	 * Return the database schema in specified format
	 * 
	 * @param Field $field
	 * @return array
	 *
	 */
	public function getDatabaseSchema(Field $field) {
		$schema = parent::getDatabaseSchema($field);
		$len = $this->wire()->database->getMaxIndexLength();
		$schema['data'] = 'text NOT NULL';
		$schema['keys']['data_exact'] = "KEY `data_exact` (`data`($len))"; 
		$schema['keys']['data'] = 'FULLTEXT KEY `data` (`data`)'; 
		return $schema;
	}

	/**
	 * Hook called when field is about to be saved
	 *
	 * @param Field $field
	 * @since 3.0.212
	 *
	 */
	public function ___saveFieldReady(Field $field) {
		parent::___saveFieldReady($field);
		if(!$field->id && $this->allowTextFormatters() && $this->wire()->page->process == 'ProcessField') {
			// default Textformatter for newly created fields in ProcessField
			$value = $field->get('textformatters');
			if(!is_array($value) || !count($value)) {
				$field->set('textformatters', array('TextformatterEntities'));
			}
		}
	}

	/**
	 * Return the fields required to configure an instance of FieldtypeText
	 * 
	 * @param Field $field
	 * @return InputfieldWrapper
	 *
	 */
	public function ___getConfigInputfields(Field $field) {
		$inputfields = parent::___getConfigInputfields($field);
		if(!$this->allowTextFormatters()) return $inputfields;
		
		$modules = $this->wire()->modules;
		$textformatters = $modules->findByPrefix('Textformatter');
		
		if(!count($textformatters)) return $inputfields;
		
		/** @var InputfieldFieldset $fieldset */
		$fieldset = $modules->get('InputfieldFieldset');
		$fieldset->attr('name', '_text_fieldset');
		$fieldset->label = $this->_('Text settings');
		$fieldset->icon = 'text-width';
		$inputfields->add($fieldset);
		
		/** @var InputfieldAsmSelect $f */
		$f = $modules->get('InputfieldAsmSelect'); 
		$f->attr('name', 'textformatters'); 
		$f->label = $this->_('Text formatters');

		foreach($textformatters as $moduleName) {
			$info = $modules->getModuleInfo($moduleName);
			$f->addOption($moduleName, "$info[title]"); 
		}

		$value = $field->get('textformatters');
		if(!is_array($value)) $value = array();
		$f->val($value);
		$f->description = 
			$this->_('If you want to apply any automatic formatting to the field when it is prepared for output, select one or more text formatters here.') . ' ' . 
			$this->_('If you select more than one, drag them into the order they should be applied.') . ' ' . 
			sprintf($this->_('Find more in the [text formatter modules directory](%s).'), 'https://processwire.com/modules/category/textformatter/');
		$f->notes = 
			$this->_('For plain text fields that will not contain HTML or markup, we recommend selecting the **HTML Entity Encoder** option above.');
		$fieldset->add($f);
		
		if(!in_array('TextformatterEntities', $value) && $this->allowTextformatters() && !$this->wire()->input->is('post')) {
			// warn user when HTML is allowed and we aren’t sure they intend to allow it
			$allowHTML = false;
			if(wireInstanceOf($field->type, 'FieldtypeTextarea')) {
				$inputType = $field->get('inputfieldClass');
				$htmlInputTypes = array('InputfieldTinyMCE', 'InputfieldCKEditor'); 
				$contentType = $field->get('contentType');
				$allowHTML = in_array($inputType, $htmlInputTypes) || $contentType >= FieldtypeTextarea::contentTypeHTML;
			}
			if(!$allowHTML) {
				$htmlValue = '<p>HTML</p>';
				foreach($value as $textformatter) {
					/** @var Textformatter $textformatter */
					$textformatter = $modules->get($textformatter);
					if($textformatter) $textformatter->format($htmlValue);
				}
				if(strpos($htmlValue, '<') !== false) $this->warning(
					$this->_('This field currently allows Markup/HTML in formatted output.') . ' ' . 
					$this->_('If you do not intend to allow Markup/HTML, please select the “HTML Entity Encoder” for “Text formatters”.')
				);
			}
		}

		if($field->type->className() === 'FieldtypeText') {
			/** @var InputfieldSelect $f */
			$defaultLabel = $this->_('Default'); 
			$f = $modules->get('InputfieldRadios');
			$f->attr('name', 'inputfieldClass');
			$f->label = $this->_('Input module');
			$f->description = $this->_('Save after changing this as it may affect what settings are available on the “Input” tab.'); 
			$f->addOption('', $this->_('Text') . " [span.detail] - $defaultLabel [/span]");
			foreach($modules->findByPrefix('Inputfield', 2) as $moduleName => $moduleInfo) {
				if($moduleName === 'InputfieldText') continue;
				if(stripos($moduleName, 'textarea') !== false) continue;
				if(!wireInstanceOf($moduleName, 'InputfieldHasTextValue')) continue;
				$f->addOption($moduleName, "$moduleInfo[title] [span.detail] - $moduleInfo[summary] [/span]"); 
			}
			$f->val((string) $field->get('inputfieldClass')); 
			$f->collapsed = Inputfield::collapsedBlank;
			$fieldset->add($f);
		}

		return $inputfields; 
	}

	/**
	 * Convert an array of exported data to a format that will be understood internally
	 *
	 * @param Field $field
	 * @param array $data
	 * @return array Data as given and modified as needed. Also included is $data[errors], an associative array
	 *	indexed by property name containing errors that occurred during import of config data.
	 *
	 */
	public function ___importConfigData(Field $field, array $data) {
		if(isset($data['textformatters']) && is_array($data['textformatters'])) {
			$errors = array();
			foreach($data['textformatters'] as $className) {
				if(!$this->wire()->modules->isInstalled($className)) {
					$errors[] = "Requires module '$className' to be installed";
				}
			}
			if(count($errors)) $data['errors']['textformatters'] = implode(" \n", $errors); 
		}
		return $data;
	}
	
	/**
	 * Import value
	 *
	 * @param Page $page
	 * @param Field $field
	 * @param array|int|object|string $value
	 * @param array $options
	 * @return array|string
	 *
	 */
	public function ___importValue(Page $page, Field $field, $value, array $options = array()) {
		if(is_array($value) && isset($value['default']) && !$this->wire()->languages) {
			// multi-language value to non-multi-language site, use only default language
			$value = $value['default'];
		}
		$value = parent::___importValue($page, $field, $value, $options);
		return $value;
	}

}