<?php

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

/**
 * Analyze content quality and determine AI processing level
 * 
 * Advanced content quality scoring system (0-100) that evaluates content
 * based on length, readability, and other factors to determine the appropriate
 * level of AI processing to apply.
 * 
 * @param string $content The content to analyze
 * @param string $title Optional title for additional context
 * @return array Array containing quality score and processing recommendations
 */
function airsrefe_analyze_content_quality($content, $title = '') {
    $score = 0;
    $content_clean = wp_strip_all_tags($content);
    $length = mb_strlen($content_clean);
    
    if ($length < 200) return 0;
    if ($length > 3000) $score += 20;
    elseif ($length > 1500) $score += 15;
    elseif ($length > 800) $score += 10;
    elseif ($length > 400) $score += 5;
    
    $paragraphs = explode("\n", $content_clean);
    $paragraph_count = count(array_filter($paragraphs, function($p) { return trim($p) !== ''; }));
    if ($paragraph_count > 5) $score += 15;
    elseif ($paragraph_count > 3) $score += 10;
    elseif ($paragraph_count > 1) $score += 5;
    
    $sentences = preg_split('/[.!?]+/', $content_clean);
    $sentence_count = count(array_filter($sentences));
    $avg_sentence_length = $sentence_count > 0 ? $length / $sentence_count : 0;
    if ($avg_sentence_length > 80 && $avg_sentence_length < 200) $score += 15;
    elseif ($avg_sentence_length > 50) $score += 10;
    elseif ($avg_sentence_length > 20) $score += 5;
    
    $valuable_keywords = [
        'analysis', 'research', 'study', 'report', 'data', 'statistics', 'findings',
        'technology', 'innovation', 'development', 'solution', 'method', 'approach',
        'strategy', 'insights', 'trends', 'market', 'industry', 'expert', 'professional',
        'detailed', 'comprehensive', 'advanced', 'specialized', 'technical', 'scientific'
    ];
    
    $keyword_matches = 0;
    foreach ($valuable_keywords as $keyword) {
        if (stripos($content_clean, $keyword) !== false) {
            $keyword_matches++;
        }
    }
    $score += min(20, $keyword_matches * 2);
    
    $spam_indicators = [
        'buy now', 'click here', 'limited time', 'special offer', 'discount', 'sale',
        'free shipping', 'call now', 'order today', 'best price', 'guaranteed',
        'amazing deal', 'don\'t miss', 'act fast', 'exclusive', 'bonus'
    ];
    
    $spam_count = 0;
    foreach ($spam_indicators as $spam) {
        if (stripos($content_clean, $spam) !== false) {
            $spam_count++;
        }
    }
    if ($spam_count > 3) $score -= 30;
    elseif ($spam_count > 1) $score -= 15;
    
    $tech_patterns = [
        '/\b\d+%\b/',
        '/\$\d+/',
        '/\b(API|SQL|HTTP|JSON|XML|CSS|HTML|PHP|JS)\b/i',
        '/\b\d{4}\b/',
        '/\b\d+(\.\d+)?\s*(million|billion|thousand)\b/i'
    ];
    
    $tech_score = 0;
    foreach ($tech_patterns as $pattern) {
        if (preg_match($pattern, $content_clean)) {
            $tech_score += 2;
        }
    }
    $score += min(10, $tech_score);
    
    if (!empty($title)) {
        $title_length = mb_strlen($title);
        if ($title_length > 30 && $title_length < 80) $score += 5;
        if (preg_match('/[?:]/', $title)) $score += 3;
        if (!preg_match('/\b(top|best|amazing|incredible)\b/i', $title)) $score += 2;
    }
    
    $common_phrases = ['lorem ipsum', 'copy and paste', 'placeholder text'];
    $originality_penalty = 0;
    foreach ($common_phrases as $phrase) {
        if (stripos($content_clean, $phrase) !== false) {
            $originality_penalty += 5;
        }
    }
    $score -= $originality_penalty;
    
    return max(0, min(100, $score));
}

/**
 * OPTIMIZATION: Check content similarity against recent posts
 */
function airsrefe_check_content_similarity($content, $days = 7) {
    $cache_key = 'airsrefe_similarity_' . md5($content);
    $cached = wp_cache_get($cache_key, 'airsrefe_plugin');
    if ($cached !== false) {
        airsrefe_track_cache_hit();
        return $cached;
    }
    
    airsrefe_track_cache_miss();
    
    // Use a more efficient approach with PHP filtering
    $recent_posts = get_posts([
        'post_type' => 'post',
        'posts_per_page' => 100, // Get more posts to filter
        'fields' => 'ids',
        'no_found_rows' => true,
        'update_post_meta_cache' => false,
        'update_post_term_cache' => false,
        'cache_results' => false
    ]);
    
    // Filter posts by processed date in PHP (more efficient)
    $filtered_posts = [];
    $cutoff_date = gmdate('Y-m-d H:i:s', strtotime("-{$days} days"));
    
    foreach ($recent_posts as $post_id) {
        $processed_date = get_post_meta($post_id, '_airsrefe_processed_date', true);
        if (!empty($processed_date) && $processed_date >= $cutoff_date) {
            $filtered_posts[] = $post_id;
        }
    }
    
    $content_hash = md5(wp_strip_all_tags($content));
    $similar_found = false;
    
    foreach ($filtered_posts as $post_id) {
        $existing_hash = get_post_meta($post_id, '_airsrefe_content_hash', true);
        if ($existing_hash && $existing_hash === $content_hash) {
            $similar_found = true;
            break;
        }
        
        $existing_content = get_post_field('post_content', $post_id);
        if ($existing_content) {
            $existing_clean = wp_strip_all_tags($existing_content);
            $similarity = similar_text($content, $existing_clean, $percent);
            if ($percent > 80) {
                $similar_found = true;
                break;
            }
        }
    }
    
    wp_cache_set($cache_key, $similar_found, 'airsrefe_plugin', 3600);
    return $similar_found;
}

/**
 * OPTIMIZATION: Enhanced content filtering before AI processing
 */
function airsrefe_should_process_with_ai_enhanced($title, $content) {
    $quality_score = airsrefe_analyze_content_quality($content, $title);
    
    if ($quality_score < 30) {
        airsrefe_append_log("Content quality too low: {$quality_score}/100 - skipping AI processing");
        return false;
    }
    
    if (airsrefe_check_content_similarity($content)) {
        airsrefe_append_log("Similar content found recently - skipping to avoid duplicates");
        return false;
    }
    
    $content_length = mb_strlen(wp_strip_all_tags($content));
    if ($content_length < 150) {
        airsrefe_append_log("Content too short ({$content_length} chars) - skipping AI processing");
        return false;
    }
    
    return true;
}

function airsrefe_log_processing_result($original_title, $unique_title, $model, $success) {
$logs = get_option('airsrefe_logs', []);
$logs[] = [
'date' => current_time('mysql'),
'original' => mb_substr($original_title, 0, 100),
'unique' => mb_substr($unique_title, 0, 100),
'model' => $model,
'success' => $success
];

if (count($logs) > 50) {
$logs = array_slice($logs, -50);
}
update_option('airsrefe_logs', $logs);
airsrefe_append_log(($success ? 'SUCCESS' : 'FAILED') . ' - ' . $original_title);
}

function airsrefe_generate_ai_post_enhanced($title, $content, $task_type = 'content', $priority = null) {
$original_title = $title;
$unique_title = $title;
$unique_content = $content;
$success = false;

if (!$priority) {
$priority = airsrefe_get_processing_priority();
}

if (get_option('airsrefe_block_parsing') == 1) {
airsrefe_append_log('Parsing blocked due to insufficient quota or budget limit');
airsrefe_log_processing_result($original_title, $unique_title, 'blocked', false);
return ['title' => $title, 'content' => $content . "\n\n<!-- Parsing blocked -->"];
}

if (!airsrefe_should_process_with_ai_enhanced($title, $content)) {
    airsrefe_append_log('Content filtered out - not suitable for AI processing');
    return ['title' => $title, 'content' => $content];
}

$model = airsrefe_smart_model_selection($content, $task_type, $title);
$budget_mode = airsrefe_get_budget_mode();

if ($model === false) {
    airsrefe_append_log('Content quality too low - skipping AI processing entirely');
    return ['title' => $title, 'content' => $content];
}

$predicted_cost = airsrefe_predict_request_cost($content, $title, $task_type, $model);
if (!airsrefe_check_budget_with_prediction($predicted_cost)) {
    airsrefe_append_log('Request blocked due to budget prediction - downgrading or skipping');
    
    if ($model === 'gpt-5') {
        $model = 'gpt-5-mini';
        $predicted_cost = airsrefe_predict_request_cost($content, $title, $task_type, $model);
        if (!airsrefe_check_budget_with_prediction($predicted_cost)) {
            return ['title' => $title, 'content' => $content . "\n\n<!-- Budget limit reached -->"];
        }
    } elseif ($model === 'gpt-5-mini') {
        $model = 'gpt-5-nano';
        $predicted_cost = airsrefe_predict_request_cost($content, $title, $task_type, $model);
        if (!airsrefe_check_budget_with_prediction($predicted_cost)) {
            return ['title' => $title, 'content' => $content . "\n\n<!-- Budget limit reached -->"];
        }
    } else {
        return ['title' => $title, 'content' => $content . "\n\n<!-- Budget limit reached -->"];
    }
}

airsrefe_check_budget_alerts();

airsrefe_append_log("Smart model selection: {$model} for {$task_type} (budget mode: {$budget_mode}, predicted cost: $" . number_format($predicted_cost, 4) . ")");

try {
if (!airsrefe_check_circuit_breaker('openai')) {
    airsrefe_append_log('OpenAI API blocked by circuit breaker - using fallback processing');
    return airsrefe_fallback_processing($title, $content, 'circuit_breaker_open');
}

$api_key = airsrefe_get_api_key();
if (empty($api_key)) {
    airsrefe_append_log('OpenAI API Key not found or invalid');
    airsrefe_log_processing_result($original_title, $unique_title, $model, false);
    return ['title' => $title, 'content' => $content . "\n\n<!-- No API key -->"];
}

// Log API key status (masked for security)
$masked_key = substr($api_key, 0, 8) . str_repeat('*', max(0, strlen($api_key) - 16)) . substr($api_key, -8);
airsrefe_append_log('Main function using API key: ' . $masked_key);

$prompt = airsrefe_get_structure_preserving_prompt($task_type, $title, $content, $priority, $model);

$content_hash = md5($title . '|' . $content . '|' . $task_type);
$cached_result = airsrefe_get_cached_ai_result($content_hash, $task_type, $model);

if ($cached_result !== false) {
    airsrefe_append_log("AI result loaded from cache - skipping API request");
    return $cached_result;
}

$system_message = airsrefe_get_system_message($task_type);
$total_input_tokens = airsrefe_estimate_total_tokens($prompt, $system_message, $model);
$estimated_output_tokens = airsrefe_estimate_output_tokens($task_type, strlen($content));
$estimated_cost = airsrefe_calculate_request_cost($model, $total_input_tokens, $estimated_output_tokens);

airsrefe_track_ai_request();

if (!airsrefe_check_budget_before_request($estimated_cost)) {
airsrefe_append_log("Request cancelled - would exceed budget (estimated: $" . number_format($estimated_cost, 4) . ")");
return ['title' => $title, 'content' => $content . "\n\n<!-- Budget limit reached -->"];
}

$use_json = get_option('airsrefe_enable_json_responses', 1) && $task_type === 'content';
$response = airsrefe_make_api_request_with_retry($model, $prompt, $use_json);

if ($response && isset($response['choices'][0]['message']['content'])) {
airsrefe_record_circuit_success('openai');

$ai_text = $response['choices'][0]['message']['content'];

$parsed_result = $use_json ? 
airsrefe_parse_json_response($ai_text, $title, $content) : 
airsrefe_parse_text_response($ai_text, $title, $content);

$unique_title = $parsed_result['title'];
$unique_content = $parsed_result['content'];

$unique_content = airsrefe_restore_html_structure($content, $unique_content, $model);

$actual_input_tokens = $response['usage']['prompt_tokens'] ?? $input_tokens;
$actual_output_tokens = $response['usage']['completion_tokens'] ?? $estimated_output_tokens;
$actual_cost = airsrefe_calculate_request_cost($model, $actual_input_tokens, $actual_output_tokens);

airsrefe_record_cost($actual_cost, $model, $task_type);

$original_clean = strtolower(trim(preg_replace('/\s+/', ' ', wp_strip_all_tags($original_title))));
$unique_clean = strtolower(trim(preg_replace('/\s+/', ' ', wp_strip_all_tags($unique_title))));

$content_changed = strlen($unique_content) > strlen($content) * 0.8 && 
  strlen($unique_content) < strlen($content) * 1.5;

similar_text($original_clean, $unique_clean, $percent);

if ($percent < 90 || $content_changed) {
$success = true;
airsrefe_append_log(sprintf("AI processed successfully (title similarity: %s%%, content changed: %s, cost: $%s)", 
number_format($percent, 1), 
$content_changed ? 'yes' : 'no',
number_format($actual_cost, 6)));
} else {
if (strlen($unique_content) > strlen($content) + 100) {
$success = true;
airsrefe_append_log(sprintf("AI processed successfully (content expanded significantly, cost: $%s)", 
number_format($actual_cost, 6)));
} else {
airsrefe_append_log(sprintf("AI result rejected - too similar (title: %s%%, content change: %s)", 
number_format($percent, 1), 
$content_changed ? 'acceptable' : 'minimal'));
}
}
} else {
airsrefe_append_log('No valid AI response received');
}

} catch (Exception $e) {
airsrefe_append_log('AI processing error: ' . $e->getMessage());
}

airsrefe_log_processing_result($original_title, $unique_title, $model, $success);

$result = [
'title' => $unique_title,
'content' => $unique_content
];

if ($success) {
    airsrefe_cache_ai_result($content_hash, $task_type, $model, $result, $estimated_cost);
}

return $result;
}

function airsrefe_restore_html_structure($original_content, $rewritten_content, $model) {
if (strpos($model, 'gpt-5') === 0) {
$original_has_html = airsrefe_detect_html_structure($original_content);
$rewritten_has_html = airsrefe_detect_html_structure($rewritten_content);

if ($original_has_html && !$rewritten_has_html) {
airsrefe_append_log("HTML structure lost, attempting to restore...");

$restored_content = airsrefe_apply_html_structure($original_content, $rewritten_content);

if (strlen($restored_content) > strlen($rewritten_content) * 0.8) {
airsrefe_append_log("HTML structure restored successfully");
return $restored_content;
}
}
}

return $rewritten_content;
}

function airsrefe_apply_html_structure($original_html, $plain_text) {
$sentences = preg_split('/(?<=[.!?])\s+/', trim($plain_text), -1, PREG_SPLIT_NO_EMPTY);

if (empty($sentences)) {
return $plain_text;
}

$structure_elements = [];
$dom = new DOMDocument();
        // Safe libxml error handling
        $old_setting = libxml_use_internal_errors(true);
        libxml_clear_errors();
        
        $load_result = $dom->loadHTML('<?xml encoding="UTF-8">' . $original_html, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
        
        // Clear any errors and restore previous setting
        libxml_clear_errors();
        libxml_use_internal_errors($old_setting);
        
        if (!$load_result) return $original_html;

$xpath = new DOMXPath($dom);
$text_nodes = $xpath->query('//text()[normalize-space()]');

foreach ($text_nodes as $node) {
$parent_tag = $node->parentNode->nodeName;
$text_content = trim($node->textContent);

if (strlen($text_content) > 10) {
$structure_elements[] = [
'tag' => $parent_tag,
'length' => strlen($text_content)
];
}
}

$structured_content = '';
$sentence_index = 0;

foreach ($structure_elements as $element) {
if ($sentence_index >= count($sentences)) break;

$sentences_needed = max(1, round($element['length'] / 100));
$content_part = '';

for ($i = 0; $i < $sentences_needed && $sentence_index < count($sentences); $i++) {
$content_part .= $sentences[$sentence_index] . ' ';
$sentence_index++;
}

$content_part = trim($content_part);

if (!empty($content_part)) {
switch ($element['tag']) {
case 'h1':
case 'h2':
case 'h3':
case 'h4':
case 'h5':
case 'h6':
$structured_content .= "<{$element['tag']}>{$content_part}</{$element['tag']}>\n\n";
break;
case 'li':
if (strpos($structured_content, '<ul>') === false && strpos($structured_content, '<ol>') === false) {
$structured_content .= "<ul>\n";
}
$structured_content .= "<li>{$content_part}</li>\n";
break;
case 'blockquote':
$structured_content .= "<blockquote>{$content_part}</blockquote>\n\n";
break;
default:
$structured_content .= "<p>{$content_part}</p>\n\n";
}
}
}

if (strpos($structured_content, '<ul>') !== false && strpos($structured_content, '</ul>') === false) {
$structured_content .= "</ul>\n\n";
}
if (strpos($structured_content, '<ol>') !== false && strpos($structured_content, '</ol>') === false) {
$structured_content .= "</ol>\n\n";
}

while ($sentence_index < count($sentences)) {
$remaining_sentences = array_slice($sentences, $sentence_index, 3);
$paragraph_content = implode(' ', $remaining_sentences);
$structured_content .= "<p>{$paragraph_content}</p>\n\n";
$sentence_index += 3;
}

return trim($structured_content);
}
function airsrefe_get_optimized_prompt($task_type, $title, $content, $priority) {
if (function_exists('airsrefe_process_prompt')) {
$custom_prompt = airsrefe_process_prompt($task_type . '_rewrite', [
'title' => $title,
'content' => $content
]);

if (!empty($custom_prompt)) {
return $custom_prompt;
}
}

$use_json = get_option('airsrefe_enable_json_responses', 1) && $task_type === 'content';

return $use_json ? 
airsrefe_get_improved_json_prompt($title, $content, $priority) : 
airsrefe_get_improved_text_prompt($title, $content, $priority);
}
function airsrefe_get_improved_json_prompt($title, $content, $priority) {
    $quality_map = [
        'economy' => 'Basic rewrite',
        'speed' => 'Quick rewrite', 
        'quality' => 'Quality rewrite',
        'balanced' => 'Standard rewrite'
    ];
    
    $level = $quality_map[$priority] ?? 'Standard rewrite';
    
    return "{$level}. Output JSON: {\"title\":\"new_title\",\"content\":\"rewritten_content\"}

Title: {$title}
Content: {$content}";
}

function airsrefe_get_optimized_text_prompt($title, $content, $priority) {
    $quality_map = [
        'economy' => 'Basic',
        'speed' => 'Quick', 
        'quality' => 'Quality',
        'balanced' => 'Standard'
    ];
    
    $level = $quality_map[$priority] ?? 'Standard';
    
    return "{$level} rewrite. Format:
Title: new_title
Content: rewritten_content

Title: {$title}
Content: {$content}";
}

function airsrefe_get_optimized_html_json_prompt($title, $content, $priority, $model) {
    $level_map = ['economy' => 'Basic', 'speed' => 'Quick', 'quality' => 'Quality', 'balanced' => 'Standard'];
    $level = $level_map[$priority] ?? 'Standard';
    
    return "{$level} rewrite. Keep ALL HTML tags. JSON: {\"title\":\"new_title\",\"content\":\"rewritten_with_html\"}

Title: {$title}
Content: {$content}";
}

function airsrefe_get_improved_text_prompt($title, $content, $priority) {
$instructions = [
'economy' => 'Rewrite efficiently with meaningful changes.',
'speed' => 'Rewrite quickly but ensure uniqueness.',
'quality' => 'Create high-quality, completely unique content.',
'balanced' => 'Balance quality and efficiency while ensuring uniqueness.'
];

$instruction = $instructions[$priority] ?? $instructions['balanced'];

return "TASK: Completely rewrite this article to make it unique. {$instruction}

IMPORTANT REQUIREMENTS:
1. Create a new, different title (keep under 120 characters, no trailing ellipsis)
2. Rewrite ALL content to be unique
3. Keep the same facts but change the writing style
4. Use this EXACT format (no quotes around title):

Title: Your new unique title here

Content: Your complete rewritten article here

Do not add any other text, explanations, or formatting.

===ORIGINAL ARTICLE===
Title: \"{$title}\"

Content:
{$content}

===YOUR REWRITE===";
}
function airsrefe_get_json_prompt($title, $content, $priority) {
$instructions = [
'economy' => 'Focus on basic rewriting with minimal changes.',
'speed' => 'Provide quick, efficient rewriting.',
'quality' => 'Create high-quality, engaging content with excellent readability.',
'balanced' => 'Balance quality and efficiency in rewriting.'
];

$instruction = $instructions[$priority] ?? $instructions['balanced'];

return "Rewrite this article uniquely using JSON format. {$instruction}

Please respond with valid JSON containing the rewritten title and content:

{
  \"title\": \"new unique title here\",
  \"content\": \"full rewritten article content here\"
}

Original article:
Title: \"{$title}\"
Content: {$content}";
}

function airsrefe_get_text_prompt($title, $content, $priority) {
$instructions = [
'economy' => 'Make minimal but effective changes to ensure uniqueness.',
'speed' => 'Rewrite efficiently while maintaining key information.',
'quality' => 'Create exceptional, engaging content with superior writing quality.',
'balanced' => 'Create well-written, unique content that balances quality and efficiency.'
];

$instruction = $instructions[$priority] ?? $instructions['balanced'];

return "Please rewrite this news article to make it completely unique while preserving all key information. {$instruction}

Format your response EXACTLY as follows:

Title: [Write new unique title here]

Content: [Write the full rewritten article content here]

===ORIGINAL ARTICLE===
Title: \"{$title}\"

Content:
{$content}";
}
function airsrefe_get_structure_preserving_prompt($task_type, $title, $content, $priority, $model) {
if (function_exists('airsrefe_process_prompt')) {
$custom_prompt = airsrefe_process_prompt($task_type . '_rewrite', [
'title' => $title,
'content' => $content
]);

if (!empty($custom_prompt)) {
return $custom_prompt;
}
}

$use_json = get_option('airsrefe_enable_json_responses', 1) && $task_type === 'content';

$has_html = airsrefe_detect_html_structure($content);

if ($has_html) {
return $use_json ? 
airsrefe_get_optimized_html_json_prompt($title, $content, $priority, $model) : 
airsrefe_get_html_preserving_text_prompt($title, $content, $priority, $model);
} else {
return $use_json ? 
airsrefe_get_improved_json_prompt($title, $content, $priority) : 
airsrefe_get_optimized_text_prompt($title, $content, $priority);
}
}
function airsrefe_get_html_preserving_json_prompt($title, $content, $priority, $model) {
$instructions = [
'economy' => 'Rewrite efficiently while preserving structure.',
'speed' => 'Rewrite quickly while maintaining HTML formatting.',
'quality' => 'Create high-quality content while preserving all HTML structure.',
'balanced' => 'Balance quality and efficiency while maintaining HTML structure.'
];

$instruction = $instructions[$priority] ?? $instructions['balanced'];

$structure_emphasis = '';
if (strpos($model, 'gpt-5') === 0) {
$structure_emphasis = "
CRITICAL FOR GPT-5: You must preserve the exact HTML structure from the original. Keep all:
- Paragraph tags (<p></p>)
- Heading tags (<h1>, <h2>, <h3>, etc.)
- List tags (<ul>, <ol>, <li>)
- Image tags (<img>)
- Links (<a>)
- Blockquotes (<blockquote>)
- Any embedded content (Twitter, YouTube, etc.)";
}

return "Rewrite this article to make it completely unique while preserving ALL HTML structure and formatting. {$instruction}

{$structure_emphasis}

IMPORTANT:
1. Rewrite the title to be unique
2. Rewrite ALL text content to be unique
3. Keep ALL HTML tags exactly as they are
4. Preserve images, links, embeds, lists, headings
5. Maintain paragraph structure

Respond in valid JSON format:

{
  \"title\": \"new unique title (no HTML tags)\",
  \"content\": \"rewritten content with ALL original HTML tags preserved\"
}

Original article:
Title: \"{$title}\"
Content: {$content}";
}
function airsrefe_get_html_preserving_text_prompt($title, $content, $priority, $model) {
$instructions = [
'economy' => 'Rewrite efficiently while preserving structure.',
'speed' => 'Rewrite quickly while maintaining HTML formatting.',
'quality' => 'Create high-quality content while preserving all HTML structure.',
'balanced' => 'Balance quality and efficiency while maintaining HTML structure.'
];

$instruction = $instructions[$priority] ?? $instructions['balanced'];

$structure_emphasis = '';
if (strpos($model, 'gpt-5') === 0) {
$structure_emphasis = "
CRITICAL FOR GPT-5: You must preserve the exact HTML structure from the original. Keep all paragraph tags, headings, lists, images, links, and embedded content exactly as they appear.";
}

return "TASK: Rewrite this article to make it unique while preserving ALL HTML structure. {$instruction}

{$structure_emphasis}

REQUIREMENTS:
1. Create a new, unique title (no HTML, keep under 120 characters, no trailing ellipsis)
2. Rewrite ALL text to be unique
3. Keep ALL HTML tags: <p>, <h1-h6>, <ul>, <ol>, <li>, <img>, <a>, <blockquote>, <div>, etc.
4. Preserve images, links, embeds (Twitter, YouTube, etc.)
5. Maintain paragraph breaks and structure

Format:
Title: Your new unique title here

Content: Your rewritten content with ALL original HTML preserved

===ORIGINAL===
Title: \"{$title}\"

Content:
{$content}

===REWRITE===";
}
function airsrefe_detect_html_structure($content) {
$html_indicators = [
'<p>', '<h1>', '<h2>', '<h3>', '<h4>', '<h5>', '<h6>',
'<ul>', '<ol>', '<li>', '<blockquote>', '<img', '<iframe',
'<div', '<span', '<strong>', '<em>', '<a href'
];

$html_count = 0;
foreach ($html_indicators as $indicator) {
if (strpos($content, $indicator) !== false) {
$html_count++;
}
}

return $html_count >= 3;
}

/**
 * Make API request to OpenAI with retry logic and error handling
 * 
 * @since 1.1
 * 
 * @param string $model The AI model to use (gpt-5, gpt-5-mini, etc.)
 * @param string $prompt The prompt to send to the AI
 * @param bool $use_json Whether to request JSON response format
 * @param int $max_retries Maximum number of retry attempts
 * @return array|WP_Error API response array or WP_Error on failure
 */
function airsrefe_make_api_request_with_retry($model, $prompt, $use_json = false, $max_retries = 3) {
$exponential_backoff = get_option('airsrefe_exponential_backoff', 1);
$api_timeout = get_option('airsrefe_api_timeout', 60);
$api_key = airsrefe_get_api_key();

// Debug logging for API key
if (empty($api_key)) {
    airsrefe_append_log('API key is empty');
    return false;
}

// Log API key status (masked for security)
$masked_key = substr($api_key, 0, 8) . str_repeat('*', max(0, strlen($api_key) - 16)) . substr($api_key, -8);
airsrefe_append_log('Using API key: ' . $masked_key);

$temperature = (strpos($model, 'gpt-5') === 0) ? 1 : 0.8;

$system_message = $use_json ? 
'You are a professional content editor. Always respond in valid JSON format as requested.' : 
'You are a professional content editor.';

$request_body = [
'model' => $model,
'messages' => [
['role' => 'system', 'content' => $system_message],
['role' => 'user', 'content' => $prompt]
],
'temperature' => $temperature,
'max_completion_tokens' => airsrefe_get_max_tokens_for_model($model)
];

if ($use_json) {
$request_body['response_format'] = ['type' => 'json_object'];
}

for ($attempt = 1; $attempt <= $max_retries; $attempt++) {
if ($attempt > 1 && $exponential_backoff) {
$delay = pow(2, $attempt - 1);
airsrefe_append_log("Retry attempt #{$attempt} after {$delay}s delay");
if (function_exists('wp_sleep')) { wp_sleep($delay); } else { sleep($delay); }
}

$response = wp_remote_post('https://api.openai.com/v1/chat/completions', [
'headers' => [
'Content-Type'  => 'application/json',
'Authorization' => 'Bearer ' . $api_key,
],
'body' => wp_json_encode($request_body),
'timeout' => $api_timeout,
'sslverify' => true, // Enable SSL verification
'httpversion' => '1.1',
'user-agent' => 'AI-RSS-Rewriter/' . AIRSREFE_VERSION,
'blocking' => true,
'cookies' => [],
'compress' => false,
'decompress' => true,
'stream' => false,
'filename' => null,
'limit_response_size' => null
]);

if (is_wp_error($response)) {
airsrefe_append_log("API request failed (attempt {$attempt}): " . $response->get_error_message());

if ($attempt === $max_retries) {
return airsrefe_try_fallback_model($prompt, $use_json);
}
continue;
}

$status_code = wp_remote_retrieve_response_code($response);
$body = json_decode(wp_remote_retrieve_body($response), true);

if ($status_code === 200 && isset($body['choices'][0]['message']['content'])) {
return $body;
}

if (isset($body['error'])) {
$error_code = $body['error']['code'] ?? '';
$error_message = $body['error']['message'] ?? '';

airsrefe_append_log("API error (attempt {$attempt}): {$error_message}");

if ($error_code === 'insufficient_quota' || strpos($error_message, 'quota') !== false) {
update_option('airsrefe_block_parsing', 1);
airsrefe_append_log('OpenAI quota exhausted - blocking parsing');
return false;
}

if ($error_code === 'invalid_request_error') {
if ($use_json && strpos($error_message, 'json') !== false) {
airsrefe_append_log('JSON mode failed, retrying with text mode');
return airsrefe_make_api_request_with_retry($model, $prompt, false, 1);
}
airsrefe_append_log('Invalid request - not retrying');
return false;
}

if ($error_code === 'rate_limit_exceeded') {
if (function_exists('wp_sleep')) { wp_sleep(60); } else { sleep(60); }
airsrefe_append_log("Rate limited - waiting 60s");
}
}

if ($attempt === $max_retries) {
return airsrefe_try_fallback_model($prompt, $use_json);
}
}

return false;
}

function airsrefe_try_fallback_model($prompt, $use_json = false) {
$fallback_model = get_option('airsrefe_model_fallback', 'gpt-4o-mini');
airsrefe_append_log("Trying fallback model: {$fallback_model}");

$api_key = airsrefe_get_api_key();
$api_timeout = get_option('airsrefe_api_timeout', 60);

// Debug logging for fallback API key
if (empty($api_key)) {
    airsrefe_append_log('Fallback API key is empty');
    return false;
}

$temperature = (strpos($fallback_model, 'gpt-5') === 0) ? 1 : 0.8;

$system_message = $use_json ? 
'You are a content editor. Always respond in valid JSON format as requested.' : 
'You are a content editor.';

$request_body = [
'model' => $fallback_model,
'messages' => [
['role' => 'system', 'content' => $system_message],
['role' => 'user', 'content' => $prompt]
],
'temperature' => $temperature,
'max_completion_tokens' => airsrefe_get_max_tokens_for_model($fallback_model)
];

if ($use_json && $fallback_model !== 'gpt-3.5-turbo') {
$request_body['response_format'] = ['type' => 'json_object'];
}

$response = wp_remote_post('https://api.openai.com/v1/chat/completions', [
'headers' => [
'Content-Type'  => 'application/json',
'Authorization' => 'Bearer ' . $api_key,
],
'body' => wp_json_encode($request_body),
'timeout' => $api_timeout,
'sslverify' => true, // Enable SSL verification
'httpversion' => '1.1',
'user-agent' => 'AI-RSS-Rewriter/' . AIRSREFE_VERSION,
'blocking' => true,
'cookies' => [],
'compress' => false,
'decompress' => true,
'stream' => false,
'filename' => null,
'limit_response_size' => null
]);

if (!is_wp_error($response)) {
$body = json_decode(wp_remote_retrieve_body($response), true);
if (isset($body['choices'][0]['message']['content'])) {
airsrefe_append_log("Fallback model succeeded");
return $body;
}
}

airsrefe_append_log("Fallback model also failed");
return false;
}

function airsrefe_generate_tags_enhanced($title, $content, $priority = null) {
if (!$priority) {
$priority = airsrefe_get_processing_priority();
}

$model = airsrefe_get_optimal_model('tags', strlen($content), $priority);

$prompt = "Generate 5-8 relevant tags for this article. Return only tags separated by commas, lowercase.

Title: {$title}
Content: " . substr($content, 0, 500) . "...";

$response = airsrefe_make_api_request_with_retry($model, $prompt);

if ($response && isset($response['choices'][0]['message']['content'])) {
$tags_text = trim($response['choices'][0]['message']['content']);
$tags = array_map('trim', explode(',', $tags_text));
$tags = array_filter($tags);

$input_tokens = airsrefe_estimate_tokens($prompt);
$output_tokens = airsrefe_estimate_tokens($tags_text);
$cost = airsrefe_calculate_request_cost($model, $input_tokens, $output_tokens);
airsrefe_record_cost($cost, $model, 'tags');

return $tags;
}

return [];
}
function airsrefe_get_optimal_model($task_type, $content_length, $priority) {
$default_models = [
'content' => 'gpt-5-mini',
'title' => 'gpt-5-nano', 
'tags' => 'gpt-5-nano',
'seo' => 'gpt-5-nano',
'fallback' => 'gpt-4o-mini'
];

$preferred_model = get_option('airsrefe_model_' . $task_type, $default_models[$task_type] ?? 'gpt-5-mini');

// Ensure we only use allowed models
$allowed_models = ['gpt-5', 'gpt-5-mini', 'gpt-5-nano', 'gpt-4o-mini'];

if (!in_array($preferred_model, $allowed_models)) {
$preferred_model = $default_models[$task_type] ?? 'gpt-5-mini';
}

return $preferred_model;
}
function airsrefe_generate_description_enhanced($content, $priority = null) {
if (!$priority) {
$priority = airsrefe_get_processing_priority();
}

$model = airsrefe_get_optimal_model('seo', strlen($content), $priority);

$prompt = "Create a compelling SEO meta description (150-160 characters) for this content:

" . substr($content, 0, 800) . "...";

$response = airsrefe_make_api_request_with_retry($model, $prompt);

if ($response && isset($response['choices'][0]['message']['content'])) {
$description = trim($response['choices'][0]['message']['content']);
$description = airsrefe_clean_ai_text($description);

if (strlen($description) > 160) {
$description = substr($description, 0, 157) . '...';
}

$input_tokens = airsrefe_estimate_tokens($prompt);
$output_tokens = airsrefe_estimate_tokens($description);
$cost = airsrefe_calculate_request_cost($model, $input_tokens, $output_tokens);
airsrefe_record_cost($cost, $model, 'seo');

return $description;
}

$description = wp_strip_all_tags($content);
$description = preg_replace('/\s+/', ' ', $description);
return mb_substr($description, 0, 157) . '...';
}
function airsrefe_calculate_request_cost($model, $input_tokens, $output_tokens) {
$pricing = [
'gpt-5' => ['input' => 1.25, 'output' => 10.00],
'gpt-5-mini' => ['input' => 0.15, 'output' => 0.60],
'gpt-5-nano' => ['input' => 0.05, 'output' => 0.40],
'gpt-4o-mini' => ['input' => 0.15, 'output' => 0.60]
];

$model_pricing = $pricing[$model] ?? $pricing['gpt-5-mini'];
return ($input_tokens * $model_pricing['input'] / 1000000) + ($output_tokens * $model_pricing['output'] / 1000000);
}
function airsrefe_parse_json_response($ai_text, $fallback_title, $fallback_content) {
airsrefe_append_log("JSON Response received: " . substr($ai_text, 0, 200) . "...");

try {
$ai_text = trim($ai_text);

$ai_text = preg_replace('/```json\s*|\s*```/', '', $ai_text);
$ai_text = preg_replace('/```\s*|\s*```/', '', $ai_text);

if (preg_match('/\{.*\}/s', $ai_text, $matches)) {
$json_text = $matches[0];
airsrefe_append_log("JSON found: " . substr($json_text, 0, 100) . "...");

$json_data = json_decode($json_text, true);

if (json_last_error() === JSON_ERROR_NONE && is_array($json_data)) {
$title = null;
$content = null;

if (isset($json_data['title'])) {
$title = $json_data['title'];
}
if (isset($json_data['content'])) {
$content = $json_data['content'];
}

if (empty($title) && isset($json_data['Title'])) {
$title = $json_data['Title'];
}
if (empty($content) && isset($json_data['Content'])) {
$content = $json_data['Content'];
}

if (empty($title)) {
foreach (['TITLE', 'new_title', 'rewritten_title', 'headline'] as $key) {
if (isset($json_data[$key])) {
$title = $json_data[$key];
break;
}
}
}

if (empty($content)) {
foreach (['CONTENT', 'article', 'text', 'body', 'rewritten_content'] as $key) {
if (isset($json_data[$key])) {
$content = $json_data[$key];
break;
}
}
}

if ($title && $content) {
$title = airsrefe_clean_ai_text($title);
$content = airsrefe_detect_html_structure($content) ? airsrefe_clean_ai_html($content) : airsrefe_clean_ai_text($content);

if (strlen($title) > 10 && strlen($content) > 100) {
airsrefe_append_log("JSON parsed successfully - Title: " . substr($title, 0, 50) . ", Content: " . strlen($content) . " chars");
return [
'title' => $title,
'content' => $content
];
}
}

airsrefe_append_log("JSON keys found but content insufficient. Title: " . (strlen($title ?? '') . " chars, Content: " . strlen($content ?? '') . " chars"));
} else {
airsrefe_append_log("JSON decode error: " . json_last_error_msg());
}
} else {
airsrefe_append_log("No JSON structure found in response");
}
} catch (Exception $e) {
airsrefe_append_log("JSON parsing exception: " . $e->getMessage());
}

airsrefe_append_log("JSON parsing failed, falling back to text parsing");
return airsrefe_parse_text_response($ai_text, $fallback_title, $fallback_content);
}

function airsrefe_parse_text_response($ai_text, $fallback_title, $fallback_content) {
$title = $fallback_title;
$content = $fallback_content;

airsrefe_append_log("AI Response received: " . substr($ai_text, 0, 200) . "...");

$ai_text = str_replace(["\r\n", "\r"], "\n", $ai_text);

$title_patterns = [
'/Title:\s*(.+?)(?:\n|$)/i',
'/New Title:\s*(.+?)(?:\n|$)/i',
'/Rewritten Title:\s*(.+?)(?:\n|$)/i',
'/^(.+?)(?:\n|$)/m'
];

$content_patterns = [
'/Content:\s*(.+)$/is',
'/Article:\s*(.+)$/is',
'/Rewritten:\s*(.+)$/is',
'/Body:\s*(.+)$/is'
];

// Try to find title
foreach ($title_patterns as $pattern) {
if (preg_match($pattern, $ai_text, $title_match)) {
$extracted_title = trim($title_match[1]);
if (strlen($extracted_title) > 10 && $extracted_title !== $fallback_title) {
$title = $extracted_title;
airsrefe_append_log("Title extracted: " . substr($title, 0, 50));
break;
}
}
}

foreach ($content_patterns as $pattern) {
if (preg_match($pattern, $ai_text, $content_match)) {
$extracted_content = trim($content_match[1]);
if (strlen($extracted_content) > 100) {
$content = $extracted_content;
airsrefe_append_log("Content extracted: " . strlen($content) . " characters");
break;
}
}
}

if ($content === $fallback_content && strlen($ai_text) > strlen($fallback_content) * 0.5) {
$lines = explode("\n", $ai_text);
$content_lines = [];
$found_title = false;

foreach ($lines as $line) {
$line = trim($line);
if (empty($line)) continue;

if (preg_match('/^(Title|Content|Article|Rewritten|Here|The):/i', $line)) {
if (preg_match('/^Title:/i', $line)) {
$found_title = true;
}
continue;
}

if ($found_title && strlen($line) > 20) {
$content_lines[] = $line;
}
elseif (!$found_title && strlen($line) > 50) {
$content_lines[] = $line;
}
}

if (!empty($content_lines)) {
$extracted_content = implode("\n\n", $content_lines);
if (strlen($extracted_content) > 100) {
$content = $extracted_content;
airsrefe_append_log("Content parsed from lines: " . strlen($content) . " characters");
}
}
}

if ($content === $fallback_content && strlen($ai_text) > 200) {
$cleaned_ai = trim(preg_replace('/^(Title|Content|Article):\s*/i', '', $ai_text));
if ($cleaned_ai !== $fallback_content && strlen($cleaned_ai) > strlen($fallback_content) * 0.8) {
$content = $cleaned_ai;
airsrefe_append_log("Using full AI response as content: " . strlen($content) . " characters");
}
}

$title = airsrefe_clean_ai_text($title);
// Prefer preserving HTML structure if present
$content = airsrefe_detect_html_structure($content) ? airsrefe_clean_ai_html($content) : airsrefe_clean_ai_text($content);

if (empty($title) || strlen($title) < 10) {
$title = $fallback_title;
airsrefe_append_log("Title validation failed, using original");
}

if (empty($content) || strlen($content) < 50) {
$content = $fallback_content;
airsrefe_append_log("Content validation failed, using original");
}

// Limit title length for better SEO and display
// Title length is enforced at generation time by AI prompts (≤ configured limit). No truncation here.

airsrefe_append_log("Final result - Title: " . substr($title, 0, 50) . ", Content: " . strlen($content) . " chars");

return [
'title' => $title,
'content' => $content
];
}

function airsrefe_clean_ai_text($text) {
if (empty($text)) return '';

$text = preg_replace('/^(Title|Content|Headline|Text):\s*/i', '', $text);
$text = preg_replace('/^#+\s*/', '', $text);
$text = trim($text, "\"'`");
$text = preg_replace('/<!--.*?-->/s', '', $text);
// Do not collapse spaces/newlines aggressively for HTML preservation
$text = preg_replace('/\n{3,}/', "\n\n", $text);

return trim($text);
}

function airsrefe_clean_ai_html($html) {
if (empty($html)) return '';

// Remove dangerous tags but keep structure and embeds
$allowed_tags = [
    'p' => [], 'h1' => [], 'h2' => [], 'h3' => [], 'h4' => [], 'h5' => [], 'h6' => [],
    'ul' => [], 'ol' => [], 'li' => [], 'blockquote' => [], 'strong' => [], 'em' => [],
    'a' => ['href' => [], 'title' => [], 'target' => []],
    'img' => ['src' => [], 'alt' => [], 'title' => [], 'width' => [], 'height' => []],
    'iframe' => ['src' => [], 'width' => [], 'height' => [], 'allow' => [], 'allowfullscreen' => []],
    'figure' => [], 'figcaption' => [], 'div' => ['class' => []], 'span' => ['class' => []]
];

// Basic cleanup: strip script/style, normalize newlines
$html = preg_replace('#<\s*(script|style)[^>]*>.*?<\s*/\s*\1>#is', '', $html);
$html = preg_replace('/\r\n?|\r/', "\n", $html);

// Keep only allowed tags/attrs
$clean = wp_kses($html, $allowed_tags);

// Collapse excessive blank lines
$clean = preg_replace('/\n{3,}/', "\n\n", $clean);

return trim($clean);
}

function airsrefe_get_max_tokens_for_model($model) {
$limits = [
'gpt-5' => 8192,
'gpt-5-mini' => 16384,
'gpt-5-nano' => 4096,
'gpt-4o-mini' => 16384,
];

return $limits[$model] ?? 4096;
}

function airsrefe_estimate_output_tokens($task_type, $content_length) {
switch ($task_type) {
case 'content':
return min(4000, max(500, $content_length / 3));
case 'title':
return 50;
case 'tags':
return 30;
case 'seo':
return 60;
default:
return 200;
}
}

if (!function_exists('airsrefe_generate_tags')) {
function airsrefe_generate_tags($title, $content) {
return airsrefe_generate_tags_enhanced($title, $content);
}
}

if (!function_exists('airsrefe_generate_description')) {
function airsrefe_generate_description($content) {
return airsrefe_generate_description_enhanced($content);
}
}

if (!function_exists('airsrefe_get_processing_priority')) {
function airsrefe_get_processing_priority() {
return get_option('airsrefe_batch_priority_mode', 'balanced');
}
}


if (!function_exists('airsrefe_estimate_tokens')) {
/**
 * ОПТИМІЗОВАНА: Точна оцінка токенів з урахуванням особливостей GPT tokenizer
 * Замість примітивного strlen/4 використовує реальні паттерни токенізації
 */
function airsrefe_estimate_tokens($text) {
    if (empty($text)) {
        return 0;
    }
    
    $cache_key = 'airsrefe_tokens_' . md5($text);
    $cached_count = wp_cache_get($cache_key, 'airsrefe_tokenization');
    
    if (false !== $cached_count) {
        return $cached_count;
    }
    
    $text = trim($text);
    $original_length = mb_strlen($text, 'UTF-8');
    
    $base_tokens = $original_length / 3.8;
    
    $adjustments = 0;
    
    $tech_patterns = [
        '/\b[A-Z]{2,}\b/',
        '/\b\w*[A-Z]\w*[A-Z]\w*\b/',
        '/\bhttps?:\/\/[^\s]+/',
        '/\b\w+\.\w+\.\w+/',
        '/\b\d{4}-\d{2}-\d{2}/',
        '/\b[a-f0-9]{8,}/',
        '/\$\w+/',
        '/\w+\(\)/',
    ];
    
    foreach ($tech_patterns as $pattern) {
        $matches = preg_match_all($pattern, $text);
        if ($matches > 0) {
            $adjustments += $matches * 0.3;
        }
    }
    
    $cyrillic_matches = preg_match_all('/[\x{0400}-\x{04FF}]/u', $text);
    if ($cyrillic_matches > 0) {
        $adjustments += $cyrillic_matches * 0.15;
    }
    
    $special_chars = preg_match_all('/[^\w\s]/', $text);
    if ($special_chars > 0) {
        $adjustments += $special_chars * 0.1;
    }
    
    $long_words = preg_match_all('/\b\w{13,}\b/', $text);
    if ($long_words > 0) {
        $adjustments += $long_words * 0.4;
    }
    
    $complex_numbers = preg_match_all('/\b\d{1,3}(,\d{3})*(\.\d+)?\b/', $text);
    if ($complex_numbers > 0) {
        $adjustments += $complex_numbers * 0.2;
    }
    
    $rare_words = preg_match_all('/\b[a-zA-Z]{8,}[aeiouy]{1,2}[a-zA-Z]{3,}\b/', $text);
    if ($rare_words > 0) {
        $adjustments += $rare_words * 0.25;
    }
    
    $final_tokens = ceil($base_tokens + $adjustments);
    
    $final_tokens = max(1, min($final_tokens, $original_length));
    
    if ($original_length < 10) {
        $final_tokens = max(1, ceil($original_length / 2));
    }
    
    wp_cache_set($cache_key, $final_tokens, 'airsrefe_tokenization', 3600);
    
    return $final_tokens;
}

// Estimate total tokens including system messages and overhead
function airsrefe_estimate_total_tokens($user_content, $system_message = '', $model = 'gpt-5-mini') {
    $user_tokens = airsrefe_estimate_tokens($user_content);
    $system_tokens = !empty($system_message) ? airsrefe_estimate_tokens($system_message) : 0;
    
    $model_overhead = [
        'gpt-5' => 8,
        'gpt-5-mini' => 6,
        'gpt-5-nano' => 4,
        'gpt-4o-mini' => 5,
    ];
    
    $overhead = isset($model_overhead[$model]) ? $model_overhead[$model] : 6;
    
    $json_overhead = 0;
    if (get_option('airsrefe_enable_json_responses', 1)) {
        $json_overhead = 15;
    }
    
    return $user_tokens + $system_tokens + $overhead + $json_overhead;
}
}


if (!function_exists('airsrefe_record_cost')) {
function airsrefe_record_cost($cost, $model, $type) {
$costs = get_option('airsrefe_daily_costs', []);
$today = current_time('Y-m-d');
$costs[$today] = ($costs[$today] ?? 0) + $cost;
update_option('airsrefe_daily_costs', $costs);

airsrefe_append_log(sprintf("Cost recorded: $%.6f for %s using %s", $cost, $type, $model));
}
}

if (!function_exists('airsrefe_check_budget_before_request')) {
function airsrefe_check_budget_before_request($cost) {
$budget = get_option('airsrefe_daily_budget_limit', 10.00);
if ($budget <= 0) return true;

$costs = get_option('airsrefe_daily_costs', []);
$today = current_time('Y-m-d');
$used = $costs[$today] ?? 0;

return ($used + $cost) <= $budget;
}
}

/**
 * НОВА: Аналіз складності контенту для розумного вибору моделей
 */
function airsrefe_analyze_content_complexity($content, $title = '') {
    if (empty($content)) {
        return 0;
    }
    
    $complexity_score = 0;
    $content_length = mb_strlen($content, 'UTF-8');
    $combined_text = $title . ' ' . $content;
    
    if ($content_length > 5000) {
        $complexity_score += 3;
    } elseif ($content_length > 2000) {
        $complexity_score += 2;
    } elseif ($content_length > 500) {
        $complexity_score += 1;
    }
    
    $tech_keywords = [
        'api', 'javascript', 'python', 'database', 'algorithm', 'machine learning',
        'artificial intelligence', 'blockchain', 'cryptocurrency', 'cloud computing',
        'devops', 'microservices', 'kubernetes', 'docker', 'aws', 'azure',
        
        'research', 'study', 'analysis', 'methodology', 'clinical', 'pharmaceutical',
        'diagnosis', 'treatment', 'syndrome', 'pathology', 'genome', 'protein',
        
        'investment', 'portfolio', 'dividend', 'securities', 'compliance', 'audit',
        'roi', 'ebitda', 'valuation', 'merger', 'acquisition', 'ipo',
        
        'litigation', 'jurisdiction', 'legislation', 'regulatory', 'patent',
        'intellectual property', 'contract', 'liability', 'statute', 'precedent'
    ];
    
    $tech_matches = 0;
    foreach ($tech_keywords as $keyword) {
        if (stripos($combined_text, $keyword) !== false) {
            $tech_matches++;
        }
    }
    
    if ($tech_matches >= 5) {
        $complexity_score += 3;
    } elseif ($tech_matches >= 3) {
        $complexity_score += 2;
    } elseif ($tech_matches >= 1) {
        $complexity_score += 1;
    }
    
    $sentences = preg_split('/[.!?]+/', $content);
    $long_sentences = 0;
    $complex_punctuation = 0;
    
    foreach ($sentences as $sentence) {
        $sentence = trim($sentence);
        if (mb_strlen($sentence) > 100) {
            $long_sentences++;
        }
        
        if (preg_match('/[;:,].*[;:,]/', $sentence)) {
            $complex_punctuation++;
        }
    }
    
    if ($long_sentences > 3) {
        $complexity_score += 2;
    } elseif ($long_sentences > 1) {
        $complexity_score += 1;
    }
    
    if ($complex_punctuation > 2) {
        $complexity_score += 1;
    }
    
    $special_patterns = [
        '/\$[^$]+\$/',
        '/\b[A-Z]{3,}\b/',
        '/\d+\.\d+\.\d+/',
        '/https?:\/\/\S+/',
        '/\b\w+@\w+\.\w+/',
        '/\([^)]{20,}\)/',
    ];
    
    $special_matches = 0;
    foreach ($special_patterns as $pattern) {
        $special_matches += preg_match_all($pattern, $content);
    }
    
    if ($special_matches > 5) {
        $complexity_score += 2;
    } elseif ($special_matches > 2) {
        $complexity_score += 1;
    }
    
    $cyrillic_ratio = 0;
    if ($content_length > 0) {
        $cyrillic_chars = preg_match_all('/[\x{0400}-\x{04FF}]/u', $content);
        $cyrillic_ratio = $cyrillic_chars / $content_length;
    }
    
    if ($cyrillic_ratio > 0.7) {
        $complexity_score += 1;
    }
    
    $long_words = preg_match_all('/\b\w{12,}\b/', $content);
    if ($long_words > 10) {
        $complexity_score += 2;
    } elseif ($long_words > 5) {
        $complexity_score += 1;
    }
    
    return min(15, max(0, $complexity_score));
}

/**
 * НОВА: Розумний вибір моделі на основі складності та типу завдання
 */
/**
 * OPTIMIZATION: Enhanced smart model selection with quality-based decisions
 */
function airsrefe_smart_model_selection($content, $task_type = 'content', $title = '') {
    // Check if smart model selection is enabled
    if (!get_option('airsrefe_smart_model_selection', 1)) {
        return get_option('airsrefe_model_' . $task_type, 'gpt-5-mini');
    }
    
    // Use new quality scoring system instead of complexity
    $quality_score = airsrefe_analyze_content_quality($content, $title);
    $budget_mode = airsrefe_get_budget_mode();
    $content_length = mb_strlen(wp_strip_all_tags($content));
    
    airsrefe_append_log(sprintf("Content analysis: quality=%d/100, length=%d, budget=%s, task=%s", 
$quality_score, $content_length, $budget_mode, $task_type));

if ($budget_mode === 'critical') {
airsrefe_append_log("Critical budget mode - using gpt-5-nano only");
return 'gpt-5-nano';
}

switch ($task_type) {
case 'content':
if ($quality_score >= 70 && $budget_mode !== 'economy' && $content_length > 1000) {
return 'gpt-5';
} elseif ($quality_score >= 50 && $budget_mode !== 'economy') {
return 'gpt-5-mini';
} elseif ($quality_score >= 30) {
return 'gpt-5-nano';
} else {
airsrefe_append_log("Content quality too low for AI processing");
return false;
}

case 'title':
if ($quality_score >= 60 && $budget_mode !== 'economy') {
return 'gpt-5-mini';
} else {
return 'gpt-5-nano';
}

case 'tags':
return 'gpt-5-nano';

case 'seo':
if ($quality_score >= 55 && $budget_mode !== 'economy') {
return 'gpt-5-mini';
} else {
return 'gpt-5-nano';
}

case 'summary':
if ($quality_score >= 60 && $content_length > 1500) {
return 'gpt-5-mini';
} else {
return 'gpt-5-nano';
}

default:
if ($quality_score >= 60 && $budget_mode !== 'economy') {
return 'gpt-5-mini';
} else {
return 'gpt-5-nano';
}
}
}

function airsrefe_get_system_message($task_type = 'content') {
    $messages = [
        'content' => 'You are a professional content editor. Rewrite content to be unique while preserving all facts and structure.',
        'title' => 'You are a professional headline writer. Create engaging, unique titles.',
        'tags' => 'You are a content categorization expert. Generate relevant tags.',
        'seo' => 'You are an SEO expert. Create compelling meta descriptions.'
    ];
    
    return $messages[$task_type] ?? $messages['content'];
}

function airsrefe_predict_request_cost($content, $title, $task_type, $model) {
    $system_message = airsrefe_get_system_message($task_type);
    $prompt = airsrefe_get_structure_preserving_prompt($task_type, $title, $content, 'balanced', $model);
    
    $total_input_tokens = airsrefe_estimate_total_tokens($prompt, $system_message, $model);
    $estimated_output_tokens = airsrefe_estimate_output_tokens($task_type, strlen($content));
    
    return airsrefe_calculate_request_cost($model, $total_input_tokens, $estimated_output_tokens);
}

function airsrefe_check_budget_with_prediction($predicted_cost, $buffer_percentage = 5) {
    $daily_budget = get_option('airsrefe_daily_budget_limit', 10.00);
    
    if ($daily_budget <= 0) {
        return true; // Unlimited budget
    }
    
    $today_cost = airsrefe_get_today_costs();
    $buffer = $daily_budget * ($buffer_percentage / 100);
    $available_budget = $daily_budget - $today_cost - $buffer;
    
    if ($predicted_cost > $available_budget) {
        airsrefe_append_log(sprintf("Request blocked: predicted cost $%.4f exceeds available budget $%.4f", 
            $predicted_cost, $available_budget));
        return false;
    }
    
    return true;
}

/**
 * OPTIMIZATION: Progressive budget alerts
 */
function airsrefe_check_budget_alerts() {
    $daily_budget = get_option('airsrefe_daily_budget_limit', 10.00);
    
    if ($daily_budget <= 0) {
        return; // No alerts for unlimited budget
    }
    
    $today_cost = airsrefe_get_today_costs();
    $usage_percentage = ($today_cost / $daily_budget) * 100;
    
    $last_alert = get_option('airsrefe_last_budget_alert', '');
    $today = current_time('Y-m-d');
    
    if ($last_alert !== $today) {
update_option('airsrefe_last_budget_alert_level', 0);
}
    
    $last_level = get_option('airsrefe_last_budget_alert_level', 0);
    
    if ($usage_percentage >= 95 && $last_level < 95) {
        airsrefe_append_log("CRITICAL: Budget usage at {$usage_percentage}% - processing may stop soon");
        update_option('airsrefe_last_budget_alert_level', 95);
        update_option('airsrefe_last_budget_alert', $today);
    } elseif ($usage_percentage >= 80 && $last_level < 80) {
        airsrefe_append_log("WARNING: Budget usage at {$usage_percentage}% - consider reducing processing");
        update_option('airsrefe_last_budget_alert_level', 80);
        update_option('airsrefe_last_budget_alert', $today);
    } elseif ($usage_percentage >= 50 && $last_level < 50) {
        airsrefe_append_log("INFO: Budget usage at {$usage_percentage}% - halfway through daily budget");
        update_option('airsrefe_last_budget_alert_level', 50);
        update_option('airsrefe_last_budget_alert', $today);
    }
}

function airsrefe_get_budget_mode() {
    $daily_budget = get_option('airsrefe_daily_budget_limit', 10.00);
    
    if ($daily_budget <= 0) {
        return 'unlimited';
    }
    
    $today_cost = airsrefe_get_today_costs();
    $usage_percent = ($today_cost / $daily_budget) * 100;
    
    if ($usage_percent >= 90) {
        return 'critical';
    } elseif ($usage_percent >= 70) {
        return 'economy';
    } elseif ($usage_percent >= 50) {
        return 'balanced';
    } else {
        return 'normal';
    }
}

function airsrefe_should_process_with_ai($title, $content) {
    if (mb_strlen($content) < 150) {
        airsrefe_append_log("Content too short for AI processing: " . mb_strlen($content) . " chars");
        return false;
    }
    
    $spam_keywords = [
        'buy now', 'limited time', 'special offer', 'discount', 'promotion',
        'subscribe', 'newsletter', 'click here', 'free trial', 'call now',
        'best deal', 'save money', 'lowest price', 'act fast', 'bonus',
        'купити зараз', 'знижка', 'акція', 'розпродаж', 'безкоштовно',
        'підписка', 'спеціальна пропозиція', 'обмежена пропозиція'
    ];
    
    $spam_score = 0;
    $combined_text = strtolower($title . ' ' . $content);
    
    foreach ($spam_keywords as $keyword) {
        if (stripos($combined_text, $keyword) !== false) {
            $spam_score++;
        }
    }
    
    if ($spam_score >= 3) {
        airsrefe_append_log("Content appears to be spam/promotional: " . $spam_score . " spam keywords found");
        return false;
    }
    
    $content_fingerprint = md5(preg_replace('/\s+/', ' ', trim($content)));
    $cache_key = 'airsrefe_fingerprint_' . $content_fingerprint;
    
    if (wp_cache_get($cache_key, 'airsrefe_fingerprints')) {
        airsrefe_append_log("Content fingerprint already processed");
        return false;
    }
    
    wp_cache_set($cache_key, time(), 'airsrefe_fingerprints', 86400);
    
    return true;
}

function airsrefe_performance_monitor() {
    $perf_data = get_option('airsrefe_performance_data', []);
    $today = current_time('Y-m-d');
    
    if (!isset($perf_data[$today])) {
        $perf_data[$today] = [
            'ai_requests' => 0,
            'cache_hits' => 0,
            'cache_misses' => 0,
            'total_cost' => 0.00,
            'avg_response_time' => 0,
            'duplicate_checks' => 0,
            'posts_created' => 0,
            'errors' => 0,
            'start_time' => time()
        ];
    }
    
    $cache_hits = wp_cache_get('airsrefe_cache_hits_today', 'airsrefe_performance') ?: 0;
    $cache_misses = wp_cache_get('airsrefe_cache_misses_today', 'airsrefe_performance') ?: 0;
    $ai_requests = wp_cache_get('airsrefe_ai_requests_today', 'airsrefe_performance') ?: 0;
    
    $perf_data[$today]['cache_hits'] = $cache_hits;
    $perf_data[$today]['cache_misses'] = $cache_misses;
    $perf_data[$today]['ai_requests'] = $ai_requests;
    $perf_data[$today]['total_cost'] = airsrefe_get_today_costs();
    $cache_total = $cache_hits + $cache_misses;
    $cache_hit_ratio = $cache_total > 0 ? ($cache_hits / $cache_total) * 100 : 0;
    
    $posts_today = wp_count_posts()->publish;
    $cost_per_post = $perf_data[$today]['total_cost'] > 0 && $posts_today > 0 ? 
        $perf_data[$today]['total_cost'] / $posts_today : 0;
    
    if ($cache_hit_ratio < 70) {
        airsrefe_append_log(sprintf("Low cache hit ratio: %.1f%% - consider optimizing caching", $cache_hit_ratio));
    }
    
    if ($cost_per_post > 0.10) {
        airsrefe_append_log(sprintf("High cost per post: $%.3f - consider using more economical models", $cost_per_post));
    }
    
    $perf_data = array_slice($perf_data, -30, null, true);
    update_option('airsrefe_performance_data', $perf_data);
    
    return $perf_data[$today];
}

function airsrefe_auto_adjust_limits() {
    $perf_data = get_option('airsrefe_performance_data', []);
    
    if (count($perf_data) < 7) {
        return false;
    }
    
    $recent_data = array_slice($perf_data, -7, null, true);
    $avg_cost = array_sum(array_column($recent_data, 'total_cost')) / 7;
    $avg_requests = array_sum(array_column($recent_data, 'ai_requests')) / 7;
    
    $current_budget = get_option('airsrefe_daily_budget_limit', 10.00);
    $current_limit = get_option('airsrefe_daily_parsing_limit', 50);
    
    $adjusted = false;
    
    if ($avg_cost > 0) {
        $utilization = ($avg_cost / $current_budget) * 100;
        
        if ($utilization < 30 && $current_budget > 2.00) {
            $new_budget = max(2.00, $current_budget * 0.8);
            update_option('airsrefe_daily_budget_limit', $new_budget);
            airsrefe_append_log(sprintf("Auto-adjusted budget: $%.2f -> $%.2f (low utilization: %.1f%%)", 
                $current_budget, $new_budget, $utilization));
            $adjusted = true;
        } elseif ($utilization > 90 && $current_budget < 50.00) {
            $new_budget = min(50.00, $current_budget * 1.2);
            update_option('airsrefe_daily_budget_limit', $new_budget);
            airsrefe_append_log(sprintf("Auto-adjusted budget: $%.2f -> $%.2f (high utilization: %.1f%%)", 
                $current_budget, $new_budget, $utilization));
            $adjusted = true;
        }
    }
    
    if ($avg_requests > 0) {
        $request_ratio = ($avg_requests / $current_limit) * 100;
        
        if ($request_ratio < 40 && $current_limit > 10) {
            $new_limit = max(10, intval($current_limit * 0.8));
            update_option('airsrefe_daily_parsing_limit', $new_limit);
            airsrefe_append_log(sprintf("Auto-adjusted parsing limit: %d -> %d (low usage: %.1f%%)", 
                $current_limit, $new_limit, $request_ratio));
            $adjusted = true;
        } elseif ($request_ratio > 95 && $current_limit < 200) {
            $new_limit = min(200, intval($current_limit * 1.3));
            update_option('airsrefe_daily_parsing_limit', $new_limit);
            airsrefe_append_log(sprintf("Auto-adjusted parsing limit: %d -> %d (high usage: %.1f%%)", 
                $current_limit, $new_limit, $request_ratio));
            $adjusted = true;
        }
    }
    
    $error_rate = 0;
    $total_errors = array_sum(array_column($recent_data, 'errors'));
    $total_requests = array_sum(array_column($recent_data, 'ai_requests'));
    
    if ($total_requests > 0) {
        $error_rate = ($total_errors / $total_requests) * 100;
        
        if ($error_rate > 10) {
            if (get_option('airsrefe_model_content') === 'gpt-5') {
                update_option('airsrefe_model_content', 'gpt-5-mini');
                airsrefe_append_log(sprintf("Auto-adjusted model: gpt-5 -> gpt-5-mini (high error rate: %.1f%%)", $error_rate));
                $adjusted = true;
            }
        }
    }
    
    return $adjusted;
}

/**
 * OPTIMIZATION: Cache tracking for metrics
 */
function airsrefe_track_cache_hit() {
    $current = wp_cache_get('airsrefe_cache_hits_today', 'airsrefe_performance') ?: 0;
    wp_cache_set('airsrefe_cache_hits_today', $current + 1, 'airsrefe_performance', 86400);
}

function airsrefe_track_cache_miss() {
    $current = wp_cache_get('airsrefe_cache_misses_today', 'airsrefe_performance') ?: 0;
    wp_cache_set('airsrefe_cache_misses_today', $current + 1, 'airsrefe_performance', 86400);
}

function airsrefe_track_ai_request() {
    $current = wp_cache_get('airsrefe_ai_requests_today', 'airsrefe_performance') ?: 0;
    wp_cache_set('airsrefe_ai_requests_today', $current + 1, 'airsrefe_performance', 86400);
}

/**
 * OPTIMIZATION: Circuit Breaker pattern for failed API requests
 */
function airsrefe_check_circuit_breaker($service = 'openai') {
    $breaker_key = "airsrefe_circuit_breaker_{$service}";
    $breaker_data = wp_cache_get($breaker_key, 'airsrefe_circuit_breaker');
    
    if ($breaker_data === false) {
        $breaker_data = [
            'state' => 'closed', // closed, open, half-open
            'failure_count' => 0,
            'last_failure' => 0,
            'success_count' => 0,
            'last_attempt' => 0
        ];
    }
    
    $current_time = time();
    $failure_threshold = 5; // Open circuit after 5 failures
    $timeout = 300; // 5 minutes timeout for open circuit
    
    switch ($breaker_data['state']) {
        case 'open':
            // Circuit is open, check if timeout passed
            if (($current_time - $breaker_data['last_failure']) > $timeout) {
                $breaker_data['state'] = 'half-open';
                wp_cache_set($breaker_key, $breaker_data, 'airsrefe_circuit_breaker', 3600);
                airsrefe_append_log("Circuit breaker {$service}: switched to half-open state");
                return true;
            }
            airsrefe_append_log("Circuit breaker {$service}: OPEN - blocking request");
            return false;
            
        case 'half-open':
            return true;

case 'closed':
default:
return true;
    }
}

function airsrefe_record_circuit_success($service = 'openai') {
    $breaker_key = "airsrefe_circuit_breaker_{$service}";
    $breaker_data = wp_cache_get($breaker_key, 'airsrefe_circuit_breaker');
    
    if ($breaker_data === false) {
        return;
    }
    
    if ($breaker_data['state'] === 'half-open') {
        $breaker_data['success_count']++;
        
        if ($breaker_data['success_count'] >= 3) {
$breaker_data['state'] = 'closed';
$breaker_data['failure_count'] = 0;
$breaker_data['success_count'] = 0;
airsrefe_append_log("Circuit breaker {$service}: closed - service recovered");
}
} else {
$breaker_data['failure_count'] = max(0, $breaker_data['failure_count'] - 1);
}
    
    wp_cache_set($breaker_key, $breaker_data, 'airsrefe_circuit_breaker', 3600);
}

function airsrefe_record_circuit_failure($service = 'openai', $error_message = '') {
    $breaker_key = "airsrefe_circuit_breaker_{$service}";
    $breaker_data = wp_cache_get($breaker_key, 'airsrefe_circuit_breaker');
    
    if ($breaker_data === false) {
        $breaker_data = [
            'state' => 'closed',
            'failure_count' => 0,
            'last_failure' => 0,
            'success_count' => 0,
            'last_attempt' => 0
        ];
    }
    
    $breaker_data['failure_count']++;
    $breaker_data['last_failure'] = time();
    $breaker_data['last_attempt'] = time();
    
    $failure_threshold = 5;
    
    if ($breaker_data['failure_count'] >= $failure_threshold) {
        $breaker_data['state'] = 'open';
        airsrefe_append_log("Circuit breaker {$service}: OPENED due to {$breaker_data['failure_count']} failures - {$error_message}");
    }
    
    wp_cache_set($breaker_key, $breaker_data, 'airsrefe_circuit_breaker', 3600);
}

function airsrefe_fallback_processing($title, $content, $reason = 'unknown') {
airsrefe_append_log("Falling back to simple processing due to: {$reason}");

$fallback_title = $title;
if (post_exists($title)) {
$fallback_title = "Updated: " . $title;
}

$fallback_content = $content;

$fallback_content .= "\n\n<!-- Content processed in fallback mode due to AI service unavailability -->";
    
    return [
        'title' => $fallback_title,
        'content' => $fallback_content,
        'fallback' => true,
        'reason' => $reason
    ];
}