<?php
namespace JVBase\registrar\fields;

use JVBase\meta\MetaTypeManager;

if (!defined('ABSPATH')) {
	exit;
}

class Field {
	protected string $name;				// field name. Will be prefixed with BASE
	protected string $type;				// field type
	protected string $label;			// define its label
	protected mixed $default;			// default value
	protected string $description;
	protected string $hint;
	protected bool $required = false;	// whether it is required
	protected bool $hidden = false;		// whether to show in the editor
	protected bool $quickEdit = true;	// whether to show in quick edit table
	protected bool $quill;				// whether to use quill
	protected int $maxLength;			// of characters
	protected int $min;
	protected int $max;
	protected string $subtype;
	protected array $condition;
	protected array $allowedSubtype = ['text', 'url','number','tel','email','number'];
	/**
	 * @var ?bool For timeline post types. Indicates whether all posts get this field, or just the parent
	 */
	protected ?bool $for_all = null;
	/**
	 * @var ?string Rather than manually defining sections, one can define which section a field belongs to here
	 */
	protected ?string $section = null;

	public function __construct(string $name, array $config) {
		$this->name = $name;
		$required = ['type', 'label'];
		foreach ($required as $r) {
			if (!array_key_exists($r, $config)) {
				error_log('[JVBase\registrar\Field] Missing required '.$r.' for field');
				return;
			}
		}
		$current = get_class($this);
		$class = match($config['type']) {
			'group'	=> ($current !== GroupedField::class) ? new GroupedField($name, $config) : $this,
			'select', 'radio', 'checkbox' => ($current !== OptionsField::class) ? new OptionsField($name, $config) : $this,
			'repeater' => ($current !== RepeaterField::class) ? new RepeaterField($name, $config) : $this,
			'taglist' => ($current !== TagListField::class) ? new TagListField($name, $config) : $this,
			'taxonomy', 'post', 'user', 'selector' => ($current !== SelectorField::class) ? new SelectorField($name, $config) : $this,
			'upload' => ($current !== UploadField::class) ? new UploadField($name, $config) : $this,
			default => $this
		};

		foreach ($config as $key => $value) {
			if (property_exists($class, $key)) {
				$method = 'set'.implode('',array_map('ucfirst',explode('_', $key)));;
				$class->$method($value);
			} else {
//				error_log('Instance: '.print_r($class, true));
				error_log('[JVBase\registrar\Field] Invalid key for '.$name.': '.$key);
			}
		}
	}

	public function setDescription(string $description):void
	{
		$this->description = $description;
	}
	public function getDescription():string
	{
		return $this->description;
	}
	public function setHint(string $hint):void
	{
		$this->hint = $hint;
	}
	public function getHint():string
	{
		return $this->hint;
	}

	public function setType(string $type):void{
		$allowed = array_keys(MetaTypeManager::getTypes());
		if (!in_array($type, $allowed)) {
			error_log('[JVBase\registrar\Field] Invalid type attempted '.$type);
			return;
		}
		$this->type = $type;
	}

	public function setLabel(string $label):void{
		$this->label = $label;
	}
	public function setRequired(bool $required):void{
		$this->required = $required;
	}
	public function setHidden(bool $hidden):void{
		$this->hidden = $hidden;
	}
	public function setQuickEdit(bool $quickEdit):void{
		$this->quickEdit = $quickEdit;
	}
	public function setDefault(mixed $default):void
	{
		$this->default = $default;
	}

	public function setQuill(bool $quill):void
	{
		$this->quill = $quill;
	}

	public function setForAll(bool $set):void
	{
		$this->for_all = $set;
	}
	public function getForAll():?bool
	{
		return $this->for_all??null;
	}
	public function setSection(string $section):void
	{
		$this->section = $section;
	}
	public function getSection():?string
	{
		return $this->section??null;
	}
	public function setMin(int $min):void
	{
		$this->min = $min;
	}
	public function getMin():?int
	{
		return $this->min??null;
	}
	public function setMax(int $max):void
	{
		$this->max = $max;
	}
	public function getMax():?int
	{
		return $this->max??null;
	}
	public function setMaxLength(int $maxLength):void
	{
		$this->maxLength = $maxLength;
	}
	public function getConfig():array{
		$config = get_object_vars($this);

		return array_map(function ($item) {
			if (is_a($item, Field::class)) {
				return $item->getConfig();
			} else if (is_array($item)) {
				$temp = [];
				foreach ($item as $k => $v) {
					if (is_a($v, Field::class)) {
						$temp[$k] = $v->getConfig();
					} else {
						$temp[$k] = $v;
					}
				}
				return $temp;
			} else {
				return $item;
			}
		}, $config);
	}
	public function setSubtype(string $subtype):void
	{
		if (!in_array($subtype, $this->allowedSubtype)) {
			error_log('[SelectorField]Attempted subtype not allowed: '.$subtype);
			return;
		}
		$this->subtype = $subtype;
	}
	public function getSubtype():string
	{
		return $this->subtype;
	}

	public function setCondition(array $condition):void
	{
		$required = ['field', 'operator', 'value'];
		foreach ($required as $field) {
			if (!array_key_exists($field, $condition)) {
				error_log('[Field]::setCondition Required condition '.$field.' not found');
				return;
			}
		}

		$this->condition = $condition;
	}
	public function getCondition(array $condition):array
	{
		return $this->condition;
	}
}