<?php
/**
 * Renders stored conditions as readable text.
 *
 * @package BlockSieve
 */

namespace BlockSieve\Admin;

use BlockSieve\Conditions\ConditionCatalog;
use BlockSieve\Conditions\ConditionRegistry;

/**
 * Turns a stored condition into a sentence a human can read, e.g.
 * "User Role is Editor, Administrator".
 *
 * Labels come from the registry and the shared ConditionCatalog, so the report
 * always speaks the same vocabulary as the editor UI.
 */
final class ConditionFormatter {

	/**
	 * Memoised option maps, keyed by catalog list name.
	 *
	 * @var array<string, array<string,string>>
	 */
	private array $maps = array();

	/**
	 * Condition registry.
	 *
	 * @var ConditionRegistry
	 */
	private ConditionRegistry $registry;

	/**
	 * Shared condition vocabulary.
	 *
	 * @var ConditionCatalog
	 */
	private ConditionCatalog $catalog;

	/**
	 * Constructor.
	 *
	 * @param ConditionRegistry $registry Condition registry.
	 * @param ConditionCatalog  $catalog  Shared condition vocabulary.
	 */
	public function __construct( ConditionRegistry $registry, ConditionCatalog $catalog ) {
		$this->registry = $registry;
		$this->catalog  = $catalog;
	}

	/**
	 * Returns the translated label for a condition type.
	 *
	 * @param string $type Condition type id.
	 * @return string
	 */
	public function type_label( string $type ): string {
		if ( $this->registry->has( $type ) ) {
			return $this->registry->get( $type )->label();
		}

		/* translators: %s: condition type identifier. */
		return sprintf( __( 'Unknown (%s)', 'blocksieve' ), $type );
	}

	/**
	 * Formats one stored condition as "<Label> <operator> <value>".
	 *
	 * @param array $condition Stored condition.
	 * @return string
	 */
	public function format( array $condition ): string {
		$type = isset( $condition['type'] ) && is_string( $condition['type'] ) ? $condition['type'] : '';

		if ( '' === $type ) {
			return __( '(condition with no type)', 'blocksieve' );
		}

		$parts    = array( $this->type_label( $type ) );
		$operator = isset( $condition['operator'] ) && is_string( $condition['operator'] )
			? $condition['operator']
			: '';
		$raw      = $condition['value'] ?? null;
		$value    = $this->format_value( $type, $raw );

		// Conditions with a single operator read better without it repeated, and
		// an unknown type with nothing to compare against has no sentence to end.
		$show_operator = '' !== $operator
			&& ( $this->registry->has( $type )
				? count( $this->registry->get( $type )->operators() ) > 1
				: '' !== $value );

		if ( $show_operator ) {
			$parts[] = $this->operator_text( $type, $operator, $raw );
		}

		if ( '' !== $value ) {
			$parts[] = $value;
		}

		return implode( ' ', array_filter( $parts, static fn( string $part ): bool => '' !== $part ) );
	}

	/**
	 * Returns the operator wording for a condition, in context.
	 *
	 * An open-ended range already names its own bound ("from January 1"), so
	 * "between from January 1" would read badly: the operator collapses to
	 * nothing, or to "not" for the negated form.
	 *
	 * @param string $type     Condition type id.
	 * @param string $operator Operator id.
	 * @param mixed  $value    Stored value.
	 * @return string
	 */
	private function operator_text( string $type, string $operator, $value ): string {
		if ( 'time-range' === $type && $this->is_open_range( $value ) ) {
			return ''; // Incomplete: described as ignored by range().
		}

		if ( 'date-range' === $type && $this->is_open_range( $value ) ) {
			return 'not_between' === $operator
				? _x( 'not', 'negated open-ended range, e.g. "not from January 1"', 'blocksieve' )
				: '';
		}

		return strtolower( $this->catalog->operator_label( $operator ) );
	}

	/**
	 * Reports whether a `{ start, end }` range is missing at least one bound.
	 *
	 * @param mixed $value Stored value.
	 * @return bool
	 */
	private function is_open_range( $value ): bool {
		if ( ! is_array( $value ) ) {
			return true;
		}

		$start = $this->text( $value['start'] ?? null );
		$end   = $this->text( $value['end'] ?? null );

		return '' === $start || '' === $end;
	}

	/**
	 * Formats every condition on a model.
	 *
	 * @param array $conditions Stored conditions.
	 * @return string[]
	 */
	public function format_all( array $conditions ): array {
		$out = array();

		foreach ( $conditions as $condition ) {
			if ( is_array( $condition ) ) {
				$out[] = $this->format( $condition );
			}
		}

		return $out;
	}

	/**
	 * Formats a condition value for display.
	 *
	 * @param string $type  Condition type id.
	 * @param mixed  $value Stored value.
	 * @return string
	 */
	private function format_value( string $type, $value ): string {
		switch ( $type ) {
			case 'logged-in':
			case 'logged-out':
				return '';

			case 'user-role':
				return $this->labelled_list( $value, 'roles' );

			case 'post-type':
				return $this->labelled_list( $value, 'postTypes' );

			case 'weekdays':
				return $this->labelled_list( $value, 'weekdays' );

			case 'archive':
				return $this->labelled_list( $value, 'archiveTypes' );

			case 'device':
				if ( is_string( $value ) && '' !== $value ) {
					$devices = array( $value ); // Legacy single-device value, still honoured on render.
				} else {
					$devices = is_array( $value ) && isset( $value['devices'] ) ? $value['devices'] : array();
				}
				return $this->labelled_list( $devices, 'devices' );

			case 'post-selection':
				return $this->post_list( $value );

			case 'date-range':
				return $this->range( $value, true );

			case 'time-range':
				return $this->range( $value, false );

			case 'url-contains':
				return $this->plain_list( $value );

			case 'query-parameter':
				return $this->query_parameter( $value );

			default:
				return $this->plain_list( $value );
		}
	}

	/**
	 * Maps stored values through a catalog option list.
	 *
	 * @param mixed  $value Stored value (array or scalar).
	 * @param string $catalog_list Catalog list name.
	 * @return string
	 */
	private function labelled_list( $value, string $catalog_list ): string {
		$map    = $this->map( $catalog_list );
		$values = is_array( $value ) ? $value : array( $value );
		$out    = array();

		foreach ( $values as $item ) {
			if ( null === $item || is_array( $item ) ) {
				continue;
			}

			$key   = (string) $item;
			$out[] = $map[ $key ] ?? $key;
		}

		return array() === $out
			? __( '(nothing selected)', 'blocksieve' )
			: implode( ', ', $out );
	}

	/**
	 * Resolves post ids to titles.
	 *
	 * @param mixed $value Stored value.
	 * @return string
	 */
	private function post_list( $value ): string {
		$ids = array_filter( array_map( 'absint', array_filter( is_array( $value ) ? $value : array( $value ), 'is_scalar' ) ) );

		if ( array() === $ids ) {
			return __( '(nothing selected)', 'blocksieve' );
		}

		$out = array();

		foreach ( $ids as $id ) {
			$title = get_the_title( $id );

			if ( '' !== trim( $title ) ) {
				$out[] = $title;
				continue;
			}

			// The post was deleted after the condition was configured.
			$out[] = sprintf(
				/* translators: %d: post id. */
				__( '#%d (missing)', 'blocksieve' ),
				$id
			);
		}

		return implode( ', ', $out );
	}

	/**
	 * Formats a `{ start, end }` value.
	 *
	 * @param mixed $value  Stored value.
	 * @param bool  $is_date Whether to format the bounds as dates.
	 * @return string
	 */
	private function range( $value, bool $is_date ): string {
		$start = is_array( $value ) ? $this->text( $value['start'] ?? null ) : '';
		$end   = is_array( $value ) ? $this->text( $value['end'] ?? null ) : '';

		if ( '' === $start && '' === $end ) {
			return __( '(no range set)', 'blocksieve' );
		}

		// A time range needs both bounds; with one missing it is ignored on render.
		if ( ! $is_date && ( '' === $start || '' === $end ) ) {
			return __( '(incomplete range, ignored)', 'blocksieve' );
		}

		if ( $is_date ) {
			$format = (string) get_option( 'date_format', 'Y-m-d' );
			$start  = '' !== $start ? (string) mysql2date( $format, $start ) : '';
			$end    = '' !== $end ? (string) mysql2date( $format, $end ) : '';
		}

		if ( '' === $start ) {
			return sprintf(
				/* translators: %s: end of a date or time range. */
				__( 'until %s', 'blocksieve' ),
				$end
			);
		}

		if ( '' === $end ) {
			return sprintf(
				/* translators: %s: start of a date or time range. */
				__( 'from %s', 'blocksieve' ),
				$start
			);
		}

		return sprintf(
			/* translators: 1: range start, 2: range end. */
			__( '%1$s – %2$s', 'blocksieve' ),
			$start,
			$end
		);
	}

	/**
	 * Formats a query-parameter value.
	 *
	 * @param mixed $value Stored value.
	 * @return string
	 */
	private function query_parameter( $value ): string {
		$key   = is_array( $value ) ? $this->text( $value['key'] ?? null ) : '';
		$param = is_array( $value ) ? $this->text( $value['value'] ?? null ) : '';

		if ( '' === $key ) {
			return __( '(no parameter name)', 'blocksieve' );
		}

		return '' === $param
			? $key
			: $key . ' = ' . $param;
	}

	/**
	 * Formats a plain list of scalars.
	 *
	 * @param mixed $value Stored value.
	 * @return string
	 */
	private function plain_list( $value ): string {
		if ( is_bool( $value ) || null === $value ) {
			return '';
		}

		if ( ! is_array( $value ) ) {
			return (string) $value;
		}

		$out = array();

		foreach ( $value as $item ) {
			if ( is_scalar( $item ) ) {
				$out[] = (string) $item;
			}
		}

		return array() === $out
			? __( '(nothing set)', 'blocksieve' )
			: implode( ', ', $out );
	}

	/**
	 * Returns a memoised value → label map for a catalog list.
	 *
	 * @param string $catalog_list Catalog list name.
	 * @return array<string,string>
	 */
	private function map( string $catalog_list ): array {
		if ( isset( $this->maps[ $catalog_list ] ) ) {
			return $this->maps[ $catalog_list ];
		}

		switch ( $catalog_list ) {
			case 'roles':
				$options = $this->catalog->role_options();
				break;
			case 'postTypes':
				$options = $this->catalog->post_type_options();
				break;
			case 'weekdays':
				$options = $this->catalog->weekday_options();
				break;
			case 'archiveTypes':
				$options = $this->catalog->archive_type_options();
				break;
			case 'devices':
				$options = $this->catalog->device_options();
				break;
			default:
				$options = array();
		}

		$this->maps[ $catalog_list ] = $this->catalog->to_map( $options );

		return $this->maps[ $catalog_list ];
	}

	/**
	 * Reads a stored scalar as text; anything else (e.g. a nested array in
	 * hand-edited markup, which the condition ignores) reads as empty.
	 *
	 * @param mixed $value Stored value.
	 * @return string
	 */
	private function text( $value ): string {
		return is_scalar( $value ) ? (string) $value : '';
	}
}