<?php
/**
 * Service d'Auto-Tagging Intelligent
 * Catégorise automatiquement les conversations avec l'IA
 */

namespace App\Services;

use Core\Database;
use Core\OpenAIService;

require_once ROOT_PATH . '/core/OpenAIService.php';

class AutoTaggingService
{
    private $db;
    private $aiService;
    
    // Tags prédéfinis par catégorie
    private array $predefinedTags = [
        'type' => [
            'question' => ['question', 'demande', 'comment', 'pourquoi', 'quand', 'où', 'quel'],
            'plainte' => ['plainte', 'réclamation', 'mécontent', 'problème', 'insatisfait', 'déçu', 'inacceptable'],
            'demande_info' => ['information', 'renseignement', 'savoir', 'détails', 'précision'],
            'assistance' => ['aide', 'aider', 'assistance', 'support', 'besoin'],
            'feedback' => ['suggestion', 'amélioration', 'proposer', 'idée', 'feedback'],
            'urgence' => ['urgent', 'urgence', 'immédiat', 'rapidement', 'vite', 'pressé']
        ],
        'sujet' => [
            'facturation' => ['facture', 'paiement', 'prix', 'tarif', 'coût', 'montant', 'reçu', 'devis'],
            'technique' => ['bug', 'erreur', 'marche pas', 'fonctionne pas', 'technique', 'panne', 'bloqué'],
            'compte' => ['compte', 'mot de passe', 'connexion', 'inscription', 'profil', 'identifiant'],
            'livraison' => ['livraison', 'colis', 'envoi', 'expédition', 'recevoir', 'délai'],
            'produit' => ['produit', 'article', 'commande', 'achat', 'qualité', 'défaut'],
            'service' => ['service', 'prestation', 'abonnement', 'offre', 'formule'],
            'remboursement' => ['remboursement', 'rembourser', 'annuler', 'annulation', 'retour']
        ],
        'sentiment' => [
            'positif' => ['merci', 'excellent', 'parfait', 'super', 'génial', 'satisfait', 'bravo'],
            'négatif' => ['nul', 'horrible', 'catastrophe', 'arnaque', 'honteux', 'scandaleux'],
            'neutre' => []
        ],
        'priorite' => [
            'urgent' => ['urgent', 'immédiat', 'critique', 'grave', 'important', 'vite'],
            'haute' => ['rapidement', 'bientôt', 'prioritaire', 'pressé'],
            'normale' => [],
            'basse' => ['quand vous pouvez', 'pas pressé', 'à l\'occasion']
        ]
    ];

    public function __construct()
    {
        $this->db = Database::getInstance();
        $this->aiService = new OpenAIService();
    }

    /**
     * Analyse et tag un message/conversation
     */
    public function analyzeAndTag(int $conversationId, string $message, bool $useAI = true): array
    {
        $tags = [];
        $messageLower = mb_strtolower($message, 'UTF-8');
        
        // 1. Analyse par mots-clés (rapide)
        $keywordTags = $this->analyzeByKeywords($messageLower);
        $tags = array_merge($tags, $keywordTags);
        
        // 2. Analyse par IA (si activé et message significatif)
        if ($useAI && strlen($message) > 20) {
            $aiTags = $this->analyzeByAI($message);
            $tags = array_merge($tags, $aiTags);
        }
        
        // 3. Déduplication et nettoyage
        $tags = array_unique($tags);
        
        // 4. Sauvegarder les tags
        $this->saveConversationTags($conversationId, $tags);
        
        // 5. Mettre à jour la priorité si détectée
        $this->updatePriorityIfNeeded($conversationId, $tags);
        
        return $tags;
    }

    /**
     * Analyse par mots-clés
     */
    private function analyzeByKeywords(string $message): array
    {
        $detectedTags = [];
        
        foreach ($this->predefinedTags as $category => $tags) {
            foreach ($tags as $tag => $keywords) {
                foreach ($keywords as $keyword) {
                    if (strpos($message, $keyword) !== false) {
                        $detectedTags[] = $tag;
                        break;
                    }
                }
            }
        }
        
        return $detectedTags;
    }

    /**
     * Analyse par IA pour tags plus précis
     */
    private function analyzeByAI(string $message): array
    {
        $prompt = <<<PROMPT
Analyse ce message client et retourne UNIQUEMENT les tags pertinents (maximum 5) séparés par des virgules.

Tags possibles:
- Type: question, plainte, demande_info, assistance, feedback, urgence
- Sujet: facturation, technique, compte, livraison, produit, service, remboursement
- Sentiment: positif, négatif, neutre
- Priorité: urgent, haute, normale, basse

Message: "{$message}"

Réponds UNIQUEMENT avec les tags, rien d'autre. Exemple: plainte, facturation, négatif, haute
PROMPT;

        try {
            $response = $this->aiService->chat($prompt, 'Tu es un système de classification de messages. Réponds uniquement avec les tags demandés.');
            
            if ($response) {
                $tags = array_map('trim', explode(',', $response));
                // Filtrer les tags invalides
                $validTags = [];
                foreach ($tags as $tag) {
                    $tag = strtolower(trim($tag));
                    if ($this->isValidTag($tag)) {
                        $validTags[] = $tag;
                    }
                }
                return array_slice($validTags, 0, 5);
            }
        } catch (\Exception $e) {
            error_log("AutoTagging AI Error: " . $e->getMessage());
        }
        
        return [];
    }

    /**
     * Vérifie si un tag est valide
     */
    private function isValidTag(string $tag): bool
    {
        foreach ($this->predefinedTags as $category => $tags) {
            if (array_key_exists($tag, $tags)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Sauvegarde les tags d'une conversation
     */
    private function saveConversationTags(int $conversationId, array $tags): void
    {
        if (empty($tags)) return;
        
        // Supprimer les anciens tags auto-générés
        $this->db->query(
            "DELETE FROM conversation_tags WHERE conversation_id = :cid AND is_auto = TRUE",
            ['cid' => $conversationId]
        );
        
        // Insérer les nouveaux tags
        foreach ($tags as $tag) {
            $this->db->insert('conversation_tags', [
                'conversation_id' => $conversationId,
                'tag' => $tag,
                'is_auto' => true,
                'created_at' => date('Y-m-d H:i:s')
            ]);
        }
        
        // Mettre à jour le champ tags JSON dans conversations
        $tagsJson = json_encode($tags);
        $this->db->query(
            "UPDATE conversations SET tags = :tags, updated_at = NOW() WHERE id = :id",
            ['tags' => $tagsJson, 'id' => $conversationId]
        );
    }

    /**
     * Met à jour la priorité si tag urgent détecté
     */
    private function updatePriorityIfNeeded(int $conversationId, array $tags): void
    {
        $priorityMap = [
            'urgent' => 'urgent',
            'urgence' => 'urgent',
            'haute' => 'high',
            'plainte' => 'high'
        ];
        
        foreach ($tags as $tag) {
            if (isset($priorityMap[$tag])) {
                $this->db->query(
                    "UPDATE conversations SET priorite = :priorite WHERE id = :id AND priorite NOT IN ('urgent', 'high')",
                    ['priorite' => $priorityMap[$tag], 'id' => $conversationId]
                );
                break;
            }
        }
    }

    /**
     * Récupère les tags d'une conversation
     */
    public function getConversationTags(int $conversationId): array
    {
        $result = $this->db->fetchAll(
            "SELECT tag, is_auto, created_at FROM conversation_tags WHERE conversation_id = :cid ORDER BY created_at",
            ['cid' => $conversationId]
        );
        
        return $result ?: [];
    }

    /**
     * Ajoute un tag manuel
     */
    public function addManualTag(int $conversationId, string $tag, int $userId): bool
    {
        $tag = strtolower(trim($tag));
        
        // Vérifier si le tag existe déjà
        $existing = $this->db->fetch(
            "SELECT id FROM conversation_tags WHERE conversation_id = :cid AND tag = :tag",
            ['cid' => $conversationId, 'tag' => $tag]
        );
        
        if ($existing) return false;
        
        $this->db->insert('conversation_tags', [
            'conversation_id' => $conversationId,
            'tag' => $tag,
            'is_auto' => false,
            'added_by' => $userId,
            'created_at' => date('Y-m-d H:i:s')
        ]);
        
        return true;
    }

    /**
     * Supprime un tag
     */
    public function removeTag(int $conversationId, string $tag): bool
    {
        $this->db->query(
            "DELETE FROM conversation_tags WHERE conversation_id = :cid AND tag = :tag",
            ['cid' => $conversationId, 'tag' => $tag]
        );
        return true;
    }

    /**
     * Statistiques des tags par entreprise
     */
    public function getTagStats(int $entrepriseId, string $period = '30days'): array
    {
        $dateFrom = match($period) {
            '7days' => date('Y-m-d', strtotime('-7 days')),
            '30days' => date('Y-m-d', strtotime('-30 days')),
            '90days' => date('Y-m-d', strtotime('-90 days')),
            default => date('Y-m-d', strtotime('-30 days'))
        };

        return $this->db->fetchAll(
            "SELECT ct.tag, COUNT(*) as count
             FROM conversation_tags ct
             JOIN conversations c ON ct.conversation_id = c.id
             WHERE c.entreprise_id = :eid AND ct.created_at >= :from
             GROUP BY ct.tag
             ORDER BY count DESC
             LIMIT 20",
            ['eid' => $entrepriseId, 'from' => $dateFrom]
        );
    }

    /**
     * Suggestions de tags basées sur l'historique
     */
    public function getSuggestedTags(int $entrepriseId): array
    {
        return $this->db->fetchAll(
            "SELECT tag, COUNT(*) as usage_count
             FROM conversation_tags ct
             JOIN conversations c ON ct.conversation_id = c.id
             WHERE c.entreprise_id = :eid
             GROUP BY tag
             ORDER BY usage_count DESC
             LIMIT 10",
            ['eid' => $entrepriseId]
        );
    }
}
