<?php
/**
 * File Type Controls Validator
 *
 * Validates uploads against File Type Controls settings (Phase 3 & 4).
 *
 * @package Gatewell
 * @since 1.5.0
 */

defined( 'ABSPATH' ) || exit;

/**
 * File Type Controls Validator Class
 *
 * @since 1.5.0
 */
class GATEWELL_File_Type_Controls_Validator {

	/**
	 * Cached settings to avoid multiple database queries.
	 *
	 * @var array|null
	 */
	private static $settings = null;

	/**
	 * Main validation entry point.
	 *
	 * Validates an upload against all File Type Controls rules.
	 *
	 * The file type toggle, MIME allow/block list and filename naming
	 * convention checks always run. The remaining validators are PRO-only and
	 * are physically removed from the free build, so no licence check is
	 * performed here.
	 *
	 * @param string $mime_type File MIME type.
	 * @param string $file_category File category (image, video, audio, document, archive).
	 * @param array  $context Upload context (post_id, user_id, location, filename, filesize).
	 * @return true|WP_Error True on success, WP_Error on failure.
	 * @since 1.5.0
	 */
	public static function validate_upload( $mime_type, $file_category, $context = array() ) {
		// Load settings once.
		self::load_settings();

		// Validate file type enabled/disabled.
		$result = self::validate_file_type_enabled( $file_category );
		if ( is_wp_error( $result ) ) {
			return $result;
		}

		// Validate MIME whitelist/blacklist.
		$result = self::validate_mime_whitelist_blacklist( $mime_type );
		if ( is_wp_error( $result ) ) {
			return $result;
		}


		// Validate naming convention.
		if ( isset( $context['filename'] ) ) {
			$result = self::validate_naming_convention( $context['filename'], $file_category );
			if ( is_wp_error( $result ) ) {
				return $result;
			}
		}

		return true;
	}

	/**
	 * Validate file type enabled/disabled toggle.
	 *
	 * @param string $category File category.
	 * @return true|WP_Error True if enabled, WP_Error if disabled.
	 * @since 1.5.0
	 */
	private static function validate_file_type_enabled( $category ) {
		// Images are always enabled (FREE feature)
		if ( 'image' === $category ) {
			return true;
		}

		$enabled = self::$settings['file_type_enabled'];

		if ( isset( $enabled[ $category ] ) && ! $enabled[ $category ] ) {
			return new WP_Error(
				'file_type_disabled',
				sprintf(
					/* translators: %s: file category name */
					__( '%s files are currently disabled. Please contact an administrator.', 'gatewell' ),
					ucfirst( $category )
				)
			);
		}

		return true;
	}

	/**
	 * Validate MIME type against whitelist/blacklist.
	 *
	 * @param string $mime_type MIME type to validate.
	 * @return true|WP_Error True if allowed, WP_Error if blocked.
	 * @since 1.5.0
	 */
	private static function validate_mime_whitelist_blacklist( $mime_type ) {
		$mode = self::$settings['mime_mode'];

		// Allow all mode - no restrictions
		if ( 'allow_all' === $mode ) {
			return true;
		}

		// Whitelist mode - only allow listed types
		if ( 'whitelist' === $mode ) {
			$whitelist = self::$settings['mime_whitelist'];
			if ( ! empty( $whitelist ) && ! in_array( $mime_type, $whitelist, true ) ) {
				return new WP_Error(
					'mime_not_whitelisted',
					sprintf(
						/* translators: %s: MIME type */
						__( 'File type "%s" is not in the allowed list.', 'gatewell' ),
						esc_html( $mime_type )
					)
				);
			}
		}

		// Blacklist mode - block listed types
		if ( 'blacklist' === $mode ) {
			$blacklist = self::$settings['mime_blacklist'];
			if ( ! empty( $blacklist ) && in_array( $mime_type, $blacklist, true ) ) {
				return new WP_Error(
					'mime_blacklisted',
					sprintf(
						/* translators: %s: MIME type */
						__( 'File type "%s" is blocked by site policy.', 'gatewell' ),
						esc_html( $mime_type )
					)
				);
			}
		}

		return true;
	}


	/**
	 * Validate filename against naming convention.
	 *
	 * @param string $filename Filename (without path).
	 * @param string $category File category.
	 * @return true|WP_Error True if valid, WP_Error if invalid.
	 * @since 1.5.0
	 */
	private static function validate_naming_convention( $filename, $category ) {
		$conventions = self::$settings['naming_conventions'];

		// If no convention for this category, allow all
		if ( empty( $conventions ) || ! isset( $conventions[ $category ] ) ) {
			return true;
		}

		$convention = $conventions[ $category ];

		// Skip if enforcement is disabled
		if ( ! isset( $convention['enforce'] ) || ! $convention['enforce'] ) {
			return true;
		}

		// Validate against pattern
		if ( isset( $convention['pattern'] ) && ! empty( $convention['pattern'] ) ) {
			$pattern = $convention['pattern'];
			if ( ! preg_match( $pattern, $filename ) ) {
				$error_message = isset( $convention['error_message'] ) && ! empty( $convention['error_message'] )
					? $convention['error_message']
					: __( 'Filename does not match the required naming convention.', 'gatewell' );

				return new WP_Error(
					'naming_convention_violation',
					$error_message
				);
			}
		}

		return true;
	}


	/**
	 * Load and cache settings.
	 *
	 * Only the options consumed by the free validators are read here. The
	 * PRO-only option reads live in their own strippable region below.
	 *
	 * @since 1.5.0
	 */
	private static function load_settings() {
		if ( null !== self::$settings ) {
			return;
		}

		self::$settings = array(
			'file_type_enabled'  => get_option( 'gatewell_file_type_enabled', array(
				'video'    => true,
				'audio'    => true,
				'document' => true,
				'archive'  => false,
			) ),
			'mime_mode'          => get_option( 'gatewell_mime_mode', 'allow_all' ),
			'mime_whitelist'     => get_option( 'gatewell_mime_whitelist', array() ),
			'mime_blacklist'     => get_option( 'gatewell_mime_blacklist', array() ),
			'naming_conventions' => get_option( 'gatewell_naming_conventions', array() ),
		);

	}

	/**
	 * Reset cached settings (useful for testing).
	 *
	 * @since 1.5.0
	 */
	public static function reset_cache() {
		self::$settings = null;
	}
}