import json
from openai import OpenAI
from pydantic import BaseModel, ValidationError, validator
from .config_manager import ConfigManager


class AIResponseModel(BaseModel):
    categorie: str
    urgence: str
    resume: str
    questions_complementaires: list[str]
    reponse_client: str
    ticket_title: str
    ticket_description: str
    priorite_odoo: int
    besoin_intervention_humaine: bool
    sentiment_client: str

    @validator("categorie")
    def validate_categorie(cls, v):
        allowed = {"copieur", "telephonie", "ged", "informatique", "autre"}
        if v not in allowed:
            raise ValueError(f"categorie invalide: {v}")
        return v

    @validator("urgence")
    def validate_urgence(cls, v):
        allowed = {"faible", "normale", "haute", "critique"}
        if v not in allowed:
            raise ValueError(f"urgence invalide: {v}")
        return v

    @validator("sentiment_client")
    def validate_sentiment(cls, v):
        allowed = {"calme", "agace", "mecontent", "urgent"}
        if v not in allowed:
            raise ValueError(f"sentiment_client invalide: {v}")
        return v


class AIAnalyzer:
    def __init__(self, config: ConfigManager, logger):
        self.config = config
        self.logger = logger
        self.mock_mode = config.getboolean("APP", "mock_mode", fallback=False)
        self.openai_key = self.config.get("OPENAI", "api_key")
        self.client = OpenAI(api_key=self.openai_key) if self.openai_key and not self.mock_mode else None

    def analyze(self, message_text):
        if not message_text:
            raise ValueError("Message text is vide")
        if self.mock_mode:
            return self._mock_response(message_text)
        if self.client is None:
            raise ValueError("OPENAI.api_key est requis quand APP.mock_mode = false")
        prompt = self._build_prompt(message_text)
        try:
            result = self.client.chat.completions.create(
                model=self.config.get("OPENAI", "model", fallback="gpt-4.1-mini"),
                temperature=self.config.getfloat("OPENAI", "temperature", fallback=0.2),
                messages=[
                    {
                        "role": "system",
                        "content": "Tu es un assistant technique SAV professionnel. Retourne uniquement un JSON valide respectant exactement le schema demande.",
                    },
                    {"role": "user", "content": prompt},
                ],
                response_format={"type": "json_object"},
                timeout=20,
            )
            content = result.choices[0].message.content
            response_json = json.loads(content)
            validated = AIResponseModel(**response_json)
            self.logger.info("Analyse IA validee")
            return validated.model_dump()
        except (json.JSONDecodeError, ValidationError) as error:
            self.logger.error(f"Erreur IA JSON/validation: {error}")
            raise
        except Exception as exc:
            self.logger.error(f"Erreur OpenAI: {exc}")
            raise

    def _build_prompt(self, message_text):
        return (
            "Analyse le message SAV ci-dessous et retourne uniquement un JSON valide, sans texte autour.\n"
            "Tu dois classer la demande dans une seule categorie parmi: copieur, telephonie, ged, informatique, autre.\n"
            "Regles de classement:\n"
            "- copieur: imprimante, photocopieur, scanner, scan, toner, impression, multifonction.\n"
            "- telephonie: telephone, standard, mobile, ligne, appel, renvoi, voix, operateur.\n"
            "- ged: document, archivage, signature, workflow documentaire, OpenBee, coffre, classement, numerisation documentaire.\n"
            "- informatique: ordinateur, serveur, reseau, disque dur, mot de passe, logiciel, mail, wifi, acces, panne PC.\n"
            "- autre: seulement si aucun service ne convient.\n"
            "Valeurs autorisees pour urgence: faible, normale, haute, critique.\n"
            "Valeurs autorisees pour sentiment_client: calme, agace, mecontent, urgent.\n"
            "Ne fais aucune supposition sur une intervention realisee. Ne promets pas de delai precis.\n"
            "Si l'information est insuffisante, demande des precisions. Si l'urgence est critique, indique qu'un technicien va reprendre la demande.\n"
            "Schema exact a retourner:\n"
            "{\"categorie\":\"informatique\",\"urgence\":\"normale\",\"resume\":\"resume court\","
            "\"questions_complementaires\":[\"question utile\"],\"reponse_client\":\"message professionnel au client\","
            "\"ticket_title\":\"titre court et clair\",\"ticket_description\":\"description exploitable pour le technicien\","
            "\"priorite_odoo\":1,\"besoin_intervention_humaine\":true,\"sentiment_client\":\"calme\"}\n"
            f"Message: {message_text}"
        )

    def _mock_response(self, message_text):
        lower_text = message_text.lower()
        categorie = "autre"
        urgence = "normale"
        sentiment = "calme"
        title = "Demande de support"

        if any(word in lower_text for word in ["imprimante", "copieur", "scanner", "scan", "toner", "impression"]):
            categorie = "copieur"
            title = "Probleme copieur"
        elif any(word in lower_text for word in ["telephone", "téléphone", "standard", "appel", "ligne"]):
            categorie = "telephonie"
            title = "Probleme telephonie"
        elif any(word in lower_text for word in ["ged", "document", "openbee", "signature", "archivage"]):
            categorie = "ged"
            title = "Probleme GED"
        elif any(word in lower_text for word in ["ordinateur", "pc", "serveur", "reseau", "réseau", "disque dur", "wifi", "mail"]):
            categorie = "informatique"
            title = "Probleme informatique"

        if "urgent" in lower_text or "panne" in lower_text:
            urgence = "haute"
            sentiment = "agace"

        response = {
            "categorie": categorie,
            "urgence": urgence,
            "resume": f"Demande support client pour {categorie}.",
            "questions_complementaires": [
                "Pouvez-vous preciser le modele exact ou le service concerne ?",
                "Quel message d'erreur est affiche ?",
            ],
            "reponse_client": "Bonjour, votre demande est bien prise en compte. Pouvez-vous preciser le modele ou le message d'erreur si vous en avez un ?",
            "ticket_title": title,
            "ticket_description": f"Support recu : {message_text}",
            "priorite_odoo": 2,
            "besoin_intervention_humaine": True,
            "sentiment_client": sentiment,
        }
        self.logger.info("MOCK_MODE: analyse IA simulee")
        return response
