<?php
/**
 * Registry of the condition types the running build can check.
 *
 * @package Yangra\Conditional
 */

namespace Yangra\Conditional\Rules;

use Yangra\Conditional\Rules\Conditions\ArchivePage;
use Yangra\Conditional\Rules\Conditions\Condition;
use Yangra\Conditional\Rules\Conditions\PageType;
use Yangra\Conditional\Rules\Conditions\UserRole;
use Yangra\Conditional\Rules\Conditions\UserState;
use Yangra\Conditional\Rules\Conditions\VisitorDevice;

defined( 'ABSPATH' ) || exit;

/**
 * Holds the Free conditions; Pro adds its own through the
 * `yangra_conditional_condition_types` filter. Types that aren't registered
 * (Pro without a license, or unknown types) are skipped when rules are evaluated.
 */
class ConditionRegistry {

	/**
	 * Pro condition type IDs. Names only, no Pro logic, so the Free build can
	 * tell a skipped Pro condition from an unknown one.
	 */
	const PRO_TYPES = array( 'visitor_location', 'visitor_language', 'user_group' );

	/**
	 * Registered conditions, keyed by type. Null until first used.
	 *
	 * @var array<string, Condition>|null
	 */
	private $conditions = null;

	/**
	 * Returns the condition for a type, or null when it isn't registered.
	 *
	 * @param string $type Condition type ID.
	 * @return Condition|null
	 */
	public function get( string $type ): ?Condition {
		return $this->all()[ $type ] ?? null;
	}

	/**
	 * All registered conditions, keyed by type, in the order they were registered.
	 *
	 * The list is built on first use, not when the plugin boots, so conditions
	 * that Pro adds later through the filter are included.
	 *
	 * @return array<string, Condition>
	 */
	public function all(): array {
		if ( null !== $this->conditions ) {
			return $this->conditions;
		}

		$this->conditions = array();
		$free             = array();
		foreach ( array( new UserState(), new UserRole(), new PageType(), new ArchivePage(), new VisitorDevice() ) as $condition ) {
			$free[ $condition->type() ] = $condition;
		}

		/**
		 * Filters the condition types that can be checked, keyed by type ID.
		 *
		 * @param array<string, mixed> $conditions Condition objects keyed by type ID.
		 *                                         Values that aren't a Condition are ignored.
		 */
		$conditions = apply_filters( 'yangra_conditional_condition_types', $free );

		foreach ( (array) $conditions as $type => $condition ) {
			if ( $condition instanceof Condition ) {
				$this->conditions[ (string) $type ] = $condition;
			}
		}

		return $this->conditions;
	}

	/**
	 * Whether a type is one of the Pro condition types.
	 *
	 * @param string $type Condition type ID.
	 * @return bool
	 */
	public function is_pro_type( string $type ): bool {
		return in_array( $type, self::PRO_TYPES, true );
	}

	/**
	 * Translated name of a Pro condition type, for "Requires Pro, skipped" warnings.
	 *
	 * @param string $type Pro condition type ID.
	 * @return string The name, or the type ID if it isn't a Pro type.
	 */
	public function pro_type_label( string $type ): string {
		$labels = array(
			'visitor_location' => __( 'Visitor location', 'yangra-conditional' ),
			'visitor_language' => __( 'Visitor language', 'yangra-conditional' ),
			'user_group'       => __( 'User group', 'yangra-conditional' ),
		);

		return $labels[ $type ] ?? $type;
	}
}