<?php
/**
 * Feature registry.
 *
 * @package Adminkeep
 */

namespace Adminkeep;

defined( 'ABSPATH' ) || exit;

/**
 * Holds the registered features and boots only the enabled ones.
 *
 * A disabled feature costs one array lookup: no hooks, no assets, no queries. That is directly
 * testable and it is tested — see tests/ZeroHookTest.php.
 */
class FeatureRegistry {

	/**
	 * Registered features, keyed by id.
	 *
	 * @var Feature[]
	 */
	private $features = array();

	/**
	 * Group key for each registered feature id.
	 *
	 * @var string[]
	 */
	private $groups = array();

	/**
	 * Ids of the features that were actually booted.
	 *
	 * @var string[]
	 */
	private $booted = array();

	/**
	 * Register a feature.
	 *
	 * @param Feature $feature Feature instance.
	 * @param string  $group   Group key the feature belongs to. Defaults to the lock group so a
	 *                         caller that predates grouping still registers successfully.
	 * @return void
	 */
	public function register( Feature $feature, $group = 'site_lock' ) {
		$this->features[ $feature->id() ] = $feature;
		$this->groups[ $feature->id() ]   = $group;
	}

	/**
	 * Registered features split into their groups, in registration order.
	 *
	 * Groups with no registered features are omitted, so a build that ships only the locks
	 * renders one heading rather than an empty second one.
	 *
	 * @return array<string, Feature[]> Group key => features keyed by id.
	 */
	public function grouped() {
		$grouped = array();

		foreach ( $this->features as $id => $feature ) {
			$group = isset( $this->groups[ $id ] ) ? $this->groups[ $id ] : 'site_lock';

			$grouped[ $group ][ $id ] = $feature;
		}

		return $grouped;
	}

	/**
	 * All registered features.
	 *
	 * @return Feature[]
	 */
	public function all() {
		return $this->features;
	}

	/**
	 * Get one registered feature.
	 *
	 * @param string $feature_id Feature id.
	 * @return Feature|null
	 */
	public function get( $feature_id ) {
		return isset( $this->features[ $feature_id ] ) ? $this->features[ $feature_id ] : null;
	}

	/**
	 * Ids of features that were booted.
	 *
	 * @return string[]
	 */
	public function booted() {
		return $this->booted;
	}

	/**
	 * Boot every enabled feature.
	 *
	 * Unknown feature ids in stored settings are ignored rather than fatal — a downgrade or a
	 * removed feature must not take the site down.
	 *
	 * @return void
	 */
	public function boot() {
		foreach ( $this->features as $id => $feature ) {
			if ( ! Settings::is_enabled( $id ) ) {
				continue;
			}

			$feature->boot( $this->resolve_settings( $feature ) );

			$this->booted[] = $id;
		}
	}

	/**
	 * Merge stored values over the feature's schema defaults.
	 *
	 * A stored value of the wrong shape falls back to the default instead of persisting.
	 *
	 * @param Feature $feature Feature instance.
	 * @return array
	 */
	public function resolve_settings( Feature $feature ) {
		$stored   = Settings::get( $feature->id() );
		$resolved = array();

		foreach ( $feature->settings_schema() as $key => $spec ) {
			$default = isset( $spec['default'] ) ? $spec['default'] : null;
			$type    = isset( $spec['type'] ) ? $spec['type'] : 'string';

			if ( ! array_key_exists( $key, $stored ) ) {
				$resolved[ $key ] = $default;
				continue;
			}

			$resolved[ $key ] = $this->coerce( $stored[ $key ], $type, $default );
		}

		return $resolved;
	}

	/**
	 * Coerce a stored value to its declared type, falling back to the default.
	 *
	 * @param mixed  $value   Stored value.
	 * @param string $type    Declared type.
	 * @param mixed  $default Declared default.
	 * @return mixed
	 */
	private function coerce( $value, $type, $default ) {
		switch ( $type ) {
			case 'bool':
				return (bool) $value;

			case 'int':
				return is_numeric( $value ) ? (int) $value : $default;

			case 'array':
				return is_array( $value ) ? $value : $default;

			case 'string':
			default:
				return is_scalar( $value ) ? (string) $value : $default;
		}
	}
}