<?php
/**
 * Base class for every field type.
 *
 * @package Fillaro
 */

namespace Fillaro\Fields;

defined( 'ABSPATH' ) || exit;

/**
 * A field type knows how to clean its settings, clean and validate a
 * submitted value, render its control, and format a stored value.
 */
abstract class FieldType {

	/**
	 * Machine name, e.g. "email".
	 *
	 * @return string
	 */
	abstract public function type();

	/**
	 * Human label.
	 *
	 * @return string
	 */
	abstract public function label();

	/**
	 * Render the input control(s). Wrapper, label and help are rendered by
	 * the form renderer.
	 *
	 * @param array $field Field config.
	 * @param array $ctx   Render context: id, name, value, describedby.
	 * @return string HTML.
	 */
	abstract public function render_control( array $field, array $ctx );

	/**
	 * Whether the field stores a value.
	 *
	 * @return bool
	 */
	public function has_value() {
		return true;
	}

	/**
	 * Whether the control is a group of inputs (fieldset + legend).
	 *
	 * @param array $field Field config.
	 * @return bool
	 */
	public function is_group( array $field = array() ) {
		unset( $field );
		return false;
	}

	/**
	 * Clean type-specific settings from the builder.
	 *
	 * @param array $raw Raw field config.
	 * @return array Clean type-specific settings only.
	 */
	public function sanitize_config( array $raw ) {
		unset( $raw );
		return array();
	}

	/**
	 * Clean a submitted value.
	 *
	 * @param mixed $raw   Unslashed input.
	 * @param array $field Field config.
	 * @return mixed
	 */
	public function sanitize_value( $raw, array $field ) {
		unset( $field );
		return is_scalar( $raw ) ? trim( sanitize_text_field( (string) $raw ) ) : '';
	}

	/**
	 * Whether a clean value counts as empty.
	 *
	 * @param mixed $value Clean value.
	 * @return bool
	 */
	public function is_empty( $value ) {
		if ( is_array( $value ) ) {
			return 0 === count(
				array_filter(
					$value,
					static function ( $v ) {
						return '' !== $v && null !== $v;
					}
				)
			);
		}
		return '' === (string) $value;
	}

	/**
	 * Validate a clean, non-empty value.
	 *
	 * @param mixed $value Clean value.
	 * @param array $field Field config.
	 * @return string Error message, or '' when valid.
	 */
	public function validate( $value, array $field ) {
		unset( $value, $field );
		return '';
	}

	/**
	 * Plain-text form of a stored value, for emails and exports.
	 *
	 * @param mixed $value Stored value.
	 * @param array $field Field config.
	 * @return string
	 */
	public function to_text( $value, array $field ) {
		unset( $field );
		if ( is_array( $value ) ) {
			return implode( ', ', array_map( 'strval', array_filter( $value, 'strlen' ) ) );
		}
		return (string) $value;
	}

	/**
	 * Build an HTML attribute string. Boolean true renders the bare name;
	 * false, null and '' are skipped.
	 *
	 * @param array $attrs Attributes.
	 * @return string
	 */
	protected function attrs( array $attrs ) {
		$out = '';
		foreach ( $attrs as $name => $value ) {
			if ( false === $value || null === $value || '' === $value ) {
				continue;
			}
			if ( true === $value ) {
				$out .= ' ' . esc_attr( $name );
				continue;
			}
			$out .= sprintf( ' %s="%s"', esc_attr( $name ), esc_attr( (string) $value ) );
		}
		return $out;
	}

	/**
	 * Common input attributes shared by single-input fields.
	 *
	 * @param array $field Field config.
	 * @param array $ctx   Render context.
	 * @return array
	 */
	protected function base_attrs( array $field, array $ctx ) {
		return array(
			'id'               => $ctx['id'],
			'name'             => $ctx['name'],
			'class'            => 'pf-input',
			'placeholder'      => isset( $field['placeholder'] ) ? $field['placeholder'] : '',
			'required'         => ! empty( $field['required'] ),
			'aria-required'    => ! empty( $field['required'] ) ? 'true' : false,
			'aria-describedby' => $ctx['describedby'],
		);
	}

	/**
	 * Clean a list of choice options.
	 *
	 * @param mixed $options Raw options.
	 * @return array<int,array{label:string,value:string}>
	 */
	protected function sanitize_options( $options ) {
		$clean = array();
		if ( ! is_array( $options ) ) {
			return $clean;
		}
		foreach ( array_slice( $options, 0, 200 ) as $option ) {
			if ( ! is_array( $option ) ) {
				continue;
			}
			$label = isset( $option['label'] ) ? sanitize_text_field( (string) $option['label'] ) : '';
			$value = isset( $option['value'] ) && '' !== (string) $option['value'] ? sanitize_text_field( (string) $option['value'] ) : $label;
			if ( '' === $label && '' === $value ) {
				continue;
			}
			$clean[] = array(
				'label' => '' === $label ? $value : $label,
				'value' => $value,
			);
		}
		return $clean;
	}

	/**
	 * Allowed option values.
	 *
	 * @param array $field Field config.
	 * @return string[]
	 */
	protected function option_values( array $field ) {
		return array_map(
			static function ( $o ) {
				return (string) $o['value'];
			},
			isset( $field['options'] ) ? $field['options'] : array()
		);
	}

	/**
	 * Label for a stored option value.
	 *
	 * @param array  $field Field config.
	 * @param string $value Stored value.
	 * @return string
	 */
	protected function option_label( array $field, $value ) {
		foreach ( isset( $field['options'] ) ? $field['options'] : array() as $o ) {
			if ( (string) $o['value'] === (string) $value ) {
				return $o['label'];
			}
		}
		return (string) $value;
	}
}