<?php
/**
 * Service Agent IA Vocal
 * Utilise GPT-4 pour répondre aux appels vocaux via Twilio
 */

namespace App\Services;

use Core\Database;

class AIVoiceAgent
{
    private Database $db;
    private string $apiKey;
    private string $model;
    private array $conversationHistory = [];
    
    public function __construct()
    {
        $this->db = Database::getInstance();
        $this->apiKey = defined('OPENAI_API_KEY') ? OPENAI_API_KEY : '';
        $this->model = defined('OPENAI_MODEL') ? OPENAI_MODEL : 'gpt-4';
    }
    
    /**
     * Vérifier si l'IA est configurée
     */
    public function isConfigured(): bool
    {
        return !empty($this->apiKey) && $this->apiKey !== 'your_openai_api_key_here';
    }
    
    /**
     * Générer une réponse IA pour un message vocal
     */
    public function generateResponse(int $entrepriseId, string $userMessage, string $callSid, string $langue = 'fr'): string
    {
        if (!$this->isConfigured()) {
            return $this->getDefaultResponse($langue);
        }
        
        // Charger le contexte de l'entreprise
        $context = $this->buildContext($entrepriseId, $langue);
        
        // Charger l'historique de conversation
        $history = $this->getConversationHistory($callSid);
        
        // Ajouter le message utilisateur
        $history[] = ['role' => 'user', 'content' => $userMessage];
        
        // Appeler OpenAI
        $response = $this->callOpenAI($context, $history);
        
        // Sauvegarder dans l'historique
        if ($response) {
            $history[] = ['role' => 'assistant', 'content' => $response];
            $this->saveConversationHistory($callSid, $history);
        }
        
        return $response ?: $this->getDefaultResponse($langue);
    }
    
    /**
     * Construire le contexte système pour l'IA
     */
    private function buildContext(int $entrepriseId, string $langue): string
    {
        $entreprise = $this->db->fetch(
            "SELECT nom, secteur, voice_welcome, ia_config FROM entreprises WHERE id = :id",
            ['id' => $entrepriseId]
        );
        
        $faqs = $this->db->fetchAll(
            "SELECT question, reponse, categorie FROM faq WHERE entreprise_id = :id AND is_active = 1",
            ['id' => $entrepriseId]
        );
        
        $langueInstructions = [
            'fr' => "Réponds en français de manière naturelle et conversationnelle.",
            'en' => "Respond in English in a natural and conversational manner.",
            'bm' => "Réponds en français simple, adapté pour être compris facilement."
        ];
        
        $context = "Tu es un assistant vocal intelligent pour l'entreprise \"{$entreprise['nom']}\"";
        if (!empty($entreprise['secteur'])) {
            $context .= " (secteur: {$entreprise['secteur']})";
        }
        $context .= ".\n\n";
        
        $context .= "RÈGLES IMPORTANTES:\n";
        $context .= "- " . ($langueInstructions[$langue] ?? $langueInstructions['fr']) . "\n";
        $context .= "- Tes réponses seront lues à voix haute, donc sois concis (2-3 phrases max).\n";
        $context .= "- Évite les listes, les URLs, et les formattages complexes.\n";
        $context .= "- Si tu ne peux pas aider, propose de transférer à un agent humain.\n";
        $context .= "- Sois poli, professionnel et empathique.\n";
        $context .= "- Ne révèle jamais que tu es une IA sauf si on te le demande directement.\n\n";
        
        if (!empty($faqs)) {
            $context .= "BASE DE CONNAISSANCES (FAQ):\n";
            foreach ($faqs as $faq) {
                $context .= "Q: {$faq['question']}\nR: {$faq['reponse']}\n\n";
            }
        }
        
        // Config IA personnalisée
        if (!empty($entreprise['ia_config'])) {
            $iaConfig = json_decode($entreprise['ia_config'], true);
            if (!empty($iaConfig['system_prompt'])) {
                $context .= "\nINSTRUCTIONS SUPPLÉMENTAIRES:\n{$iaConfig['system_prompt']}\n";
            }
        }
        
        return $context;
    }
    
    /**
     * Appeler l'API OpenAI
     */
    private function callOpenAI(string $systemPrompt, array $messages): ?string
    {
        $url = 'https://api.openai.com/v1/chat/completions';
        
        $allMessages = array_merge(
            [['role' => 'system', 'content' => $systemPrompt]],
            $messages
        );
        
        $data = [
            'model' => $this->model,
            'messages' => $allMessages,
            'max_tokens' => 150, // Court pour la voix
            'temperature' => 0.7,
            'presence_penalty' => 0.6
        ];
        
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/json',
            'Authorization: Bearer ' . $this->apiKey
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_TIMEOUT, 10);
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        
        if ($httpCode !== 200) {
            error_log("OpenAI API error: " . $response);
            return null;
        }
        
        $result = json_decode($response, true);
        return $result['choices'][0]['message']['content'] ?? null;
    }
    
    /**
     * Récupérer l'historique de conversation
     */
    private function getConversationHistory(string $callSid): array
    {
        $result = $this->db->fetch(
            "SELECT context_data FROM voice_call_context WHERE call_sid = :sid",
            ['sid' => $callSid]
        );
        
        if ($result) {
            $data = json_decode($result['context_data'], true);
            return $data['ai_history'] ?? [];
        }
        
        return [];
    }
    
    /**
     * Sauvegarder l'historique de conversation
     */
    private function saveConversationHistory(string $callSid, array $history): void
    {
        $result = $this->db->fetch(
            "SELECT context_data FROM voice_call_context WHERE call_sid = :sid",
            ['sid' => $callSid]
        );
        
        if ($result) {
            $data = json_decode($result['context_data'], true);
            $data['ai_history'] = $history;
            
            $this->db->query(
                "UPDATE voice_call_context SET context_data = :data WHERE call_sid = :sid",
                ['sid' => $callSid, 'data' => json_encode($data)]
            );
        }
    }
    
    /**
     * Analyser l'intention de l'utilisateur
     */
    public function analyzeIntent(string $message): array
    {
        $message = strtolower($message);
        
        // Demande de transfert humain
        $humanKeywords = ['agent', 'humain', 'personne', 'conseiller', 'parler à quelqu\'un', 'human', 'representative'];
        foreach ($humanKeywords as $keyword) {
            if (strpos($message, $keyword) !== false) {
                return ['intent' => 'transfer_human', 'confidence' => 0.9];
            }
        }
        
        // Fin de conversation
        $endKeywords = ['merci', 'au revoir', 'bye', 'c\'est tout', 'terminé', 'goodbye', 'thank you'];
        foreach ($endKeywords as $keyword) {
            if (strpos($message, $keyword) !== false) {
                return ['intent' => 'end_conversation', 'confidence' => 0.8];
            }
        }
        
        // Question générale
        return ['intent' => 'question', 'confidence' => 0.7];
    }
    
    /**
     * Réponse par défaut si l'IA n'est pas configurée
     */
    private function getDefaultResponse(string $langue): string
    {
        $responses = [
            'fr' => "Je suis désolé, je ne suis pas en mesure de répondre pour le moment. Souhaitez-vous être mis en relation avec un conseiller?",
            'en' => "I'm sorry, I'm unable to respond at the moment. Would you like to be connected to an advisor?"
        ];
        
        return $responses[$langue] ?? $responses['fr'];
    }
    
    /**
     * Générer un résumé de l'appel pour les agents
     */
    public function generateCallSummary(string $callSid): ?string
    {
        if (!$this->isConfigured()) {
            return null;
        }
        
        $history = $this->getConversationHistory($callSid);
        
        if (empty($history)) {
            return null;
        }
        
        $transcript = "";
        foreach ($history as $msg) {
            $role = $msg['role'] === 'user' ? 'Client' : 'Assistant';
            $transcript .= "$role: {$msg['content']}\n";
        }
        
        $prompt = "Résume brièvement cette conversation téléphonique en 2-3 lignes. Identifie le problème principal et si une action est requise:\n\n$transcript";
        
        return $this->callOpenAI("Tu es un assistant qui résume des conversations.", [
            ['role' => 'user', 'content' => $prompt]
        ]);
    }
    
    /**
     * Loguer l'utilisation de l'IA
     */
    public function logUsage(int $entrepriseId, int $tokensUsed, string $type = 'voice'): void
    {
        $this->db->query(
            "INSERT INTO ai_usage_logs (entreprise_id, tokens_used, type, created_at) 
             VALUES (:eid, :tokens, :type, NOW())",
            ['eid' => $entrepriseId, 'tokens' => $tokensUsed, 'type' => $type]
        );
    }
}
