<?php
/**
 * Licence tier and plan limits, as decided by the ReachZone licence server.
 *
 * The key is activated for this site (POST /v1/license/activate) and re-checked (GET /v1/license/status) every 12
 * hours by WP-Cron. The verified answer is cached in a transient. If the API cannot be reached, the last verified answer
 * stays valid for 7 days, then the site falls back to the free tier. A definite "no" (unknown, expired or cancelled key)
 * falls back to free at once. Shopper-facing requests never wait for the network: they read the transient or the stored
 * answer, and a refresh is scheduled in the background. The server enforces every limit again on each API call, so
 * nothing here can be talked into a higher plan by editing the shop's own database.
 *
 * The plan only decides what the ReachZone API is asked to do (build a drive-time zone, look up an address, send and
 * show unserved-demand points) and which hints the settings page shows. It never switches off anything that runs
 * inside the shop: locations, radius, drawn and postcode zones, the checker and the checkout rules are free for everyone.
 *
 * @package ReachZone
 */

namespace ReachZone;

defined( 'ABSPATH' ) || exit;

/**
 * Plan tiers.
 */
final class License {

	const FREE     = 'free';
	const PRO      = 'pro';
	const BUSINESS = 'business';
	const AGENCY   = 'agency';

	const OPTION      = 'reachzone_license_state';
	const TRANSIENT   = 'reachzone_license_status';
	const RETRY       = 'reachzone_license_retry';
	const CRON_HOOK   = 'reachzone_license_refresh';
	const CRON_NOW    = 'reachzone_license_refresh_now';
	const TTL         = 43200;  // 12 hours.
	const REFUSED_TTL = 3600;   // A refused key is looked at again after an hour (the customer may have just renewed).
	const RETRY_TTL   = 900;    // After an unreachable API, wait 15 minutes before trying again.
	const GRACE       = 604800; // 7 days.

	/**
	 * Per-request memo of the resolved status.
	 *
	 * @var array|null
	 */
	private static $memo = null;

	/**
	 * Hook the background refresh.
	 */
	public static function init() {
		add_action( self::CRON_HOOK, array( __CLASS__, 'refresh' ) );
		add_action( self::CRON_NOW, array( __CLASS__, 'refresh' ) );
		if ( '' !== Settings::get()['license_key'] && ! wp_next_scheduled( self::CRON_HOOK ) ) {
			wp_schedule_event( time() + HOUR_IN_SECONDS, 'twicedaily', self::CRON_HOOK );
		}
	}

	/**
	 * Remove the scheduled refresh (plugin deactivation).
	 */
	public static function unschedule() {
		wp_clear_scheduled_hook( self::CRON_HOOK );
		wp_clear_scheduled_hook( self::CRON_NOW );
	}

	/**
	 * Fingerprint of a key, so a stored answer is only used for the key it was issued for.
	 *
	 * @param string $key Licence key.
	 * @return string
	 */
	public static function key_hash( $key ) {
		return hash( 'sha256', strtoupper( trim( (string) $key ) ) );
	}

	/**
	 * Turn the licence server's answer into the status we store, or null when it is not a valid active licence for this
	 * site.
	 *
	 * @param mixed $response Decoded JSON from /v1/license/activate or /status.
	 * @return array|null
	 */
	public static function status_from_response( $response ) {
		if ( ! is_array( $response ) || ! isset( $response['tier'], $response['limits'] ) || ! is_array( $response['limits'] ) ) {
			return null;
		}
		if ( ! isset( $response['status'] ) || 'active' !== $response['status'] || empty( $response['site_active'] ) ) {
			return null;
		}
		$tier = (string) $response['tier'];
		if ( ! in_array( $tier, array( self::PRO, self::BUSINESS, self::AGENCY ), true ) ) {
			return null;
		}
		return array(
			'tier'       => $tier,
			'limits'     => self::limits_from_api( $response['limits'] ),
			'expires_at' => isset( $response['expires_at'] ) ? (string) $response['expires_at'] : '',
		);
	}

	/**
	 * Plugin-shaped limits from the server's limits object (null means unlimited).
	 *
	 * Keys: drive_time (the API builds drive-time zones), drive_time_locations (how many locations may have them),
	 * drive_time_zones (how many in total), max_drive_minutes, demand_map (the API stores and shows unserved demand).
	 *
	 * @param array $api Limits from the API.
	 * @return array{drive_time: bool, drive_time_locations: int, drive_time_zones: int, max_drive_minutes: int, demand_map: bool}
	 */
	public static function limits_from_api( array $api ) {
		$int = static function ( $value, $fallback ) {
			if ( null === $value ) {
				return PHP_INT_MAX;
			}
			return is_numeric( $value ) ? max( 0, (int) $value ) : $fallback;
		};
		$drive = ! empty( $api['drive_time'] );
		return array(
			'drive_time'           => $drive,
			'drive_time_locations' => $int( array_key_exists( 'drive_time_locations', $api ) ? $api['drive_time_locations'] : ( $drive ? 1 : 0 ), $drive ? 1 : 0 ),
			'drive_time_zones'     => $int( array_key_exists( 'drive_time_zones', $api ) ? $api['drive_time_zones'] : 0, 0 ),
			'max_drive_minutes'    => isset( $api['max_minutes'] ) && is_numeric( $api['max_minutes'] ) ? max( 0, (int) $api['max_minutes'] ) : 15,
			'demand_map'           => ! empty( $api['demand_map'] ),
		);
	}

	/**
	 * Decide the tier from what is cached and stored. Pure function: no WordPress calls, so it is unit tested.
	 *
	 * @param string     $key    Licence key from the settings.
	 * @param array|null $cached The transient (a fresh, verified answer), or null.
	 * @param array|null $stored The last stored answer, or null.
	 * @param int        $now    Unix time.
	 * @return array{tier: string, limits: array, source: string} source is none|cache|grace|refused|stale.
	 */
	public static function resolve( $key, $cached, $stored, $now ) {
		$free = array(
			'tier'   => self::FREE,
			'limits' => self::limits( self::FREE ),
		);
		if ( '' === trim( (string) $key ) ) {
			return $free + array( 'source' => 'none' );
		}
		$hash = self::key_hash( $key );
		foreach ( array(
			'cache' => $cached,
			'grace' => $stored,
		) as $source => $record ) {
			if ( ! is_array( $record ) || ! isset( $record['key_hash'], $record['state'] ) || $record['key_hash'] !== $hash ) {
				continue;
			}
			if ( 'refused' === $record['state'] ) {
				return $free + array( 'source' => 'refused' );
			}
			if ( 'ok' !== $record['state'] || empty( $record['tier'] ) || ! isset( $record['limits'], $record['verified_at'] ) ) {
				continue;
			}
			if ( 'grace' === $source && ( $now - (int) $record['verified_at'] ) > self::GRACE ) {
				return $free + array( 'source' => 'stale' );
			}
			return array(
				'tier'   => $record['tier'],
				'limits' => self::normalise_limits( $record['limits'], (string) $record['tier'] ),
				'source' => $source,
			);
		}
		return $free + array( 'source' => 'none' );
	}

	/**
	 * Make sure a stored limits array has every key the plugin reads. A record written by an older plugin version (with
	 * the retired "locations" and "demand_log" keys) is completed from the tier table until the next refresh.
	 *
	 * @param mixed  $limits Stored limits.
	 * @param string $tier   Tier of the record.
	 * @return array
	 */
	private static function normalise_limits( $limits, $tier ) {
		$defaults = self::limits( $tier );
		return array_merge( $defaults, array_intersect_key( is_array( $limits ) ? $limits : array(), $defaults ) );
	}

	/**
	 * The current status for this site.
	 *
	 * @return array{tier: string, limits: array, source: string}
	 */
	public static function current() {
		if ( null !== self::$memo ) {
			return self::$memo;
		}
		$key = Settings::get()['license_key'];
		if ( '' === $key ) {
			self::$memo = self::resolve( '', null, null, time() );
			return self::$memo;
		}
		$cached = get_transient( self::TRANSIENT );
		$stored = get_option( self::OPTION, null );
		$result = self::resolve( $key, is_array( $cached ) ? $cached : null, is_array( $stored ) ? $stored : null, time() );
		if ( false === $cached && ! wp_next_scheduled( self::CRON_NOW ) ) {
			// Nothing fresh: look again in the background, never while a shopper waits.
			wp_schedule_single_event( time() + 10, self::CRON_NOW );
		}
		self::$memo = $result;
		return $result;
	}

	/**
	 * Forget the per-request memo (after a refresh or in tests).
	 */
	public static function forget() {
		self::$memo = null;
	}

	/**
	 * Current site tier.
	 *
	 * @return string
	 */
	public static function tier() {
		return self::current()['tier'];
	}

	/**
	 * Limits of the current plan.
	 *
	 * @return array
	 */
	public static function current_limits() {
		return self::current()['limits'];
	}

	/**
	 * Fallback limits for a tier constant (the free tier, and the labels the settings page shows). Paid sites use the
	 * limits the server sent. These only say what the API may be asked to do.
	 *
	 * @param string $tier Tier.
	 * @return array{drive_time: bool, drive_time_locations: int, drive_time_zones: int, max_drive_minutes: int, demand_map: bool}
	 */
	public static function limits( $tier ) {
		switch ( $tier ) {
			case self::BUSINESS:
			case self::AGENCY:
				return array(
					'drive_time'           => true,
					'drive_time_locations' => 5,
					'drive_time_zones'     => PHP_INT_MAX,
					'max_drive_minutes'    => 15,
					'demand_map'           => true,
				);
			case self::PRO:
				return array(
					'drive_time'           => true,
					'drive_time_locations' => 1,
					'drive_time_zones'     => 3,
					'max_drive_minutes'    => 15,
					'demand_map'           => false,
				);
		}
		return array(
			'drive_time'           => false,
			'drive_time_locations' => 0,
			'drive_time_zones'     => 0,
			'max_drive_minutes'    => 15,
			'demand_map'           => false,
		);
	}

	/**
	 * Ask the server about the saved key and store the answer. Live network call: cron, the settings page and saving only.
	 *
	 * @param bool $force Ignore the retry back-off (saving the settings).
	 * @return array{ok: bool, message: string}
	 */
	public static function refresh( $force = false ) {
		$key = Settings::get()['license_key'];
		self::forget();
		if ( '' === $key ) {
			self::clear();
			return array(
				'ok'      => true,
				'message' => '',
			);
		}
		if ( ! $force && false !== get_transient( self::RETRY ) ) {
			return array(
				'ok'      => false,
				'message' => '',
			);
		}
		$answer = Api_Client::license_status();
		if ( ! is_wp_error( $answer ) && empty( $answer['site_active'] ) ) {
			$answer = Api_Client::license_activate( $key );
		}
		return self::store_answer( $key, $answer );
	}

	/**
	 * Settings were saved with a possibly different key: free the old activation, activate the new key now.
	 *
	 * @param string $old_key Key before saving ('' for none).
	 * @param string $new_key Key after saving.
	 * @return array{ok: bool, message: string}
	 */
	public static function apply_key( $old_key, $new_key ) {
		$old_key = strtoupper( trim( (string) $old_key ) );
		$new_key = strtoupper( trim( (string) $new_key ) );
		self::forget();
		if ( '' !== $old_key && $old_key !== $new_key ) {
			Api_Client::license_deactivate( $old_key ); // Best effort: frees the site slot for the next key.
		}
		if ( '' === $new_key ) {
			self::clear();
			return array(
				'ok'      => true,
				'message' => '',
			);
		}
		return self::store_answer( $new_key, Api_Client::license_activate( $new_key ) );
	}

	/**
	 * Write a server answer (or an error) into the stored state and the transient.
	 *
	 * @param string          $key    Key the answer is for.
	 * @param array|\WP_Error $answer Decoded response or error.
	 * @return array{ok: bool, message: string}
	 */
	private static function store_answer( $key, $answer ) {
		$hash = self::key_hash( $key );
		$now  = time();
		self::forget();
		if ( ! is_wp_error( $answer ) ) {
			$status = self::status_from_response( $answer );
			if ( null !== $status ) {
				$record = array(
					'key_hash'    => $hash,
					'state'       => 'ok',
					'tier'        => $status['tier'],
					'limits'      => $status['limits'],
					'expires_at'  => $status['expires_at'],
					'verified_at' => $now,
				);
				update_option( self::OPTION, $record, false );
				set_transient( self::TRANSIENT, $record, self::TTL );
				delete_transient( self::RETRY );
				return array(
					'ok'      => true,
					'message' => '',
				);
			}
			$answer = new \WP_Error( 'reachzone_bad_response', 'Unexpected licence response.' );
		}
		$refusals = array( 'reachzone_bad_key', 'reachzone_payment_required', 'reachzone_forbidden', 'reachzone_site_limit' );
		if ( in_array( $answer->get_error_code(), $refusals, true ) ) {
			$record = array(
				'key_hash'   => $hash,
				'state'      => 'refused',
				'reason'     => $answer->get_error_code(),
				'checked_at' => $now,
			);
			update_option( self::OPTION, $record, false );
			set_transient( self::TRANSIENT, $record, self::REFUSED_TTL );
			delete_transient( self::RETRY );
		} else {
			// The API is down or answered nonsense: keep the last verified answer (7 days of grace), try again later.
			set_transient( self::RETRY, 1, self::RETRY_TTL );
		}
		return array(
			'ok'      => false,
			'message' => self::message_for( $answer->get_error_code() ),
		);
	}

	/**
	 * Forget everything stored about a licence.
	 */
	private static function clear() {
		delete_option( self::OPTION );
		delete_transient( self::TRANSIENT );
		delete_transient( self::RETRY );
		self::forget();
	}

	/**
	 * Shop-owner-facing text for a licence error code.
	 *
	 * @param string $code WP_Error code from the API client.
	 * @return string
	 */
	public static function message_for( $code ) {
		switch ( $code ) {
			case 'reachzone_bad_key':
				return __( 'The licence key was not recognised.', 'reachzone' );
			case 'reachzone_payment_required':
				return __( 'This licence has expired. Renew the plan to use the ReachZone API services again.', 'reachzone' );
			case 'reachzone_forbidden':
				return __( 'This licence was cancelled or suspended.', 'reachzone' );
			case 'reachzone_site_limit':
				return __( 'This licence is already active on as many sites as the plan allows. Remove the key from another site first.', 'reachzone' );
		}
		return __( 'The ReachZone licence server could not be reached. Your last verified plan stays active for up to 7 days.', 'reachzone' );
	}
}