import threading
import tkinter as tk
from tkinter import ttk, messagebox, filedialog
from .config_manager import ConfigManager
from .logger_manager import get_logger
from .database import DatabaseManager
from .ticket_service import TicketService
from .webhook_server import WebhookServer
import json
import os
import requests

class AdminGUI:
    def __init__(self, root, config: ConfigManager, db: DatabaseManager, server: WebhookServer, ticket_service: TicketService):
        self.root = root
        self.config = config
        self.db = db
        self.server = server
        self.ticket_service = ticket_service
        self.logger = get_logger()
        self._build_ui()
        self.refresh_all()
        self.root.after(5000, self._periodic_refresh)

    def _build_ui(self):
        banner = ttk.Label(self.root, text="IA SAV Telegram Odoo - Copyright 2026 Vincent Gallet - Vincesoft", font=("Segoe UI", 12, "bold"))
        banner.pack(fill="x", padx=10, pady=8)
        self.notebook = ttk.Notebook(self.root)
        self.notebook.pack(fill="both", expand=True, padx=10, pady=10)

        self.dashboard_frame = ttk.Frame(self.notebook)
        self.messages_frame = ttk.Frame(self.notebook)
        self.tickets_frame = ttk.Frame(self.notebook)
        self.config_frame = ttk.Frame(self.notebook)
        self.logs_frame = ttk.Frame(self.notebook)
        self.tests_frame = ttk.Frame(self.notebook)

        self.notebook.add(self.dashboard_frame, text="Tableau de bord")
        self.notebook.add(self.messages_frame, text="Messages reçus")
        self.notebook.add(self.tickets_frame, text="Tickets Odoo")
        self.notebook.add(self.config_frame, text="Configuration")
        self.notebook.add(self.logs_frame, text="Logs")
        self.notebook.add(self.tests_frame, text="Tests API")

        self._build_dashboard()
        self._build_messages_tab()
        self._build_tickets_tab()
        self._build_config_tab()
        self._build_logs_tab()
        self._build_tests_tab()

    def _build_dashboard(self):
        frame = self.dashboard_frame
        stats = ttk.Frame(frame)
        stats.pack(fill="x", pady=10)
        self.total_messages_label = ttk.Label(stats, text="Messages reçus: 0")
        self.tickets_created_label = ttk.Label(stats, text="Tickets créés: 0")
        self.errors_label = ttk.Label(stats, text="Erreurs: 0")
        self.critical_label = ttk.Label(stats, text="Demandes critiques: 0")
        for widget in [self.total_messages_label, self.tickets_created_label, self.errors_label, self.critical_label]:
            widget.pack(anchor="w", pady=2)
        buttons = ttk.Frame(frame)
        buttons.pack(fill="x", pady=10)
        self.start_button = ttk.Button(buttons, text="Démarrer serveur", command=self.start_server)
        self.stop_button = ttk.Button(buttons, text="Arrêter serveur", command=self.stop_server)
        self.server_status_label = ttk.Label(buttons, text="Statut serveur: arrêté")
        self.start_button.pack(side="left", padx=5)
        self.stop_button.pack(side="left", padx=5)
        self.server_status_label.pack(side="left", padx=20)

    def _build_messages_tab(self):
        frame = self.messages_frame
        toolbar = ttk.Frame(frame)
        toolbar.pack(fill="x", pady=5)
        self.refresh_messages_button = ttk.Button(toolbar, text="Rafraîchir", command=self.load_messages)
        self.process_message_button = ttk.Button(toolbar, text="Retraiter avec IA", command=self.reprocess_selected_message)
        self.view_detail_button = ttk.Button(toolbar, text="Voir détail", command=self.show_message_detail)
        self.refresh_messages_button.pack(side="left", padx=4)
        self.process_message_button.pack(side="left", padx=4)
        self.view_detail_button.pack(side="left", padx=4)
        columns = ("id", "received_at", "phone", "message", "urgence", "processed")
        self.messages_tree = ttk.Treeview(frame, columns=columns, show="headings", selectmode="browse")
        for col in columns:
            self.messages_tree.heading(col, text=col)
            self.messages_tree.column(col, width=140, anchor="w")
        self.messages_tree.pack(fill="both", expand=True)
        self.load_messages()

    def _build_tickets_tab(self):
        frame = self.tickets_frame
        toolbar = ttk.Frame(frame)
        toolbar.pack(fill="x", pady=5)
        self.refresh_tickets_button = ttk.Button(toolbar, text="Rafraîchir", command=self.load_tickets)
        self.refresh_tickets_button.pack(side="left", padx=4)
        columns = ("id", "odoo_ticket_id", "title", "priority", "status", "created_at")
        self.tickets_tree = ttk.Treeview(frame, columns=columns, show="headings", selectmode="browse")
        for col in columns:
            self.tickets_tree.heading(col, text=col)
            self.tickets_tree.column(col, width=140, anchor="w")
        self.tickets_tree.pack(fill="both", expand=True)
        self.load_tickets()

    def _build_config_tab(self):
        frame = self.config_frame
        canvas = tk.Canvas(frame)
        scrollbar = ttk.Scrollbar(frame, orient="vertical", command=canvas.yview)
        scroll_host = ttk.Frame(canvas)
        scroll_host.bind("<Configure>", lambda event: canvas.configure(scrollregion=canvas.bbox("all")))
        canvas.create_window((0, 0), window=scroll_host, anchor="nw")
        canvas.configure(yscrollcommand=scrollbar.set)
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        self.config_fields = {}
        field_map = [
            ("APP", "host"), ("APP", "port"), ("APP", "public_base_url"), ("APP", "debug"), ("APP", "mock_mode"),
            ("TELEGRAM", "bot_token"), ("TELEGRAM", "webhook_secret_token"), ("TELEGRAM", "test_chat_id"),
            ("OPENAI", "api_key"), ("OPENAI", "model"), ("OPENAI", "temperature"),
            ("ODOO", "odoo_url"), ("ODOO", "odoo_db"), ("ODOO", "odoo_username"), ("ODOO", "odoo_api_key"), ("ODOO", "helpdesk_model"), ("ODOO", "default_team_id"), ("ODOO", "default_stage_id"),
            ("SERVICE_TEAMS", "copieur_team_id"), ("SERVICE_TEAMS", "telephonie_team_id"), ("SERVICE_TEAMS", "ged_team_id"), ("SERVICE_TEAMS", "informatique_team_id"),
            ("SERVICE_TEAMS", "copieur_team_name"), ("SERVICE_TEAMS", "telephonie_team_name"), ("SERVICE_TEAMS", "ged_team_name"), ("SERVICE_TEAMS", "informatique_team_name"),
            ("SECURITY", "webhook_secret"), ("SECURITY", "allowed_ips"), ("SECURITY", "enable_signature_check"),
            ("FORM", "enable_public_form"),
            ("EMAIL", "enable_email_ingestion"), ("EMAIL", "imap_host"), ("EMAIL", "imap_port"), ("EMAIL", "imap_username"), ("EMAIL", "imap_password"), ("EMAIL", "mailbox"), ("EMAIL", "delete_after_import"),
            ("TICKET_RULES", "critical_keywords"), ("TICKET_RULES", "default_priority"), ("TICKET_RULES", "critical_priority"), ("TICKET_RULES", "auto_reply_enabled"),
            ("DATABASE", "engine"), ("DATABASE", "path"), ("DATABASE", "mysql_host"), ("DATABASE", "mysql_port"), ("DATABASE", "mysql_database"), ("DATABASE", "mysql_user"), ("DATABASE", "mysql_password"),
        ]
        row = 0
        self.secret_values = {}
        for section, option in field_map:
            label = ttk.Label(scroll_host, text=f"{section}.{option}")
            entry = ttk.Entry(scroll_host, width=60)
            value = self.config.get(section, option, "")
            if option in {"bot_token", "webhook_secret_token", "access_token", "api_key", "odoo_api_key", "webhook_secret", "imap_password", "mysql_password"}:
                self.secret_values[(section, option)] = value
                entry.insert(0, self.config.mask_secret(value))
                entry.config(show="*")
            else:
                entry.insert(0, value)
            label.grid(row=row, column=0, sticky="w", padx=5, pady=4)
            entry.grid(row=row, column=1, sticky="we", padx=5, pady=4)
            self.config_fields[(section, option)] = entry
            row += 1
        buttons = ttk.Frame(scroll_host)
        buttons.grid(row=row, column=0, columnspan=2, pady=10)
        ttk.Button(buttons, text="Enregistrer", command=self.save_configuration).pack(side="left", padx=5)
        ttk.Button(buttons, text="Recharger", command=self.reload_configuration).pack(side="left", padx=5)

    def _build_logs_tab(self):
        frame = self.logs_frame
        toolbar = ttk.Frame(frame)
        toolbar.pack(fill="x", pady=5)
        ttk.Button(toolbar, text="Exporter logs", command=self.export_logs).pack(side="left", padx=4)
        self.log_text = tk.Text(frame, wrap="none", state="disabled", height=25)
        self.log_text.pack(fill="both", expand=True)
        self.load_logs()

    def _build_tests_tab(self):
        frame = self.tests_frame
        toolbar = ttk.Frame(frame)
        toolbar.pack(fill="x", pady=10)
        ttk.Button(toolbar, text="Tester Telegram", command=self.test_telegram).pack(side="left", padx=5)
        ttk.Button(toolbar, text="Tester OpenAI", command=self.test_openai).pack(side="left", padx=5)
        ttk.Button(toolbar, text="Tester Odoo", command=self.test_odoo).pack(side="left", padx=5)
        self.tests_result = tk.Text(frame, wrap="word", height=20)
        self.tests_result.pack(fill="both", expand=True, padx=5, pady=5)

    def refresh_all(self):
        self.load_messages()
        self.load_tickets()
        self.load_logs()
        self._update_dashboard()

    def _periodic_refresh(self):
        self.refresh_all()
        self.root.after(5000, self._periodic_refresh)

    def start_server(self):
        self.server.start()
        self.server_status_label.config(text="Statut serveur: démarré")

    def stop_server(self):
        self.server.stop()
        self.server_status_label.config(text="Statut serveur: arrêté")

    def load_messages(self):
        for row in self.messages_tree.get_children():
            self.messages_tree.delete(row)
        messages = self.db.fetch_recent_messages()
        for row in messages:
            self.messages_tree.insert("", "end", values=(row["id"], row["received_at"], row["phone"], row["message"], row["urgence"], row["processed"]))
        self._update_dashboard()

    def load_tickets(self):
        for row in self.tickets_tree.get_children():
            self.tickets_tree.delete(row)
        tickets = self.db.fetch_tickets()
        for row in tickets:
            self.tickets_tree.insert("", "end", values=(row["id"], row["odoo_ticket_id"], row["title"], row["priority"], row["status"], row["created_at"]))

    def load_logs(self):
        logs = self.db.fetch_logs()
        self.log_text.config(state="normal")
        self.log_text.delete("1.0", "end")
        for row in logs:
            self.log_text.insert("end", f"[{row['created_at']}] [{row['level']}] [{row['source']}] {row['message']}\n")
        self.log_text.config(state="disabled")

    def save_configuration(self):
        for (section, option), entry in self.config_fields.items():
            value = entry.get().strip()
            if option in {"bot_token", "webhook_secret_token", "access_token", "api_key", "odoo_api_key", "webhook_secret", "imap_password", "mysql_password"} and value == self.config.mask_secret(self.secret_values.get((section, option), "")):
                value = self.secret_values.get((section, option), "")
            self.config.set(section, option, value)
        self.config.save()
        messagebox.showinfo("Configuration", "Configuration enregistrée avec succès.")
        self.reload_configuration()

    def reload_configuration(self):
        self.config.load()
        self.secret_values = {}
        for (section, option), entry in self.config_fields.items():
            value = self.config.get(section, option, "")
            if option in {"bot_token", "webhook_secret_token", "access_token", "api_key", "odoo_api_key", "webhook_secret", "imap_password", "mysql_password"}:
                self.secret_values[(section, option)] = value
                entry.delete(0, "end")
                entry.insert(0, self.config.mask_secret(value))
            else:
                entry.delete(0, "end")
                entry.insert(0, value)
        messagebox.showinfo("Configuration", "Configuration rechargée.")

    def export_logs(self):
        output_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files", "*.txt")])
        if not output_path:
            return
        logs = self.db.fetch_logs(limit=1000)
        with open(output_path, "w", encoding="utf-8") as f:
            for row in logs:
                f.write(f"[{row['created_at']}] [{row['level']}] [{row['source']}] {row['message']}\n")
        messagebox.showinfo("Logs", f"Logs exportés vers {output_path}")

    def test_telegram(self):
        chat_id = self.config.get("TELEGRAM", "test_chat_id")
        if not chat_id:
            self._append_test_result("Telegram: chat_id de test non défini. Ajoutez TELEGRAM.test_chat_id dans config.ini.")
            return
        try:
            result = self.server.messaging_api.send_text_message(chat_id, "Test API Telegram depuis IA SAV")
            self._append_test_result(f"Telegram OK: {result}")
        except Exception as exc:
            self._append_test_result(f"Telegram erreur: {exc}")

    def test_openai(self):
        try:
            result = self.server.ticket_service.ai_analyzer.analyze("Bonjour, mon imprimante ne scanne plus et j'ai besoin d'aide rapidement.")
            self._append_test_result(f"OpenAI OK: {result}")
        except Exception as exc:
            self._append_test_result(f"OpenAI erreur: {exc}")

    def test_odoo(self):
        try:
            desc = "Test de création de ticket depuis l'interface de gestion."
            result = self.server.ticket_service.odoo_api.create_helpdesk_ticket("Test ticket Odoo", desc, self.config.getint("TICKET_RULES", "default_priority", fallback=1))
            self._append_test_result(f"Odoo OK: {result}")
        except Exception as exc:
            self._append_test_result(f"Odoo erreur: {exc}")

    def _append_test_result(self, message):
        self.tests_result.insert("end", f"{message}\n")
        self.tests_result.see("end")

    def show_message_detail(self):
        selected = self.messages_tree.focus()
        if not selected:
            messagebox.showwarning("Sélection", "Sélectionnez un message.")
            return
        item = self.messages_tree.item(selected)
        values = item["values"]
        record_id = values[0]
        row = self.db.fetch_message_by_id(record_id)
        if not row:
            return
        detail = (
            f"ID interne: {row['id']}\n"
            f"Message ID: {row['whatsapp_message_id']}\n"
            f"Téléphone: {row['phone']}\n"
            f"Contact: {row['contact_name']}\n"
            f"Message: {row['message']}\n"
            f"Reçu le: {row['received_at']}\n"
            f"Traité: {row['processed']}\n"
        )
        messagebox.showinfo("Détail du message", detail)

    def reprocess_selected_message(self):
        selected = self.messages_tree.focus()
        if not selected:
            messagebox.showwarning("Sélection", "Sélectionnez un message à retraiter.")
            return
        item = self.messages_tree.item(selected)
        record_id = item["values"][0]
        row = self.db.fetch_message_by_id(record_id)
        if not row:
            return
        threading.Thread(target=self._reprocess_message, args=(row,), daemon=True).start()

    def _reprocess_message(self, row):
        self.ticket_service.process_saved_message(row)
        self.load_messages()
        self.load_tickets()

    def _update_dashboard(self):
        total = len(self.db.fetch_recent_messages(limit=1000))
        tickets = len(self.db.fetch_tickets(limit=1000))
        errors = len([row for row in self.db.fetch_logs(limit=1000) if row["level"] in ("ERROR", "CRITICAL")])
        critical = len([row for row in self.db.fetch_recent_messages(limit=1000) if row["urgence"] == "critique"])
        self.total_messages_label.config(text=f"Messages reçus: {total}")
        self.tickets_created_label.config(text=f"Tickets créés: {tickets}")
        self.errors_label.config(text=f"Erreurs: {errors}")
        self.critical_label.config(text=f"Demandes critiques: {critical}")
