<?php
if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

/**
 * Shared AI model configuration for settings, prompts, and API requests.
 */
class AIEditor_Model_Config {

	const RECOMMENDED_MODEL_KEY = 'm6a';
	const SOL_MODEL_KEY = 'm56';
	const TERRA_MODEL_KEY = 'm56t';
	const LUNA_MODEL_KEY = 'm56l';
	const PREVIOUS_MODEL_KEY = 'm55';
	const LEGACY_MODEL_KEY = 'm54';
	const MINI_MODEL_KEY = 'm54m';
	const DEFAULT_REASONING_EFFORT = 'low';

	/**
	 * Return supported settings keys mapped to display and API names.
	 *
	 * @return array
	 */
	public static function get_supported_models() {
		return array(
			self::RECOMMENDED_MODEL_KEY => array(
				'label'      => 'GPT-6 Astra',
				'api_name'   => 'gpt-6-astra',
				'recommended' => true,
			),
			self::SOL_MODEL_KEY => array(
				'label'      => 'GPT-5.6 Sol',
				'api_name'   => 'gpt-5.6',
				'recommended' => false,
			),
			self::TERRA_MODEL_KEY => array(
				'label'      => 'GPT-5.6 Terra',
				'api_name'   => 'gpt-5.6-terra',
				'recommended' => false,
			),
			self::LUNA_MODEL_KEY => array(
				'label'      => 'GPT-5.6 Luna',
				'api_name'   => 'gpt-5.6-luna',
				'recommended' => false,
			),
			self::PREVIOUS_MODEL_KEY => array(
				'label'      => 'GPT-5.5',
				'api_name'   => 'gpt-5.5',
				'recommended' => false,
			),
			self::LEGACY_MODEL_KEY => array(
				'label'      => 'GPT-5.4',
				'api_name'   => 'gpt-5.4',
				'recommended' => false,
			),
			self::MINI_MODEL_KEY => array(
				'label'      => 'GPT-5.4 mini',
				'api_name'   => 'gpt-5.4-mini',
				'recommended' => false,
			),
		);
	}

	/**
	 * Return supported reasoning-effort options.
	 *
	 * @return array
	 */
	public static function get_reasoning_effort_options() {
		return array(
			'none'    => 'None',
			'low'     => 'Low',
			'medium'  => 'Medium',
			'high'    => 'High',
		);
	}

	/**
	 * Return supported reasoning-effort keys.
	 *
	 * @return array
	 */
	public static function get_reasoning_effort_keys() {
		return array_keys( self::get_reasoning_effort_options() );
	}

	/**
	 * Return the default reasoning-effort key.
	 *
	 * @return string
	 */
	public static function get_default_reasoning_effort() {
		return self::DEFAULT_REASONING_EFFORT;
	}

	/**
	 * Resolve a saved reasoning effort to a value supported by the API model.
	 *
	 * @param string $effort_key Saved reasoning-effort key.
	 * @param string $openai_model OpenAI API model name.
	 * @return string
	 */
	public static function normalize_reasoning_effort( $effort_key, $openai_model ) {
		if ( ! in_array( $effort_key, self::get_reasoning_effort_keys(), true ) || ( 'gpt-6-astra' === $openai_model && 'none' === $effort_key ) ) {
			return self::DEFAULT_REASONING_EFFORT;
		}

		return $effort_key;
	}

	/**
	 * Return the display label for a reasoning-effort key.
	 *
	 * @param string $effort_key Saved reasoning-effort key.
	 * @return string
	 */
	public static function get_reasoning_effort_label( $effort_key ) {
		$options = self::get_reasoning_effort_options();
		return isset( $options[ $effort_key ] ) ? $options[ $effort_key ] : $options[ self::DEFAULT_REASONING_EFFORT ];
	}

	/**
	 * Return the OpenAI HTTP timeout window for a reasoning-effort key.
	 *
	 * @param string $effort_key Saved reasoning-effort key.
	 * @return int Timeout in seconds.
	 */
	public static function get_openai_timeout_for_reasoning_effort( $effort_key ) {
		$timeouts = array(
			'none'   => 60,
			'low'    => 120,
			'medium' => 180,
			'high'   => 240,
		);

		return isset( $timeouts[ $effort_key ] ) ? $timeouts[ $effort_key ] : $timeouts[ self::DEFAULT_REASONING_EFFORT ];
	}

	/**
	 * Return the note shown for reasoning-effort settings.
	 *
	 * @return string
	 */
	public static function get_reasoning_effort_note() {
		return 'Controls how much deliberate reasoning the model uses before responding. None is fastest on models that support it; GPT-6 Astra uses Low when None is selected. Low can improve reliability with modest latency. Higher values can help harder tasks but cost more tokens and time.';
	}

	/**
	 * Return supported model keys.
	 *
	 * @return array
	 */
	public static function get_supported_model_keys() {
		return array_keys( self::get_supported_models() );
	}

	/**
	 * Return the recommended model key.
	 *
	 * @return string
	 */
	public static function get_recommended_model_key() {
		return self::RECOMMENDED_MODEL_KEY;
	}

	/**
	 * Return the recommended model label.
	 *
	 * @return string
	 */
	public static function get_recommended_model_label() {
		return self::get_model_label( self::RECOMMENDED_MODEL_KEY );
	}

	/**
	 * Return the mini model label.
	 *
	 * @return string
	 */
	public static function get_mini_model_label() {
		return self::get_model_label( self::MINI_MODEL_KEY );
	}

	/**
	 * Return the display label for a model key.
	 *
	 * @param string $model_key Stored model key.
	 * @return string
	 */
	public static function get_model_label( $model_key ) {
		$models = self::get_supported_models();
		return isset( $models[ $model_key ]['label'] ) ? $models[ $model_key ]['label'] : self::get_recommended_model_label();
	}

	/**
	 * Return the OpenAI API model name for a model key.
	 *
	 * @param string $model_key Stored model key.
	 * @return string
	 */
	public static function get_openai_model_name( $model_key ) {
		$models = self::get_supported_models();
		return isset( $models[ $model_key ]['api_name'] ) ? $models[ $model_key ]['api_name'] : $models[ self::RECOMMENDED_MODEL_KEY ]['api_name'];
	}

	/**
	 * Return the standard supported-models settings message.
	 *
	 * @return string
	 */
	public static function get_supported_models_message() {
		$model_labels = array_map(
			function ( $model ) {
				return $model['label'];
			},
			self::get_supported_models()
		);

		return sprintf(
			'AI Editor now supports only %1$s. Update the model in Settings -> AI Editor.',
			implode( ', ', $model_labels )
		);
	}

	/**
	 * Return the recommendation note shown in settings.
	 *
	 * @return string
	 */
	public static function get_recommended_model_note() {
		return sprintf(
			'Use %1$s for the strongest layout and instruction-following quality. Terra and Luna are more cost-efficient, but may perform less reliably on complex layouts or nuanced requests.',
			self::get_recommended_model_label()
		);
	}
}