<?php

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

require_once AI_SEO_CRO_PATH . 'core/helpers.php';
require_once AI_SEO_CRO_PATH . 'analyzers/seo-analyzer.php';
require_once AI_SEO_CRO_PATH . 'analyzers/performance-analyzer.php';

class AI_SEO_CRO_Analyze_Controller {

    public static function analyze($request) {

        $seo_response = self::analyze_seo($request);

        if (empty($seo_response['success'])) {
            return $seo_response;
        }

        if (!empty($seo_response['excluded'])) {
            return array_merge($seo_response, [
                'mobile_score' => 0,
                'mobile_scores' => [],
                'mobile_metrics' => [],
                'mobile_success' => false,
                'mobile_message' => 'Performance analysis skipped for excluded SEO utility URL.',
                'desktop_score' => 0,
                'desktop_scores' => [],
                'desktop_metrics' => [],
                'desktop_success' => false,
                'desktop_message' => 'Performance analysis skipped for excluded SEO utility URL.',
                'performance_success' => false,
                'performance_message' => 'Performance analysis skipped for excluded SEO utility URL.',
            ]);
        }

        $performance_response = self::analyze_performance($request);

        return array_merge($seo_response, [
            'mobile_score' => $performance_response['mobile_score'] ?? 0,
            'mobile_scores' => $performance_response['mobile_scores'] ?? [],
            'mobile_metrics' => $performance_response['mobile_metrics'] ?? [],
            'mobile_success' => $performance_response['mobile_success'] ?? false,
            'mobile_message' => $performance_response['mobile_message'] ?? '',
            'desktop_score' => $performance_response['desktop_score'] ?? 0,
            'desktop_scores' => $performance_response['desktop_scores'] ?? [],
            'desktop_metrics' => $performance_response['desktop_metrics'] ?? [],
            'desktop_success' => $performance_response['desktop_success'] ?? false,
            'desktop_message' => $performance_response['desktop_message'] ?? '',
            'performance_success' => $performance_response['success'] ?? false,
            'performance_message' => $performance_response['message'] ?? '',
            'excluded' => $seo_response['excluded'] ?? false,
            'excluded_reason' => $seo_response['excluded_reason'] ?? '',
        ]);
    }

    public static function analyze_seo($request) {

        $url = self::get_request_url($request);

        if (!$url || !wp_http_validate_url($url)) {
            return [
                'success' => false,
                'message' => 'A valid URL is required.',
            ];
        }

        $page = ai_seo_cro_fetch_page($url);

        if (!$page['success']) {
            return [
                'success' => false,
                'message' => $page['message'] ?: 'Unable to fetch the page.',
            ];
        }

        $seo = AI_SEO_CRO_SEO_Analyzer::analyze($page['html'], $page['url'], $page);

        return [
            'success' => true,
            'url' => $page['url'],
            'score' => $seo['score'] ?? 0,
            'breakdown' => $seo['breakdown'] ?? [],
            'summary' => $seo['summary'] ?? [],
            'category_checks' => $seo['category_checks'] ?? [],
            'cro_score' => 70,
            'issues' => $seo['issues'] ?? [],
            'excluded' => $seo['excluded'] ?? false,
            'excluded_reason' => $seo['excluded_reason'] ?? '',
        ];
    }

    public static function analyze_performance($request) {

        $url = self::get_request_url($request);

        if (!$url || !wp_http_validate_url($url)) {
            return [
                'success' => false,
                'message' => 'A valid URL is required.',
                'mobile_score' => 0,
                'mobile_scores' => [],
                'mobile_metrics' => [],
                'mobile_success' => false,
                'mobile_message' => 'A valid URL is required.',
                'desktop_score' => 0,
                'desktop_scores' => [],
                'desktop_metrics' => [],
                'desktop_success' => false,
                'desktop_message' => 'A valid URL is required.',
            ];
        }

        $normalized_url = ai_seo_cro_normalize_url($url);
        $performance = AI_SEO_CRO_Performance_Analyzer::analyze($normalized_url);

        $mobile = $performance['mobile'] ?? [];
        $desktop = $performance['desktop'] ?? [];

        $mobile_success = !empty($mobile['success']);
        $desktop_success = !empty($desktop['success']);
        $success = $mobile_success || $desktop_success;
        $message = '';

        if (!$success) {
            $message = $mobile['message'] ?? $desktop['message'] ?? 'Unable to fetch Google PSI scores.';
        }

        return [
            'success' => $success,
            'message' => $message,
            'url' => $normalized_url,
            'mobile_score' => $mobile['scores']['performance'] ?? 0,
            'mobile_scores' => $mobile['scores'] ?? [],
            'mobile_metrics' => $mobile['metrics'] ?? [],
            'mobile_success' => $mobile_success,
            'mobile_message' => $mobile['message'] ?? '',
            'desktop_score' => $desktop['scores']['performance'] ?? 0,
            'desktop_scores' => $desktop['scores'] ?? [],
            'desktop_metrics' => $desktop['metrics'] ?? [],
            'desktop_success' => $desktop_success,
            'desktop_message' => $desktop['message'] ?? '',
        ];
    }

    public static function get_robots_status($request) {

        return rest_ensure_response(ai_seo_cro_get_robots_txt_status());

    }

    public static function repair_robots_txt($request) {

        $result = ai_seo_cro_update_physical_robots_txt();

        if (empty($result['success'])) {
            return new WP_Error(
                'ai_seo_cro_robots_update_failed',
                $result['message'] ?? 'Unable to update robots.txt.',
                ['status' => 500, 'data' => $result]
            );
        }

        return rest_ensure_response($result);

    }

    public static function save_robots_txt($request) {

        $params = json_decode($request->get_body(), true);
        if (!is_array($params)) {
            $params = [];
        }

        $content = isset($params['content']) ? wp_unslash((string) $params['content']) : '';
        $result = ai_seo_cro_save_robots_txt_content($content);

        if (empty($result['success'])) {
            return new WP_Error(
                'ai_seo_cro_robots_save_failed',
                $result['message'] ?? 'Unable to save robots.txt.',
                ['status' => 500, 'data' => $result]
            );
        }

        return rest_ensure_response($result);

    }

    public static function get_internal_nofollow_status($request) {

        return rest_ensure_response(ai_seo_cro_get_internal_nofollow_status());

    }

    public static function fix_internal_nofollow($request) {

        return rest_ensure_response(ai_seo_cro_fix_internal_nofollow_links());

    }

    public static function get_automatic_internal_link_repair_status($request) {

        return rest_ensure_response(ai_seo_cro_get_automatic_internal_link_repair_status());

    }

    public static function update_automatic_internal_link_repair($request) {

        $params = json_decode($request->get_body(), true);
        if (!is_array($params)) {
            $params = [];
        }

        $enabled = array_key_exists('enabled', $params) ? (bool) $params['enabled'] : true;

        return rest_ensure_response(ai_seo_cro_update_automatic_internal_link_repair($enabled));

    }

    public static function get_sitemap_status($request) {

        return rest_ensure_response(ai_seo_cro_get_sitemap_status());

    }

    public static function generate_sitemap($request) {

        return rest_ensure_response(ai_seo_cro_generate_sitemaps());

    }

    public static function get_llms_txt_status($request) {

        return rest_ensure_response(ai_seo_cro_get_llms_txt_status());

    }

    public static function generate_llms_txt($request) {

        return rest_ensure_response(ai_seo_cro_generate_llms_txt());

    }

    public static function get_canonical_status($request) {

        return rest_ensure_response(ai_seo_cro_get_canonical_fix_status());

    }

    public static function update_canonical_fix($request) {

        $params = json_decode($request->get_body(), true);
        if (!is_array($params)) {
            $params = [];
        }

        $enabled = array_key_exists('enabled', $params) ? (bool) $params['enabled'] : true;

        return rest_ensure_response(ai_seo_cro_update_canonical_fix($enabled, $params));

    }


    public static function get_force_https_status($request) {

        return rest_ensure_response(ai_seo_cro_get_force_https_status());

    }


    public static function update_force_https($request) {

        $params = json_decode($request->get_body(), true);
        if (!is_array($params)) {
            $params = [];
        }

        $enabled = array_key_exists('enabled', $params) ? (bool) $params['enabled'] : true;

        return rest_ensure_response(ai_seo_cro_update_force_https($enabled));

    }


    public static function validate_seokey($request) {

        $params = json_decode($request->get_body(), true);
        if (!is_array($params)) {
            $params = [];
        }

        $key = array_key_exists('key', $params)
            ? ai_seo_cro_update_seokey($params['key'])
            : ai_seo_cro_get_seokey();

        $result = ai_seo_cro_validate_seokey($key);

        return rest_ensure_response($result);

    }

    private static function get_request_url($request) {

        return esc_url_raw(trim((string) $request['url']));
    }
}