from .database import DatabaseManager
from .ai_analyzer import AIAnalyzer
from .odoo_api import OdooAPI
from .config_manager import ConfigManager
from datetime import datetime
from html import escape
import json
import re
from uuid import uuid4

class TicketService:
    def __init__(self, config: ConfigManager, logger, db: DatabaseManager, messaging_api, ai_analyzer: AIAnalyzer, odoo_api: OdooAPI):
        self.config = config
        self.logger = logger
        self.db = db
        self.messaging_api = messaging_api
        self.ai_analyzer = ai_analyzer
        self.odoo_api = odoo_api

    def create_support_request(self, source, requester_contact, contact_name, message, subject=""):
        received_at = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
        record_id = self.db.insert_support_request(
            source=source,
            external_id=f"{source}-{uuid4()}",
            requester_contact=requester_contact,
            contact_name=contact_name,
            message=message,
            received_at=received_at,
            subject=subject,
        )
        record = self.db.fetch_message_by_id(record_id)
        self.process_saved_message(record)
        return record_id

    def process_saved_message(self, message_record):
        if not isinstance(message_record, dict):
            message_record = dict(message_record)
        message_id = message_record["id"]
        source = message_record.get("source", "telegram")
        requester_contact = message_record["phone"]
        text = message_record["message"]
        if not text:
            self.logger.warning(f"Message vide ignore: {message_id}")
            return

        pending_result = self._handle_pending_new_issue_answer(message_record)
        if pending_result:
            return

        analysis = self._get_analysis_for_message(message_record)
        self.db.insert_ai_analysis(
            message_id,
            analysis["categorie"],
            analysis["urgence"],
            analysis["resume"],
            analysis,
        )

        ticket_title = self._build_ticket_title(message_record, analysis)
        description = self._build_ticket_description(message_record, analysis)
        priority = analysis.get("priorite_odoo", self.config.getint("TICKET_RULES", "default_priority", fallback=1))
        team_id = self._get_team_id_for_category(analysis.get("categorie"))
        team_name = self._get_team_name_for_category(analysis.get("categorie"))
        status = "created"

        try:
            recent_ticket = self._find_recent_ticket(source, requester_contact)
            if recent_ticket:
                recent_ticket_open = self.odoo_api.is_ticket_open(recent_ticket["odoo_ticket_id"])
                recent_ticket_same_team = False
                if recent_ticket_open:
                    recent_ticket_same_team = self.odoo_api.is_ticket_in_team(recent_ticket["odoo_ticket_id"], team_id=team_id, team_name=team_name)
                    if not recent_ticket_same_team:
                        self.logger.info(
                            f"Ticket Odoo {recent_ticket['odoo_ticket_id']} ouvert mais dans une autre equipe: creation d'un nouveau ticket"
                        )
                    else:
                        self.db.set_conversation_state(
                            source,
                            requester_contact,
                            "awaiting_new_issue_confirmation",
                            recent_ticket["odoo_ticket_id"],
                            analysis.get("categorie", ""),
                            self._build_pending_state_payload(message_record),
                        )
                        self.db.mark_message_processed(message_id)
                        self.messaging_api.send_text_message(
                            requester_contact,
                            "Vous avez deja un ticket ouvert. Est-ce un nouveau probleme ? Repondez par oui ou non.",
                        )
                        self.logger.info(f"Question nouveau probleme envoyee pour le message {message_id}")
                        return
                if not recent_ticket_open:
                    self.logger.info(f"Ticket Odoo {recent_ticket['odoo_ticket_id']} clos: creation d'un nouveau ticket")

            ticket = self.odoo_api.create_helpdesk_ticket(
                ticket_title,
                description,
                priority,
                requester=self._build_requester(message_record),
                team_id=team_id,
                team_name=team_name,
                attachments=self._build_attachments(message_record),
            )
            self.db.insert_ticket(message_id, ticket.get("id"), ticket_title, priority, status)
        except Exception as exc:
            self.logger.error(f"Echec creation ticket Odoo pour message {message_id}: {exc}")
            self.db.insert_ticket(message_id, None, ticket_title, priority, "pending")

        self._send_auto_reply(source, requester_contact, analysis, message_id)
        self.db.mark_message_processed(message_id)

    def _send_auto_reply(self, source, requester_contact, analysis, message_id):
        if source not in {"telegram", "whatsapp"}:
            return
        if not self.config.getboolean("TICKET_RULES", "auto_reply_enabled", fallback=True):
            return
        try:
            self.messaging_api.send_text_message(requester_contact, analysis["reponse_client"])
        except Exception as exc:
            self.logger.error(f"Echec envoi reponse automatique {message_id}: {exc}")

    def _handle_pending_new_issue_answer(self, message_record):
        source = message_record.get("source", "telegram")
        requester_contact = message_record["phone"]
        state = self.db.get_conversation_state(source, requester_contact)
        if not state:
            return False
        if not isinstance(state, dict):
            state = dict(state)
        if state.get("state") != "awaiting_new_issue_confirmation":
            return False

        answer = self._parse_yes_no(message_record.get("message", ""))
        if answer is None:
            self.messaging_api.send_text_message(
                requester_contact,
                "Merci de repondre par oui si c'est un nouveau probleme, ou par non si cela concerne le ticket deja ouvert.",
            )
            self.db.mark_message_processed(message_record["id"])
            return True

        if answer is False:
            pending_message = self._get_pending_state_message(state, message_record)
            analysis = self._get_recent_context_analysis(pending_message) or self._fallback_analysis(pending_message.get("message", ""))
            analysis["categorie"] = state.get("category") or analysis.get("categorie")
            analysis["resume"] = f"{analysis.get('resume', '')} Le client confirme que le message concerne le ticket deja ouvert.".strip()
            self.db.insert_ai_analysis(
                message_record["id"],
                analysis["categorie"],
                analysis["urgence"],
                analysis["resume"],
                analysis,
            )
            self.odoo_api.append_to_ticket(
                state["odoo_ticket_id"],
                self._build_followup_note(pending_message, analysis),
                attachments=self._build_attachments(pending_message),
            )
            self.db.insert_ticket(
                message_record["id"],
                state["odoo_ticket_id"],
                self._build_ticket_title(message_record, analysis),
                analysis.get("priorite_odoo", self.config.getint("TICKET_RULES", "default_priority", fallback=1)),
                "updated",
            )
            self.db.clear_conversation_state(source, requester_contact)
            self.db.mark_message_processed(message_record["id"])
            self.messaging_api.send_text_message(requester_contact, "Merci, votre message est ajoute au ticket deja ouvert.")
            return True

        self.db.clear_conversation_state(source, requester_contact)
        ticket_message = self._get_pending_state_message(state, message_record)
        original_message = ticket_message.get("message") or message_record.get("message", "")
        try:
            analysis = self.ai_analyzer.analyze(original_message)
        except Exception as exc:
            self.logger.error(f"Echec analyse IA nouveau probleme pour message {message_record['id']}: {exc}")
            analysis = self._fallback_analysis(original_message)
        self.db.insert_ai_analysis(
            message_record["id"],
            analysis["categorie"],
            analysis["urgence"],
            analysis["resume"],
            analysis,
        )
        ticket_message = {**ticket_message, "message": original_message}
        ticket = self.odoo_api.create_helpdesk_ticket(
            self._build_ticket_title(ticket_message, analysis),
            self._build_ticket_description(ticket_message, analysis),
            analysis.get("priorite_odoo", self.config.getint("TICKET_RULES", "default_priority", fallback=1)),
            requester=self._build_requester(message_record),
            team_id=self._get_team_id_for_category(analysis.get("categorie")),
            team_name=self._get_team_name_for_category(analysis.get("categorie")),
            attachments=self._build_attachments(ticket_message),
        )
        self.db.insert_ticket(
            message_record["id"],
            ticket.get("id"),
            self._build_ticket_title(ticket_message, analysis),
            analysis.get("priorite_odoo", self.config.getint("TICKET_RULES", "default_priority", fallback=1)),
            "created",
        )
        self.db.mark_message_processed(message_record["id"])
        self.messaging_api.send_text_message(requester_contact, "Merci, un nouveau ticket est cree pour ce probleme.")
        return True

    def _build_pending_state_payload(self, message_record):
        return json.dumps(
            {
                "message_id": message_record.get("id"),
                "message": message_record.get("message", ""),
                "attachment_path": message_record.get("attachment_path", ""),
                "attachment_url": message_record.get("attachment_url", ""),
                "received_at": message_record.get("received_at", ""),
                "subject": message_record.get("subject", ""),
                "contact_name": message_record.get("contact_name", ""),
                "phone": message_record.get("phone", ""),
                "source": message_record.get("source", "telegram"),
                "client_phone": message_record.get("client_phone", ""),
            },
            ensure_ascii=False,
        )

    def _get_pending_state_message(self, state, fallback_message):
        created_message = state.get("created_message") or ""
        payload = None
        try:
            payload = json.loads(created_message)
        except (TypeError, json.JSONDecodeError):
            payload = None

        if isinstance(payload, dict):
            pending_id = payload.get("message_id")
            if pending_id:
                try:
                    record = self.db.fetch_message_by_id(pending_id)
                    if record:
                        return dict(record)
                except Exception as exc:
                    self.logger.error(f"Lecture message en attente ignoree: {exc}")
            return {**fallback_message, **payload}

        return {**fallback_message, "message": created_message or fallback_message.get("message", "")}

    def _parse_yes_no(self, text):
        normalized = re.sub(r"[^\w\s]", " ", (text or "").lower()).strip()
        normalized = re.sub(r"\s+", " ", normalized)
        yes_values = {"oui", "oui merci", "yes", "nouveau", "nouveau probleme", "c est nouveau", "autre sujet"}
        no_values = {"non", "non merci", "no", "meme probleme", "même probleme", "meme sujet", "même sujet"}
        if normalized in yes_values:
            return True
        if normalized in no_values:
            return False
        return None

    def _get_analysis_for_message(self, message_record):
        text = message_record["message"]
        if self._is_negative_detail_reply(text):
            previous = self._get_recent_context_analysis(message_record)
            if previous:
                previous["resume"] = f"{previous.get('resume', '')} Le client indique ne pas avoir plus de details a fournir.".strip()
                previous["questions_complementaires"] = []
                previous["reponse_client"] = "Merci, votre demande est transmise a l'equipe d'assistance concernee avec les informations deja fournies."
                previous["ticket_description"] = f"{previous.get('ticket_description', '')}\nReponse client: {text}".strip()
                previous["conversation_closed"] = True
                return previous

        try:
            return self.ai_analyzer.analyze(text)
        except Exception as exc:
            self.logger.error(f"Echec analyse IA pour message {message_record['id']}: {exc}")
            return self._fallback_analysis(text)

    def _fallback_analysis(self, text):
        return {
            "categorie": self._guess_category_from_text(text),
            "urgence": "normale",
            "resume": "Analyse IA indisponible.",
            "questions_complementaires": [],
            "reponse_client": "Votre demande a bien ete recue. Nous revenons rapidement vers vous.",
            "ticket_title": "Demande support brute",
            "ticket_description": text,
            "priorite_odoo": self.config.getint("TICKET_RULES", "default_priority", fallback=1),
            "besoin_intervention_humaine": True,
            "sentiment_client": "calme",
        }

    def _get_recent_context_analysis(self, message_record):
        minutes = self.config.getint("TICKET_RULES", "reuse_open_ticket_minutes", fallback=60)
        previous = self.db.fetch_recent_analysis_for_contact(
            message_record.get("source", "telegram"),
            message_record["phone"],
            message_record["id"],
            minutes=minutes,
        )
        if not previous:
            return None
        if not isinstance(previous, dict):
            previous = dict(previous)
        try:
            analysis = json.loads(previous.get("response_json") or "{}")
        except json.JSONDecodeError:
            analysis = {}
        if not analysis:
            analysis = self._fallback_analysis(previous.get("message", ""))
            analysis["categorie"] = previous.get("categorie") or analysis["categorie"]
            analysis["urgence"] = previous.get("urgence") or analysis["urgence"]
            analysis["resume"] = previous.get("resume") or analysis["resume"]
        return analysis

    def _is_negative_detail_reply(self, text):
        normalized = re.sub(r"[^\w\s]", " ", (text or "").lower()).strip()
        normalized = re.sub(r"\s+", " ", normalized)
        negative_replies = {
            "non",
            "non merci",
            "non je ne sais pas",
            "je ne sais pas",
            "je sais pas",
            "pas plus",
            "pas d autre detail",
            "pas d autres details",
            "aucun detail",
            "aucune idee",
        }
        return normalized in negative_replies

    def _guess_category_from_text(self, text):
        lower_text = (text or "").lower()
        if any(word in lower_text for word in ["imprimante", "copieur", "scanner", "scan", "toner", "impression"]):
            return "copieur"
        if any(word in lower_text for word in ["telephone", "téléphone", "standard", "appel", "ligne"]):
            return "telephonie"
        if any(word in lower_text for word in ["ged", "document", "openbee", "signature", "archivage"]):
            return "ged"
        if any(word in lower_text for word in ["ordinateur", "pc", "serveur", "reseau", "réseau", "disque dur", "wifi", "mail"]):
            return "informatique"
        return "autre"

    def _build_ticket_description(self, message_record, analysis):
        source = message_record.get("source", "telegram")
        subject = message_record.get("subject", "")
        client_phone = self._extract_client_phone(message_record)
        contact_label = "Telegram chat ID" if source == "telegram" else "Coordonnees"
        questions = analysis.get("questions_complementaires", [])
        questions_html = "".join(f"<li>{escape(str(question))}</li>" for question in questions) if questions else "<li>Aucune</li>"
        attachments_html = self._build_attachments_html(message_record)
        return f"""
<h3>Demande client</h3>
<p><strong>Sujet :</strong> {escape(subject or 'Demande SAV')}</p>
<p><strong>Message :</strong><br>{escape(str(message_record.get('message') or '')).replace(chr(10), '<br>')}</p>
<p><strong>Recu le :</strong> {escape(str(message_record.get('received_at') or ''))}</p>
<hr>
<h3>Client</h3>
<p><strong>Nom :</strong> {escape(str(message_record.get('contact_name') or 'Non fourni'))}</p>
<p><strong>Telephone :</strong> {escape(client_phone or 'Non fourni')}</p>
<p><strong>{escape(contact_label)} :</strong> {escape(str(message_record.get('phone') or 'Non fourni'))}</p>
<p><strong>Canal :</strong> {escape(source)}</p>
<hr>
<h3>Routage</h3>
<p><strong>Equipe :</strong> {escape(self._get_service_label(analysis.get('categorie')))}</p>
<p><strong>Categorie IA :</strong> {escape(str(analysis.get('categorie') or ''))}</p>
<p><strong>Urgence :</strong> {escape(str(analysis.get('urgence') or ''))}</p>
<hr>
<h3>Analyse</h3>
<p><strong>Resume :</strong> {escape(str(analysis.get('resume') or ''))}</p>
<p><strong>Sentiment :</strong> {escape(str(analysis.get('sentiment_client') or ''))}</p>
<hr>
<h3>Questions complementaires</h3>
<ul>{questions_html}</ul>
<hr>
<h3>Pieces jointes</h3>
{attachments_html}
<hr>
<h3>Suivi</h3>
<p><strong>Dialogue client :</strong> {'clos' if analysis.get('conversation_closed') else 'ouvert'}</p>
""".strip()

    def _build_ticket_title(self, message_record, analysis):
        ai_title = (analysis.get("ticket_title") or "").strip()
        if ai_title and ai_title.lower() not in {"demande support brute", "ticket sav", "demande de support"}:
            return ai_title[:120]

        text = (message_record.get("message") or "").strip()
        cleaned = re.sub(r"^(bonjour|bonsoir|salut|hello|bjr)[,.\s:;-]+", "", text, flags=re.IGNORECASE).strip()
        cleaned = cleaned.splitlines()[0] if cleaned else text
        cleaned = cleaned.rstrip(".")
        if not cleaned:
            cleaned = message_record.get("subject") or "Nouvelle demande SAV"
        return f"SAV - {cleaned[:90]}"

    def _build_requester(self, message_record):
        source = message_record.get("source", "telegram")
        contact = message_record.get("phone", "")
        phone = self._extract_client_phone(message_record)
        email = self._extract_email(message_record.get("message", ""))
        return {
            "source": source,
            "name": message_record.get("contact_name") or "Client SAV",
            "contact": contact,
            "telegram_chat_id": contact if source == "telegram" else "",
            "phone": phone,
            "email": email,
        }

    def _build_attachments(self, message_record):
        attachment_path = message_record.get("attachment_path")
        if not attachment_path:
            return []
        return [{
            "path": attachment_path,
            "url": message_record.get("attachment_url", ""),
            "name": attachment_path.rsplit("/", 1)[-1].rsplit("\\", 1)[-1],
        }]

    def _build_attachments_html(self, message_record):
        attachment_url = message_record.get("attachment_url")
        attachment_path = message_record.get("attachment_path")
        if not attachment_url and not attachment_path:
            return "<p>Aucune</p>"
        if attachment_url:
            safe_url = escape(attachment_url, quote=True)
            return f'<p><a href="{safe_url}" target="_blank">Voir la photo envoyee par le client</a></p>'
        return f"<p>Photo enregistree sur le serveur : {escape(str(attachment_path))}</p>"

    def _extract_client_phone(self, message_record):
        if message_record.get("client_phone"):
            return message_record["client_phone"]
        text = message_record.get("message", "")
        match = re.search(r"(?:(?:\+|00)33[\s.-]?[1-9](?:[\s.-]?\d{2}){4}|0[1-9](?:[\s.-]?\d{2}){4})", text)
        return match.group(0).strip() if match else ""

    def _extract_email(self, text):
        match = re.search(r"[\w.+-]+@[\w-]+(?:\.[\w-]+)+", text or "")
        return match.group(0) if match else ""

    def _get_team_id_for_category(self, categorie):
        mapping = {
            "copieur": "copieur_team_id",
            "telephonie": "telephonie_team_id",
            "ged": "ged_team_id",
            "informatique": "informatique_team_id",
        }
        option = mapping.get(categorie or "")
        if not option:
            return 0
        return self.config.getint("SERVICE_TEAMS", option, fallback=0)

    def _get_team_name_for_category(self, categorie):
        mapping = {
            "copieur": "copieur_team_name",
            "telephonie": "telephonie_team_name",
            "ged": "ged_team_name",
            "informatique": "informatique_team_name",
        }
        option = mapping.get(categorie or "")
        if not option:
            return ""
        return self.config.get("SERVICE_TEAMS", option, fallback="")

    def _get_service_label(self, categorie):
        labels = {
            "copieur": "Service copieur",
            "telephonie": "Service telephonie",
            "ged": "Service GED",
            "informatique": "Service informatique",
            "autre": "Service non determine",
        }
        return labels.get(categorie or "autre", "Service non determine")

    def _find_recent_ticket(self, source, requester_contact):
        minutes = self.config.getint("TICKET_RULES", "reuse_open_ticket_minutes", fallback=60)
        if minutes <= 0:
            return None
        return self.db.fetch_recent_ticket_for_contact(source, requester_contact, minutes=minutes)

    def _build_followup_note(self, message_record, analysis):
        message = escape(str(message_record.get("message") or "")).replace(chr(10), "<br>")
        return f"""
<hr>
<h3>Nouveau message client</h3>
<p><strong>Recu le :</strong> {escape(str(message_record.get('received_at') or ''))}</p>
<p><strong>Client :</strong> {escape(str(message_record.get('contact_name') or ''))}</p>
<p><strong>Message :</strong><br>{message}</p>
<p><strong>Piece jointe :</strong> {self._build_attachments_html(message_record)}</p>
<h3>Mise a jour IA</h3>
<p><strong>Equipe :</strong> {escape(self._get_service_label(analysis.get('categorie')))}</p>
<p><strong>Urgence :</strong> {escape(str(analysis.get('urgence') or ''))}</p>
<p><strong>Resume :</strong> {escape(str(analysis.get('resume') or ''))}</p>
<p><strong>Dialogue client :</strong> {'clos' if analysis.get('conversation_closed') else 'ouvert'}</p>
""".strip()
