<?php
/**
 * License tier resolution and feature gating.
 *
 * @package AgentFirewall
 */

declare(strict_types=1);

namespace AgentFirewall\License;

use Closure;

defined( 'ABSPATH' ) || exit; // @codeCoverageIgnore

/**
 * Resolves the site's tier and answers whether a feature is available.
 *
 * Resolution order (ADR-14 §2):
 * 1. Dev override: WP_DEBUG, a local or development environment, and
 *    adaf_license_dev_override = 'yes' read the adaf_license_tier option.
 * 2. Freemius, when the SDK is loaded and the site is registered: a paying
 *    site by its plan, a trialing site by its trial plan, otherwise free.
 * 3. Otherwise free. A stored option grants nothing on its own - unlike
 *    webcalendar-pro, there is no option fallback for a site owner to set.
 */
class License {

	public const FREE   = 'free';
	public const PRO    = 'pro';
	public const AGENCY = 'agency';

	/**
	 * Option holding the dev-override tier. Read only under the override.
	 */
	public const TIER_OPTION = 'adaf_license_tier';

	/**
	 * Option that, on a development site under WP_DEBUG, makes TIER_OPTION
	 * win over Freemius.
	 */
	public const DEV_OVERRIDE_OPTION = 'adaf_license_dev_override';

	/**
	 * Environment types the dev override is honored in. WP_DEBUG alone is
	 * too weak a signal: it is often left on in staging and production.
	 */
	private const DEV_ENVIRONMENTS = array( 'local', 'development' );

	/**
	 * Paid tiers, highest first, each checked by exact plan name.
	 */
	private const PAID_TIERS_DESCENDING = array( self::AGENCY, self::PRO );

	/**
	 * Returns the Freemius instance, or null when the SDK is not loaded.
	 *
	 * @var Closure(): ?object
	 */
	private Closure $freemius;

	/**
	 * Whether WP_DEBUG is on.
	 */
	private bool $debug;

	/**
	 * Constructor.
	 *
	 * @param (Closure(): ?object)|null $freemius Freemius lookup; defaults to adaf_fs() when defined.
	 * @param bool|null                 $debug    WP_DEBUG; defaults to the constant.
	 */
	public function __construct( ?Closure $freemius = null, ?bool $debug = null ) {
		$this->freemius = $freemius ?? static function (): ?object {
			return function_exists( 'adaf_fs' ) ? adaf_fs() : null;
		};
		$this->debug    = $debug ?? ( defined( 'WP_DEBUG' ) && WP_DEBUG );
	}

	/**
	 * The site's current tier: one of FeatureMap::TIER_ORDER.
	 */
	public function get_tier(): string {
		if ( $this->has_dev_override() ) {
			return $this->tier_from_option();
		}

		$fs = ( $this->freemius )();
		if ( $fs instanceof \Freemius && $fs->is_registered() ) {
			return $this->tier_from_freemius( $fs );
		}

		return self::FREE;
	}

	/**
	 * Whether a feature is available on the current tier. A key FeatureMap
	 * does not declare, or one whose min_tier is off the ladder, is
	 * unavailable (fail closed) - tier_rank() would rank a typo as free.
	 *
	 * @param string $feature Feature key.
	 */
	public function is_feature_available( string $feature ): bool {
		$min_tier = FeatureMap::min_tier( $feature );
		if ( null === $min_tier || ! in_array( $min_tier, FeatureMap::TIER_ORDER, true ) ) {
			return false;
		}

		return FeatureMap::tier_rank( $this->get_tier() ) >= FeatureMap::tier_rank( $min_tier );
	}

	/**
	 * Whether the dev override is on.
	 */
	private function has_dev_override(): bool {
		return $this->debug
			&& in_array( wp_get_environment_type(), self::DEV_ENVIRONMENTS, true )
			&& 'yes' === get_option( self::DEV_OVERRIDE_OPTION, 'no' );
	}

	/**
	 * Tier from a registered Freemius site.
	 *
	 * Freemius' is_paying() is false for the whole of a trial, and during a
	 * no-card trial the licensed plan can still be free - so a trial is read
	 * from is_trial_plan(), never from is_plan(). Both checks are exact: the
	 * SDK's non-exact is_trial_plan() is true for any plan missing from its
	 * plan list, and it appends a freshly fetched trial plan after the
	 * others, so non-exact ordering could promote a Pro trial to Agency. A
	 * paying or trialing site on a plan this build does not know gets the
	 * lowest paid tier.
	 *
	 * @param \Freemius $fs Registered Freemius instance.
	 */
	private function tier_from_freemius( \Freemius $fs ): string {
		if ( $fs->is_paying() ) {
			return $this->highest_tier(
				static function ( string $tier ) use ( $fs ): bool {
					return (bool) $fs->is_plan( $tier, true );
				}
			);
		}

		if ( $fs->is_trial() ) {
			return $this->highest_tier(
				static function ( string $tier ) use ( $fs ): bool {
					return (bool) $fs->is_trial_plan( $tier, true );
				}
			);
		}

		return self::FREE;
	}

	/**
	 * The highest paid tier the site holds, or the lowest paid tier when it
	 * holds none this build knows.
	 *
	 * @param Closure(string): bool $holds Whether the site holds a tier's plan.
	 */
	private function highest_tier( Closure $holds ): string {
		foreach ( self::PAID_TIERS_DESCENDING as $tier ) {
			if ( $holds( $tier ) ) {
				return $tier;
			}
		}

		return self::PRO;
	}

	/**
	 * Tier from the stored option, under the dev override only; anything off
	 * the ladder is free.
	 */
	private function tier_from_option(): string {
		$value = get_option( self::TIER_OPTION, self::FREE );

		return is_string( $value ) && in_array( $value, FeatureMap::TIER_ORDER, true ) ? $value : self::FREE;
	}
}