<?php
/**
 * Font Downloader for Maple Local Fonts.
 *
 * @package Maple_Local_Fonts
 */

if (!defined('ABSPATH')) {
    exit;
}

/**
 * Class MLF_Font_Downloader
 *
 * Handles downloading fonts from Google Fonts CSS2 API.
 */
class MLF_Font_Downloader {

    /**
     * User agent to send with requests (needed to get WOFF2 format).
     *
     * @var string
     */
    private $user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';

    /**
     * Download a font from Google Fonts.
     *
     * @param string $font_name Font family name.
     * @param array  $weights   Weights to download.
     * @param array  $styles    Styles to download.
     * @return array|WP_Error Download result or error.
     */
    public function download($font_name, $weights, $styles) {
        // Validate inputs
        if (empty($font_name) || !preg_match('/^[a-zA-Z0-9\s\-]+$/', $font_name)) {
            return new WP_Error('invalid_name', 'Invalid font name');
        }

        $weights = array_intersect(array_map('absint', $weights), [100, 200, 300, 400, 500, 600, 700, 800, 900]);
        if (empty($weights)) {
            return new WP_Error('invalid_weights', 'No valid weights specified');
        }

        $styles = array_intersect($styles, ['normal', 'italic']);
        if (empty($styles)) {
            return new WP_Error('invalid_styles', 'No valid styles specified');
        }

        // Fetch CSS from Google
        $css = $this->fetch_css($font_name, $weights, $styles);
        if (is_wp_error($css)) {
            return $css;
        }

        // Parse CSS to get font face data
        $font_faces = $this->parse_css($css, $font_name);
        if (is_wp_error($font_faces)) {
            return $font_faces;
        }

        // Download each font file
        $font_slug = sanitize_title($font_name);
        $downloaded = $this->download_files($font_faces, $font_slug);
        if (is_wp_error($downloaded)) {
            return $downloaded;
        }

        return [
            'font_name' => $font_name,
            'font_slug' => $font_slug,
            'files'     => $downloaded,
        ];
    }

    /**
     * Build Google Fonts CSS2 API URL.
     *
     * @param string $font_name Font family name.
     * @param array  $weights   Array of weights.
     * @param array  $styles    Array of styles.
     * @return string Google Fonts CSS2 URL.
     */
    private function build_url($font_name, $weights, $styles) {
        // URL-encode font name (spaces become +)
        $family = str_replace(' ', '+', $font_name);

        // Sort for consistent URLs
        sort($weights);

        $has_italic = in_array('italic', $styles, true);
        $has_normal = in_array('normal', $styles, true);

        // If only normal styles, simpler format
        if ($has_normal && !$has_italic) {
            $wght = implode(';', $weights);
            return "https://fonts.googleapis.com/css2?family={$family}:wght@{$wght}&display=swap";
        }

        // Full format with ital axis
        $variations = [];
        foreach ($weights as $weight) {
            if ($has_normal) {
                $variations[] = "0,{$weight}";
            }
            if ($has_italic) {
                $variations[] = "1,{$weight}";
            }
        }

        $variation_string = implode(';', $variations);
        return "https://fonts.googleapis.com/css2?family={$family}:ital,wght@{$variation_string}&display=swap";
    }

    /**
     * Fetch CSS from Google Fonts API.
     *
     * @param string $font_name Font family name.
     * @param array  $weights   Weights to fetch.
     * @param array  $styles    Styles to fetch.
     * @return string|WP_Error CSS content or error.
     */
    private function fetch_css($font_name, $weights, $styles) {
        $url = $this->build_url($font_name, $weights, $styles);

        // Validate URL
        if (!$this->is_valid_google_fonts_url($url)) {
            return new WP_Error('invalid_url', 'Invalid Google Fonts URL');
        }

        // CRITICAL: Must use modern browser user-agent to get WOFF2
        $response = wp_remote_get($url, [
            'timeout'    => MLF_REQUEST_TIMEOUT,
            'sslverify'  => true,
            'user-agent' => $this->user_agent,
        ]);

        if (is_wp_error($response)) {
            return new WP_Error('request_failed', $response->get_error_message());
        }

        $status = wp_remote_retrieve_response_code($response);
        if ($status === 400) {
            return new WP_Error('font_not_found', 'Font not found');
        }
        if ($status !== 200) {
            return new WP_Error('http_error', 'HTTP ' . $status);
        }

        $css = wp_remote_retrieve_body($response);
        if (empty($css)) {
            return new WP_Error('empty_response', 'Empty response from Google Fonts');
        }

        // Check CSS response size to prevent memory issues
        $max_size = defined('MLF_MAX_CSS_SIZE') ? MLF_MAX_CSS_SIZE : 512 * 1024;
        if (strlen($css) > $max_size) {
            return new WP_Error('response_too_large', 'CSS response exceeds maximum size limit');
        }

        // Verify we got WOFF2 (sanity check)
        if (strpos($css, '.woff2)') === false) {
            return new WP_Error('wrong_format', 'Did not receive WOFF2 format');
        }

        return $css;
    }

    /**
     * Parse Google Fonts CSS and extract font face data.
     *
     * @param string $css       CSS content from Google Fonts.
     * @param string $font_name Expected font family name.
     * @return array|WP_Error Array of font face data or error.
     */
    private function parse_css($css, $font_name) {
        $font_faces = [];

        // Match all @font-face blocks
        $pattern = '/@font-face\s*\{([^}]+)\}/s';
        if (!preg_match_all($pattern, $css, $matches)) {
            return new WP_Error('parse_failed', 'Could not parse CSS - no @font-face rules found');
        }

        foreach ($matches[1] as $block) {
            $face_data = $this->parse_font_face_block($block);

            if (is_wp_error($face_data)) {
                continue; // Skip malformed blocks
            }

            // Verify font family matches (security)
            if (strcasecmp($face_data['family'], $font_name) !== 0) {
                continue;
            }

            // Create unique key for weight+style combo
            $key = $face_data['weight'] . '-' . $face_data['style'];

            // Prefer latin subset (usually comes after latin-ext)
            $is_latin = $this->is_latin_subset($face_data['unicode_range']);

            // Only store if:
            // 1. We don't have this weight/style yet, OR
            // 2. This is latin and replaces non-latin
            if (!isset($font_faces[$key]) || $is_latin) {
                $font_faces[$key] = $face_data;
            }
        }

        if (empty($font_faces)) {
            return new WP_Error('no_fonts', 'No valid font faces found in CSS');
        }

        // Limit number of font faces to prevent excessive downloads
        $max_faces = defined('MLF_MAX_FONT_FACES') ? MLF_MAX_FONT_FACES : 20;
        $font_faces_array = array_values($font_faces);
        if (count($font_faces_array) > $max_faces) {
            $font_faces_array = array_slice($font_faces_array, 0, $max_faces);
        }

        return $font_faces_array;
    }

    /**
     * Parse a single @font-face block.
     *
     * @param string $block Content inside @font-face { }.
     * @return array|WP_Error Parsed data or error.
     */
    private function parse_font_face_block($block) {
        $data = [];

        // Extract font-family
        if (preg_match('/font-family:\s*[\'"]?([^;\'"]+)[\'"]?;/i', $block, $m)) {
            $data['family'] = trim($m[1]);
        } else {
            return new WP_Error('missing_family', 'Missing font-family');
        }

        // Extract font-weight
        if (preg_match('/font-weight:\s*(\d+);/i', $block, $m)) {
            $data['weight'] = $m[1];
        } else {
            return new WP_Error('missing_weight', 'Missing font-weight');
        }

        // Extract font-style
        if (preg_match('/font-style:\s*(\w+);/i', $block, $m)) {
            $data['style'] = $m[1];
        } else {
            $data['style'] = 'normal'; // Default
        }

        // Extract src URL - MUST be fonts.gstatic.com
        if (preg_match('/src:\s*url\((https:\/\/fonts\.gstatic\.com\/[^)]+\.woff2)\)/i', $block, $m)) {
            $data['url'] = $m[1];
        } else {
            return new WP_Error('missing_src', 'Missing or invalid src URL');
        }

        // Extract unicode-range (optional, for subset detection)
        if (preg_match('/unicode-range:\s*([^;]+);/i', $block, $m)) {
            $data['unicode_range'] = trim($m[1]);
        } else {
            $data['unicode_range'] = '';
        }

        return $data;
    }

    /**
     * Check if unicode-range indicates latin subset.
     *
     * @param string $range Unicode range string.
     * @return bool True if appears to be latin subset.
     */
    private function is_latin_subset($range) {
        if (empty($range)) {
            return true; // Assume latin if no range specified
        }

        // Latin subset typically includes basic ASCII range
        // and does NOT include extended Latin (U+0100+) as primary
        if (preg_match('/U\+0000/', $range) && !preg_match('/^U\+0100/', $range)) {
            return true;
        }

        return false;
    }

    /**
     * Download all font files.
     *
     * @param array  $font_faces Array of font face data.
     * @param string $font_slug  Font slug for filename.
     * @return array|WP_Error Array of downloaded file info or error.
     */
    private function download_files($font_faces, $font_slug) {
        $downloaded = [];
        $errors = [];

        foreach ($font_faces as $face) {
            $result = $this->download_single_file(
                $face['url'],
                $font_slug,
                $face['weight'],
                $face['style']
            );

            if (is_wp_error($result)) {
                $errors[] = $result->get_error_message();
                continue;
            }

            $downloaded[] = [
                'path'   => $result,
                'weight' => $face['weight'],
                'style'  => $face['style'],
            ];
        }

        // If no files downloaded, return error
        if (empty($downloaded)) {
            return new WP_Error(
                'download_failed',
                'Could not download any font files: ' . implode(', ', $errors)
            );
        }

        return $downloaded;
    }

    /**
     * Download a single WOFF2 file from Google Fonts.
     *
     * @param string $url       Google Fonts static URL.
     * @param string $font_slug Font slug for filename.
     * @param string $weight    Font weight.
     * @param string $style     Font style.
     * @return string|WP_Error Local file path or error.
     */
    private function download_single_file($url, $font_slug, $weight, $style) {
        // Validate URL is from Google
        if (!$this->is_valid_google_fonts_url($url)) {
            return new WP_Error('invalid_url', 'URL is not from Google Fonts');
        }

        // Build local filename
        $filename = sprintf('%s_%s_%s.woff2', $font_slug, $style, $weight);
        $filename = sanitize_file_name($filename);

        // Validate filename
        $filename = $this->sanitize_font_filename($filename);
        if ($filename === false) {
            return new WP_Error('invalid_filename', 'Invalid filename');
        }

        // Get destination path
        $font_dir = wp_get_font_dir();
        $destination = trailingslashit($font_dir['path']) . $filename;

        // Validate destination path before any file operations
        if (!$this->validate_font_path($destination)) {
            return new WP_Error('invalid_path', 'Invalid destination path');
        }

        // Ensure directory exists
        if (!wp_mkdir_p($font_dir['path'])) {
            return new WP_Error('mkdir_failed', 'Could not create fonts directory');
        }

        // Download file
        $response = wp_remote_get($url, [
            'timeout'    => MLF_REQUEST_TIMEOUT,
            'sslverify'  => true,
            'user-agent' => $this->user_agent,
        ]);

        if (is_wp_error($response)) {
            return new WP_Error('download_failed', 'Failed to download font file: ' . $response->get_error_message());
        }

        $status = wp_remote_retrieve_response_code($response);
        if ($status !== 200) {
            return new WP_Error('http_error', 'Font download returned HTTP ' . $status);
        }

        $content = wp_remote_retrieve_body($response);
        if (empty($content)) {
            return new WP_Error('empty_file', 'Downloaded font file is empty');
        }

        // Check font file size to prevent memory issues
        $max_size = defined('MLF_MAX_FONT_FILE_SIZE') ? MLF_MAX_FONT_FILE_SIZE : 5 * 1024 * 1024;
        if (strlen($content) > $max_size) {
            return new WP_Error('file_too_large', 'Font file exceeds maximum size limit');
        }

        // Verify it looks like a WOFF2 file (magic bytes: wOF2)
        if (substr($content, 0, 4) !== 'wOF2') {
            return new WP_Error('invalid_format', 'Downloaded file is not valid WOFF2');
        }

        // Write file using WP Filesystem
        global $wp_filesystem;
        if (empty($wp_filesystem)) {
            require_once ABSPATH . 'wp-admin/includes/file.php';
            WP_Filesystem();
        }

        if (!$wp_filesystem->put_contents($destination, $content, FS_CHMOD_FILE)) {
            return new WP_Error('write_failed', 'Could not write font file');
        }

        return $destination;
    }

    /**
     * Validate that a URL is a legitimate Google Fonts URL.
     *
     * @param string $url URL to validate.
     * @return bool True if valid Google Fonts URL.
     */
    private function is_valid_google_fonts_url($url) {
        $parsed = wp_parse_url($url);

        if (!$parsed || !isset($parsed['host'])) {
            return false;
        }

        // Only allow Google Fonts domains
        $allowed_hosts = [
            'fonts.googleapis.com',
            'fonts.gstatic.com',
        ];

        return in_array($parsed['host'], $allowed_hosts, true);
    }

    /**
     * Sanitize and validate a font filename.
     *
     * @param string $filename The filename to validate.
     * @return string|false Sanitized filename or false if invalid.
     */
    private function sanitize_font_filename($filename) {
        // WordPress sanitization first
        $filename = sanitize_file_name($filename);

        // Must have .woff2 extension
        if (pathinfo($filename, PATHINFO_EXTENSION) !== 'woff2') {
            return false;
        }

        // No path components
        if ($filename !== basename($filename)) {
            return false;
        }

        // Reasonable length
        if (strlen($filename) > 200) {
            return false;
        }

        return $filename;
    }

    /**
     * Validate that a path is within the WordPress fonts directory.
     *
     * @param string $path Full path to validate.
     * @return bool True if path is safe, false otherwise.
     */
    private function validate_font_path($path) {
        $font_dir = wp_get_font_dir();
        $fonts_path = wp_normalize_path(trailingslashit($font_dir['path']));

        // Resolve to real path (handles ../ etc)
        $real_path = realpath($path);

        // If realpath fails, file doesn't exist yet - validate the directory
        if ($real_path === false) {
            $dir = dirname($path);
            $real_dir = realpath($dir);
            if ($real_dir === false) {
                // Directory doesn't exist yet, check parent
                $parent_dir = dirname($dir);
                $real_parent = realpath($parent_dir);
                if ($real_parent === false) {
                    return false;
                }
                $real_path = wp_normalize_path($real_parent . '/' . basename($dir) . '/' . basename($path));
            } else {
                $real_path = wp_normalize_path($real_dir . '/' . basename($path));
            }
        } else {
            $real_path = wp_normalize_path($real_path);
        }

        // Must be within fonts directory
        return strpos($real_path, $fonts_path) === 0;
    }
}
