<?php
// includes/claude-api.php

class ClaudeAPI {
    private $apiKey;
    private $apiUrl;
    private $model = 'claude-3-haiku-20240307';

    public function __construct() {
        $this->apiKey = CLAUDE_API_KEY;
        $this->apiUrl = CLAUDE_API_URL;
    }
    
    /**
     * Faz uma requisição para a API do Claude
     */
    private function makeRequest($endpoint, $data) {
        $ch = curl_init($this->apiUrl . $endpoint);
        
        $headers = [
            'Content-Type: application/json',
            'x-api-key: ' . $this->apiKey,
            'anthropic-version: 2023-06-01'
        ];
        
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        
        if (curl_errno($ch)) {
            throw new Exception('Erro na requisição: ' . curl_error($ch));
        }
        
        curl_close($ch);
        
        if ($httpCode !== 200) {
            throw new Exception('Erro na API: ' . $response);
        }
        
        return json_decode($response, true);
    }
    
    /**
     * Gera conteúdo para uma página específica com aproximadamente o número de palavras desejado
     */
    public function generatePage($title, $type, $keywords = '', $tone = 'informativo', $wordCount = 1000) {
        $prompts = [
            'landing' => "Crea una página de aterrizaje persuasiva que CONECTE CON EL LECTOR para un curso gratuito con EXACTAMENTE {$wordCount} palabras. 
                         Título: {$title}
                         Tono: {$tone}
                         Palabras clave: {$keywords}
                         
                         La página debe CONECTAR EMOCIONALMENTE incluiendo:
                         - Titular atractivo que resuene con las frustraciones del lector <h1>
                         - Historia o situación cotidiana que el lector pueda identificarse
                         - Descripción empática del problema que vive el lector diariamente
                         - Conexión emocional mostrando que entiendes su situación
                         - Al menos 5 puntos de conexión que hagan sentir 'esto es exactamente lo que necesito'
                         - Identificación del perfil emocional y situacional del lector ideal
                         - Promesa de transformación que resuene con sus deseos más profundos
                         - Llamada a la acción que genere curiosidad y conexión
                         
                         Formatea el contenido en HTML con:
                         - <h2> para secciones principales y <h3> para subsecciones
                         - Antes de cada subtítulo, incluye un ícono Font Awesome relevante (ejemplo: <i class=\"fas fa-heart\"></i>)
                         - Incluye íconos Font Awesome dentro del texto (ejemplo: <i class=\"fas fa-check\"></i> antes de puntos de conexión) para destacar elementos emocionales
                         - Usa listas <ul> y <li> para puntos de conexión y benefits
                         - Párrafos en <p>
                         - Asegura escaneabilidad con párrafos cortos y espaciado
                         
                         ES MUY IMPORTANTE que produzcas EXACTAMENTE {$wordCount} palabras, ni más ni menos (contando solo el texto visible, sin etiquetas HTML ni íconos). El contenido debe generar CONEXIÓN EMOCIONAL y resonancia personal.",

'step1' => "Crea la página de contenido que MUESTRE EL VALOR DEL APRENDIZAJE para el curso gratuito con EXACTAMENTE {$wordCount} palabras.
                        Título: {$title}
                        Tono: {$tone}
                        Palabras clave: {$keywords}
                        
                        La página debe DEMOSTRAR VALOR PROFESIONAL Y ECONÓMICO incluyendo:
                        - Introducción al valor transformacional del conocimiento en esta área
                        - Por qué este aprendizaje es una inversión en su futuro profesional
                        - SALARIOS PROMEDIO: Presenta datos específicos de salarios en países hispanohablantes (España: €X, México: $X, Argentina: $X, Colombia: $X, Chile: $X) para profesionales con esta capacitación
                        - ÁREAS DE APLICACIÓN: Explica la amplitud de sectores donde aplicar este conocimiento (tecnología, consultoría, educación, empresas multinacionales, startups, gobierno, etc.)
                        - Al menos 7 BENEFICIOS ESPECÍFICOS Y MEDIBLES del aprendizaje (aumento salarial promedio, nuevas oportunidades laborales, reconocimiento profesional, etc.)
                        - IMPORTANCIA DEL CERTIFICADO: Por qué el certificado es clave para validar competencias, mejorar CV/LinkedIn, acceder a mejores posiciones, ser considerado por reclutadores
                        - Comparación detallada: vida profesional ANTES vs DESPUÉS de adquirir este conocimiento (salario, oportunidades, reconocimiento)
                        - COSTO DE NO APRENDER: Oportunidades perdidas, brecha salarial, obsolescencia profesional
                        - Metodología que GARANTIZA resultados de aprendizaje efectivos
                        - Valor económico y personal que representa dominar este conocimiento
                        - Expectativas claras de lo que lograrán al completar el curso

                        Formatea el contenido en HTML con:
                        - <h2> para secciones principales y <h3> para subsecciones
                        - Íconos Font Awesome antes de subtítulos: <i class=\"fas fa-chart-line\"></i>, <i class=\"fas fa-dollar-sign\"></i>, <i class=\"fas fa-certificate\"></i>, <i class=\"fas fa-globe\"></i>, <i class=\"fas fa-gem\"></i>
                        - <i class=\"fas fa-check\"></i> antes de cada beneficio y punto de valor
                        - <i class=\"fas fa-arrow-right\"></i> para comparaciones antes/después
                        - <i class=\"fas fa-star\"></i> para historias de éxito
                        - Listas <ul> y <li> para beneficios, salarios por país, áreas de aplicación
                        - Párrafos <p> cortos y escaneables
                        - <strong> para destacar CIFRAS SALARIALES, DATOS IMPORTANTES y BENEFICIOS CLAVE
                        
                        CRÍTICO: Debe tener EXACTAMENTE {$wordCount} palabras (solo texto visible, sin HTML ni íconos). El contenido debe demostrar claramente el VALOR ECONÓMICO Y PROFESIONAL DEL APRENDIZAJE con datos concretos de salarios y oportunidades reales.",
                        
'step2' => "Crea la segunda página que APORTE CONOCIMIENTO PRÁCTICO para el curso gratuito con EXACTAMENTE {$wordCount} palabras.
                        Título: {$title}
                        Tono: {$tone}
                        Palabras clave: {$keywords}
                        
                        La página debe ENTREGAR CONOCIMIENTO ÚTIL incluiendo:
                        - Conceptos fundamentales explicados de forma práctica
                        - Al menos 3 técnicas que pueden aplicar inmediatamente
                        - Casos de estudio reales con resultados concretos
                        - Paso a paso para implementar cada técnica
                        - Errores comunes y cómo evitarlos
                        - Herramientas y recursos específicos para aplicar
                        - Ejercicios prácticos con ejemplos del mundo real
                        - Tips de expertos para obtener mejores resultados
                        - Métricas para medir el progreso y éxito
                        
                        Formatea el contenido en HTML con:
                        - <h2> para secciones principales y <h3> para subsecciones
                        - Antes de cada subtítulo, incluye un ícono Font Awesome relevante (ejemplo: <i class=\"fas fa-tools\"></i>)
                        - Incluye íconos Font Awesome dentro del texto (ejemplo: <i class=\"fas fa-check\"></i> antes de técnicas y tips) para destacar conocimiento aplicable
                        - Usa listas <ul> y <li> para técnicas, pasos y herramientas
                        - Párrafos en <p>
                        - Asegura escaneabilidad con párrafos cortos y espaciado
                        
                        ES MUY IMPORTANTE que produzcas EXACTAMENTE {$wordCount} palabras, ni más ni menos (contando solo el texto visible, sin etiquetas HTML ni íconos). El contenido debe ser PRÁCTICO Y APLICABLE inmediatamente.",

'step3' => "Crea la tercera página de contenido para el curso gratuito con EXACTAMENTE {$wordCount} palabras.
                        Título: {$title}
                        Tono: {$tone}
                        Palabras clave: {$keywords}
                        
                        La página debe incluir:
                        - Revisión breve del contenido de las etapas anteriores
                        - Contenido avanzado sobre el tema
                        - Análisis de tendencias futuras e innovaciones en el área
                        - Al menos 5 consejos avanzados de expertos
                        - Estrategias para la aplicación práctica del conocimiento
                        - Un proyecto o desafío completo para el lector
                        - Cómo superar obstáculos comunes en la implementación
                        - Recursos adicionales para profundización
                        - Preparación entusiasta para la etapa final de registro
                        
                        Formatea el contenido en HTML con:
                        - Subtítulos en <h2> para secciones principales y <h3> para subsecciones
                        - Antes de cada subtítulo, incluye un ícono Font Awesome relevante (ejemplo: <i class=\"fas fa-rocket\"></i>)
                        - Incluye íconos Font Awesome dentro del texto (ejemplo: <i class=\"fas fa-check\"></i> antes de consejos, estrategias o recursos) para destacar puntos clave
                        - Usa listas <ul> y <li> para consejos, estrategias y recursos
                        - Párrafos en <p>
                        - Asegura escaneabilidad con párrafos cortos y espaciado
                        
                        ES MUY IMPORTANTE que produzcas EXACTAMENTE {$wordCount} palabras, ni más ni menos (contando solo el texto visible, sin etiquetas HTML ni íconos). El contenido debe ser avanzado, inspirador y extremadamente bien estructurado para consolidar la confianza del lector.",
             
             'registration' => "Crea la página final de registro PERSUASIVA para el curso gratuito con EXACTAMENTE {$wordCount} palabras.
                             Título: {$title}
                             Tono: {$tone}
                             Palabras clave: {$keywords}
                             
                             La página debe CONVENCER AL USUARIO A REGISTRARSE incluyendo:
                             - APERTURA ATRACTIVA: Por qué este curso representa una excelente oportunidad para su desarrollo profesional
                             - Resumen COMPLETO de todos los beneficios económicos y profesionales presentados anteriormente
                             - PLATAFORMA EDUTIN: Menciona que el curso está disponible en la reconocida plataforma educativa https://edutin.com, valorada por su calidad académica y certificaciones válidas
                             - MOTIVACIÓN POSITIVA: Razones convincentes para tomar la decisión de capacitarse (crecimiento del sector, demanda profesional, desarrollo personal)
                             - VALOR INCLUIDO: Detalla todo lo que recibirá al registrarse (acceso completo, materiales educativos, certificado reconocido, soporte académico)
                             - ELIMINACIÓN DE OBJECIONES: Responde dudas sobre tiempo requerido, nivel de dificultad, validez del certificado, sin costos ocultos
                             - GARANTÍAS DE CALIDAD: Seguridad de datos, privacidad, calidad del contenido, acompañamiento educativo
                             - PROCESO POST-REGISTRO: Explicación clara de qué sucede después del registro (acceso a Edutin, primeros módulos, metodología)
                             - FAQ COMPLETO: 7-8 preguntas frecuentes que aclaren dudas y brinden información útil
                             - LLAMADA A LA ACCIÓN CLARA: Invitación directa y motivadora para completar el registro
                             - INSTRUCCIONES SENCILLAS: Pasos claros para finalizar el proceso de inscripción
                             
                             Formatea el contenido en HTML con:
                             - <h2> para secciones principales y <h3> para subsecciones
                             - Íconos Font Awesome relevantes: <i class=\"fas fa-graduation-cap\"></i>, <i class=\"fas fa-shield-alt\"></i>, <i class=\"fas fa-star\"></i>, <i class=\"fas fa-book\"></i>
                             - <i class=\"fas fa-check\"></i> antes de beneficios y garantías
                             - <i class=\"fas fa-trophy\"></i> para elementos de valor y testimonios
                             - <i class=\"fas fa-question-circle\"></i> para FAQs
                             - Listas <ul> y <li> para beneficios, garantías, pasos del proceso
                             - Párrafos <p> informativos y persuasivos
                             - <strong> para BENEFICIOS PRINCIPALES, GARANTÍAS, VALOR INCLUIDO y CERTIFICACIÓN
                             - Destaca el prestigio de https://edutin.com como plataforma educativa confiable
                             
                             IMPORTANTE: EXACTAMENTE {$wordCount} palabras que generen INTERÉS Y CONFIANZA. El contenido debe informar completamente y motivar positivamente al registro en Edutin basándose en valor y beneficios reales."
                             
                             ];
        
        if (!isset($prompts[$type])) {
            throw new Exception('Tipo de página inválido');
        }
        
        try {
            logInfo("Iniciando generación de contenido para '{$title}' con aproximadamente {$wordCount} palabras");
            
            $response = $this->makeRequest('/messages', [
                'model' => $this->model,
                'messages' => [
                    [
                        'role' => 'user',
                        'content' => $prompts[$type]
                    ]
                ],
                'temperature' => 0.7,
                'max_tokens' => 4000 // Ajustado para el límite del modelo
            ]);
            
            // Procesa la respuesta
            $content = $response['content'][0]['text'];
            $actualWordCount = str_word_count(strip_tags($content));
            
            logInfo("Contenido generado con {$actualWordCount} palabras (solicitado: {$wordCount})");
            
            // Verifica y ajusta la longitud del contenido si está muy fuera del objetivo
            if ($actualWordCount < $wordCount * 0.7 || $actualWordCount > $wordCount * 1.3) {
                logInfo("Ajustando tamaño del contenido para más cerca de {$wordCount} palabras");
                $content = $this->verifyContentLength($content, $wordCount);
                $actualWordCount = str_word_count(strip_tags($content));
                logInfo("Contenido ajustado para {$actualWordCount} palabras");
            }
            
            // Genera resumen
            $excerptResponse = $this->makeRequest('/messages', [
                'model' => $this->model,
                'messages' => [
                    [
                        'role' => 'user',
                        'content' => "Crea un resumen corto (máximo 160 caracteres) para este contenido:\n\n" . substr($content, 0, 1500) // Limitado para ahorrar tokens
                    ]
                ],
                'temperature' => 0.7,
                'max_tokens' => 200
            ]);
            
            $excerpt = $excerptResponse['content'][0]['text'];
            
            // Genera meta description
            $metaResponse = $this->makeRequest('/messages', [
                'model' => $this->model,
                'messages' => [
                    [
                        'role' => 'user',
                        'content' => "Crea una meta description amigable con SEO (máximo 160 caracteres) para este contenido:\n\n" . substr($content, 0, 1500) // Limitado para ahorrar tokens
                    ]
                ],
                'temperature' => 0.7,
                'max_tokens' => 200
            ]);
            
            $metaDescription = $metaResponse['content'][0]['text'];
            
            // Definir texto del CTA según el tipo de página
            if ($type === 'landing') {
                $ctaText = "Claro, me interesa saber más";
            } else if ($type === 'step1') {
                $ctaText = "Quiero ver las instrucciones de registro";
            } else {
                // Para otros tipos, generar con API
                $ctaResponse = $this->makeRequest('/messages', [
                    'model' => $this->model,
                    'messages' => [
                        [
                            'role' => 'user',
                            'content' => "Crea un texto corto, persuasivo y atractivo (máximo 30 palabras) para el botón de llamada a la acción de esta página:\n\n" . substr($content, 0, 800) // Limitado para ahorrar tokens
                        ]
                    ],
                    'temperature' => 0.8,
                    'max_tokens' => 100
                ]);
                
                $ctaText = $ctaResponse['content'][0]['text'];
            }
            
            return [
                'content' => $content,
                'excerpt' => $excerpt,
                'meta_description' => $metaDescription,
                'cta_text' => $ctaText,
                'word_count' => $actualWordCount
            ];
            
        } catch (Exception $e) {
            error_log("Error en la generación de contenido con Claude API: " . $e->getMessage());
            throw new Exception("Error en la generación de contenido: " . $e->getMessage());
        }
    }
    /**
 * Gera múltiplas sugestões de títulos para um tipo específico de página
 */
public function generateMultipleTitles($keyword, $type, $count = 3) {
    $pageTypes = [
        'landing' => 'página de aterrisagem',
        'step1' => 'primeira etapa do curso',
        'step2' => 'segunda etapa do curso',
        'step3' => 'etapa avançada do curso',
        'registration' => 'página de registro'
    ];
    
    $pageDescription = isset($pageTypes[$type]) ? $pageTypes[$type] : $type;
    
    $prompt = "Genera exactamente {$count} títulos persuasivos, atractivos y específicos para una {$pageDescription} 
               sobre '{$keyword}'. Cada título debe:
               
               1. Ser conciso pero impactante (máximo 60 caracteres)
               2. Incluir al menos una palabra del tema principal '{$keyword}'
               3. Generar curiosidad o comunicar un beneficio claro
               4. Ser optimizado para conversión
               
               Formato de respuesta:
               1. [Primer título]
               2. [Segundo título]
               3. [Tercer título]
               
               Solo entrega los títulos numerados. Nada más.";
    
    try {
        $response = $this->makeRequest('/messages', [
            'model' => $this->model,
            'messages' => [
                [
                    'role' => 'user',
                    'content' => $prompt
                ]
            ],
            'temperature' => 0.8,
            'max_tokens' => 300
        ]);
        
        $content = $response['content'][0]['text'];
        $titles = [];
        
        // Extrair os títulos usando expressão regular
        preg_match_all('/\d+\.\s+(.*?)(?=\n\d+\.|\n\n|$)/s', $content, $matches);
        
        if (!empty($matches[1])) {
            $titles = array_map('trim', $matches[1]);
        }
        
        // Se não conseguimos extrair títulos pelo padrão, dividimos por linhas
        if (empty($titles)) {
            $lines = explode("\n", $content);
            $titles = array_filter(array_map('trim', $lines));
            $titles = array_slice($titles, 0, $count);
        }
        
        return $titles;
        
    } catch (Exception $e) {
        error_log("Error en la generación de títulos múltiples: " . $e->getMessage());
        throw new Exception("Error en la generación de títulos: " . $e->getMessage());
    }
}

/**
 * Gera múltiplas sugestões de CTAs para um tipo específico de página
 */
public function generateMultipleCTAs($keyword, $type, $count = 3) {
    $ctaTypes = [
        'landing' => 'botón para continuar al primer paso del curso',
        'step1' => 'botón para continuar al segundo paso del curso',
        'step2' => 'botón para continuar al tercer paso del curso',
        'step3' => 'botón para ir a la página de registro',
        'registration' => 'botón final de registro/inscripción'
    ];
    
    $ctaDescription = isset($ctaTypes[$type]) ? $ctaTypes[$type] : 'botón de llamada a la acción';
    
    $prompt = "Genera exactamente {$count} textos persuasivos para un {$ctaDescription} 
               sobre '{$keyword}'. Cada texto de CTA debe:
               
               1. Ser breve y contundente (máximo 30 caracteres)
               2. Ser escrito en primera persona (ej: 'Quiero aprender', 'Inscribirme ahora')
               3. Generar urgencia o motivación para hacer clic
               4. Comunicar claramente la acción o beneficio
               
               Formato de respuesta:
               1. [Primera CTA]
               2. [Segunda CTA]
               3. [Tercera CTA]
               
               Solo entrega los textos numerados. Nada más.";
    
    try {
        $response = $this->makeRequest('/messages', [
            'model' => $this->model,
            'messages' => [
                [
                    'role' => 'user',
                    'content' => $prompt
                ]
            ],
            'temperature' => 0.8,
            'max_tokens' => 300
        ]);
        
        $content = $response['content'][0]['text'];
        $ctas = [];
        
        // Extrair os CTAs usando expressão regular
        preg_match_all('/\d+\.\s+(.*?)(?=\n\d+\.|\n\n|$)/s', $content, $matches);
        
        if (!empty($matches[1])) {
            $ctas = array_map('trim', $matches[1]);
        }
        
        // Se não conseguimos extrair CTAs pelo padrão, dividimos por linhas
        if (empty($ctas)) {
            $lines = explode("\n", $content);
            $ctas = array_filter(array_map('trim', $lines));
            $ctas = array_slice($ctas, 0, $count);
        }
        
        return $ctas;
        
    } catch (Exception $e) {
        error_log("Error en la generación de CTAs: " . $e->getMessage());
        throw new Exception("Error en la generación de CTAs: " . $e->getMessage());
    }
}

/**
 * Gera palavras-chave relacionadas ao tema do curso
 */
public function generateKeywords($mainKeyword, $count = 5) {
    $prompt = "Genera exactamente {$count} palabras clave o frases cortas relacionadas con '{$mainKeyword}' 
               que sean relevantes para SEO. Estas palabras clave deben:
               
               1. Estar estrechamente relacionadas con el tema principal
               2. Ser términos que potenciales estudiantes buscarían
               3. Incluir una mezcla de términos específicos y generales
               4. Tener buen volumen de búsqueda potencial
               
               Formato de respuesta:
               palabra1, palabra2, palabra3, palabra4, palabra5
               
               Entrega SOLO las palabras clave separadas por comas, sin numeración ni explicaciones adicionales.";
    
    try {
        $response = $this->makeRequest('/messages', [
            'model' => $this->model,
            'messages' => [
                [
                    'role' => 'user',
                    'content' => $prompt
                ]
            ],
            'temperature' => 0.7,
            'max_tokens' => 200
        ]);
        
        $content = trim($response['content'][0]['text']);
        
        // Remover qualquer texto explicativo que possa aparecer antes ou depois das palavras-chave
        if (strpos($content, ',') !== false) {
            // Dividir por vírgulas e limpar cada palavra-chave
            $keywords = explode(',', $content);
            $keywords = array_map('trim', $keywords);
            // Limitar ao número solicitado
            $keywords = array_slice($keywords, 0, $count);
            return $keywords;
        } else {
            // Se não há vírgulas, talvez esteja em linhas ou outro formato
            $lines = preg_split('/\r\n|\r|\n/', $content);
            $keywords = array_map('trim', $lines);
            $keywords = array_filter($keywords);
            $keywords = array_slice($keywords, 0, $count);
            return $keywords;
        }
        
    } catch (Exception $e) {
        error_log("Error en la generación de palabras clave: " . $e->getMessage());
        throw new Exception("Error en la generación de palabras clave: " . $e->getMessage());
    }
}
    /**
     * Verifica la longitud del contenido y ajusta si es necesario
     */
    private function verifyContentLength($content, $targetWordCount = 1000) {
        $wordCount = str_word_count(strip_tags($content));
        
        // Si el contenido está cerca del objetivo (±30%), retorna como está
        if ($wordCount >= $targetWordCount * 0.7 && $wordCount <= $targetWordCount * 1.3) {
            return $content;
        }
        
        // Si es muy corto o muy largo, pide a la API que ajuste
        $instruction = $wordCount < $targetWordCount 
            ? "Este texto tiene solo {$wordCount} palabras, pero necesito que tenga EXACTAMENTE {$targetWordCount} palabras. Por favor, expande este texto añadiendo más detalles, ejemplos y explicaciones para alcanzar EXACTAMENTE {$targetWordCount} palabras:" 
            : "Este texto tiene {$wordCount} palabras, pero necesito que tenga EXACTAMENTE {$targetWordCount} palabras. Por favor, condensa este texto manteniendo la información más importante para alcanzar EXACTAMENTE {$targetWordCount} palabras:";
        
        try {
            $response = $this->makeRequest('/messages', [
                'model' => $this->model,
                'messages' => [
                    [
                        'role' => 'user',
                        'content' => $instruction . "\n\n" . $content
                    ]
                ],
                'temperature' => 0.7,
                'max_tokens' => 4000 // Ajustado para el límite del modelo
            ]);
            
            $adjustedContent = $response['content'][0]['text'];
            $newWordCount = str_word_count(strip_tags($adjustedContent));
            
            // Si el ajuste fue peor, mantiene el original
            if (abs($newWordCount - $targetWordCount) > abs($wordCount - $targetWordCount)) {
                return $content;
            }
            
            return $adjustedContent;
            
        } catch (Exception $e) {
            // Si falla el ajuste, retorna el contenido original
            error_log("Error al ajustar la longitud del contenido: " . $e->getMessage());
            return $content;
        }
    }
    
    /**
     * Gera contenido para una página específica con control preciso de tamaño
     */
    public function generatePageWithLength($title, $type, $wordCount = 1000, $keywords = '', $tone = 'informativo') {
        // Usa la implementación predeterminada con el parámetro de tamaño
        return $this->generatePage($title, $type, $keywords, $tone, $wordCount);
    }
    
    /**
     * Genera sugerencias de título
     */
    public function generateTitle($type, $keywords = '') {
        $prompt = "Genera 5 sugerencias de títulos persuasivos para una {$type} de curso gratuito.";
        if (!empty($keywords)) {
            $prompt .= " Usa las siguientes palabras clave: {$keywords}";
        }
        $prompt .= "\n\nGenera títulos altamente atractivos, envolventes y que despierten curiosidad. Los títulos deben ser específicos y generar un fuerte deseo de hacer clic.";
        
        try {
            $response = $this->makeRequest('/messages', [
                'model' => $this->model,
                'messages' => [
                    [
                        'role' => 'user',
                        'content' => $prompt
                    ]
                ],
                'temperature' => 0.8,
                'max_tokens' => 300
            ]);
            
            $titles = explode("\n", $response['content'][0]['text']);
            return array_filter(array_map('trim', $titles));
            
        } catch (Exception $e) {
            error_log("Error en la generación de títulos con Claude API: " . $e->getMessage());
            throw new Exception("Error en la generación de títulos: " . $e->getMessage());
        }
    }
    
    /**
     * Mejora un texto existente
     */
    public function improveContent($content, $tone = 'informativo', $wordCount = null) {
        $prompt = "Mejora este texto manteniendo un tono {$tone}:";
        
        if ($wordCount !== null) {
            $prompt .= "\n\nEl texto final debe tener aproximadamente {$wordCount} palabras.";
        }
        
        $prompt .= "\n\nHaz el texto más persuasivo, atractivo y con mejor fluidez. Añade elementos que aumenten el compromiso del lector y mejora la claridad de las ideas. Mantén la estructura original pero mejora la calidad de la escritura.\n\n{$content}";
        
        try {
            $response = $this->makeRequest('/messages', [
                'model' => $this->model,
                'messages' => [
                    [
                        'role' => 'user',
                        'content' => $prompt
                    ]
                ],
                'temperature' => 0.7,
                'max_tokens' => 4000 // Ajustado para el límite del modelo
            ]);
            
            $improvedContent = $response['content'][0]['text'];
            
            // Verifica la longitud si se solicitó un tamaño específico
            if ($wordCount !== null) {
                $improvedContent = $this->verifyContentLength($improvedContent, $wordCount);
            }
            
            return $improvedContent;
            
        } catch (Exception $e) {
            error_log("Error en la mejora de contenido con Claude API: " . $e->getMessage());
            throw new Exception("Error en la mejora de contenido: " . $e->getMessage());
        }
    }
    
    /**
     * Optimiza un texto para SEO
     */
    public function optimizeForSEO($content, $keywords, $wordCount = null) {
        $prompt = "Optimiza este contenido para SEO utilizando estas palabras clave: {$keywords}.\n\n";
        $prompt .= "Mantén la esencia del contenido, pero incluye las palabras clave de forma natural en:
                   - Encabezados (H1, H2, H3)
                   - Primer y último párrafo
                   - A lo largo del texto con una densidad adecuada
                   - En listas con viñetas cuando sea apropiado
                   
                   Añade:
                   - Subtítulos relevantes
                   - Preguntas que los usuarios podrían hacer
                   - Estructura bien definida
                   - Mejor formato para escaneabilidad";
                   
        if ($wordCount !== null) {
            $prompt .= "\n\nEl texto final debe tener aproximadamente {$wordCount} palabras.";
        }
        
        $prompt .= "\n\nContenido a optimizar:\n\n{$content}";
        
        try {
            $response = $this->makeRequest('/messages', [
                'model' => $this->model,
                'messages' => [
                    [
                        'role' => 'user',
                        'content' => $prompt
                    ]
                ],
                'temperature' => 0.7,
                'max_tokens' => 4000 // Ajustado para el límite del modelo
            ]);
            
            $optimizedContent = $response['content'][0]['text'];
            
            // Verifica la longitud si se solicitó un tamaño específico
            if ($wordCount !== null) {
                $optimizedContent = $this->verifyContentLength($optimizedContent, $wordCount);
            }
            
            return $optimizedContent;
            
        } catch (Exception $e) {
            error_log("Error en la optimización SEO de contenido con Claude API: " . $e->getMessage());
            throw new Exception("Error en la optimización SEO: " . $e->getMessage());
        }
    }
    
    /**
     * Genera FAQs relacionadas con el contenido
     */
    public function generateFAQs($title, $content, $numberOfQuestions = 5) {
        $prompt = "Crea {$numberOfQuestions} preguntas y respuestas (FAQ) relacionadas con este contenido de curso gratuito.\n\n";
        $prompt .= "Título del curso: {$title}\n\n";
        $prompt .= "Contenido:\n" . substr($content, 0, 2000) . "\n\n"; // Limitado para ahorrar tokens
        $prompt .= "Genera preguntas que los estudiantes potenciales tendrían antes de inscribirse, como dudas sobre requisitos previos, 
                    beneficios, formato, tiempo necesario, aplicación práctica, etc. 
                    Las respuestas deben ser detalladas, persuasivas y eliminar objeciones para aumentar la tasa de conversión.";
        
        try {
            $response = $this->makeRequest('/messages', [
                'model' => $this->model,
                'messages' => [
                    [
                        'role' => 'user',
                        'content' => $prompt
                    ]
                ],
                'temperature' => 0.7,
                'max_tokens' => 2000 // Ajustado para el límite del modelo
            ]);
            
            return $response['content'][0]['text'];
            
        } catch (Exception $e) {
            error_log("Error en la generación de FAQs con Claude API: " . $e->getMessage());
            throw new Exception("Error en la generación de FAQs: " . $e->getMessage());
        }
    }
}

// Instancia la clase
$claudeAPI = new ClaudeAPI();