import threading
from flask import Flask, request, jsonify, render_template_string, send_from_directory
from .config_manager import ConfigManager
from .logger_manager import get_logger

FORM_TEMPLATE = """
<!doctype html>
<html lang="fr">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Nouvelle demande SAV</title>
  <style>
    body { margin: 0; font-family: Arial, sans-serif; background: #f5f7fa; color: #1f2933; }
    main { max-width: 720px; margin: 40px auto; padding: 0 18px; }
    form { background: white; border: 1px solid #d8dee6; border-radius: 8px; padding: 24px; }
    h1 { font-size: 26px; margin: 0 0 18px; }
    label { display: block; font-weight: 700; margin-top: 14px; }
    input, textarea { box-sizing: border-box; width: 100%; margin-top: 6px; padding: 11px; border: 1px solid #b8c2cc; border-radius: 6px; font: inherit; }
    textarea { min-height: 160px; resize: vertical; }
    button { margin-top: 18px; padding: 12px 18px; border: 0; border-radius: 6px; background: #0f766e; color: white; font-weight: 700; cursor: pointer; }
    .message { margin-bottom: 16px; padding: 12px; border-radius: 6px; background: #e7f7ee; border: 1px solid #a7e3bd; }
    .error { background: #fdecec; border-color: #f5b5b5; }
    .hp { display: none; }
  </style>
</head>
<body>
  <main>
    <form method="post" action="/demande">
      <h1>Nouvelle demande SAV</h1>
      {% if status %}<div class="message">{{ status }}</div>{% endif %}
      {% if error %}<div class="message error">{{ error }}</div>{% endif %}
      <label for="name">Nom</label>
      <input id="name" name="name" autocomplete="name" required>
      <label for="contact">Email ou telephone</label>
      <input id="contact" name="contact" autocomplete="email" required>
      <label for="subject">Sujet</label>
      <input id="subject" name="subject" required>
      <label for="message">Demande</label>
      <textarea id="message" name="message" required></textarea>
      <input class="hp" name="website" tabindex="-1" autocomplete="off">
      <button type="submit">Envoyer la demande</button>
    </form>
  </main>
</body>
</html>
"""

class WebhookServer:
    def __init__(self, config: ConfigManager, logger, messaging_api, ticket_service):
        self.config = config
        self.logger = logger
        self.messaging_api = messaging_api
        self.ticket_service = ticket_service
        self.app = Flask(__name__)
        self._configure_routes()
        self.thread = None

    def _configure_routes(self):
        @self.app.route("/webhook", methods=["GET"])
        def verify():
            return "Telegram webhook ready", 200

        @self.app.route("/webhook", methods=["POST"])
        def receive():
            secret_token = request.headers.get("X-Telegram-Bot-Api-Secret-Token")
            if not self.messaging_api.check_secret_token(secret_token):
                self.logger.warning("Token secret Telegram invalide")
                return "Invalid secret token", 403
            try:
                payload = request.get_json(force=True)
            except Exception:
                self.logger.error("Payload webhook invalide")
                return "Invalid payload", 400
            messages = self.messaging_api.parse_webhook_payload(payload)
            for message_record in messages:
                try:
                    self.ticket_service.process_saved_message(message_record)
                except Exception as exc:
                    self.logger.error(f"Erreur traitement message webhook: {exc}")
            return jsonify({"success": True, "received": len(messages)}), 200

        @self.app.route("/demande", methods=["GET", "POST"])
        def support_form():
            if not self.config.getboolean("FORM", "enable_public_form", fallback=True):
                return "Formulaire indisponible", 404
            if request.method == "GET":
                return render_template_string(FORM_TEMPLATE)

            if request.form.get("website"):
                return render_template_string(FORM_TEMPLATE, status="Votre demande a bien ete recue.")

            name = request.form.get("name", "").strip()
            contact = request.form.get("contact", "").strip()
            subject = request.form.get("subject", "").strip()
            message = request.form.get("message", "").strip()
            if not name or not contact or not subject or not message:
                return render_template_string(FORM_TEMPLATE, error="Tous les champs sont obligatoires."), 400

            try:
                self.ticket_service.create_support_request("formulaire", contact, name, message, subject)
            except Exception as exc:
                self.logger.error(f"Erreur creation demande formulaire: {exc}")
                return render_template_string(FORM_TEMPLATE, error="Impossible d'enregistrer la demande pour le moment."), 500
            return render_template_string(FORM_TEMPLATE, status="Votre demande a bien ete recue.")

        @self.app.route("/attachments/<path:filename>", methods=["GET"])
        def attachments(filename):
            attachments_dir = self.config.project_root / "data" / "attachments"
            return send_from_directory(attachments_dir, filename)

        @self.app.route("/shutdown", methods=["POST"])
        def shutdown():
            if request.remote_addr not in {"127.0.0.1", "::1"}:
                return "Forbidden", 403
            func = request.environ.get("werkzeug.server.shutdown")
            if func is None:
                return "Server shutdown impossible", 500
            func()
            return "Server stopped", 200

    def run(self):
        host = self.config.get("APP", "host", fallback="0.0.0.0")
        port = self.config.getint("APP", "port", fallback=8080)
        self.logger.info(f"Demarrage du serveur webhook sur {host}:{port}")
        self.app.run(host=host, port=port, threaded=True)

    def start(self):
        if self.thread and self.thread.is_alive():
            self.logger.warning("Le serveur webhook est déjà démarré")
            return
        self.thread = threading.Thread(target=self.run, daemon=True)
        self.thread.start()

    def stop(self):
        host = self.config.get("APP", "host", fallback="127.0.0.1")
        if host == "0.0.0.0":
            host = "127.0.0.1"
        port = self.config.getint("APP", "port", fallback=8080)
        try:
            import requests
            response = requests.post(f"http://{host}:{port}/shutdown", timeout=5)
            if response.status_code == 200:
                self.logger.info("Serveur webhook arrêté")
        except Exception as exc:
            self.logger.warning(f"Impossible d'arreter le serveur webhook: {exc}")
