package controllers

import (
	"crypto/subtle"
	"fmt"
	"log"
	"regexp"
	"strconv"
	"strings"

	"github.com/gofiber/fiber/v2"
	"github.com/sujit-baniya/fiber-boilerplate/app"
	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
	"github.com/sujit-baniya/fiber-boilerplate/pkg/services"
)

// ─── Webhook de correo entrante ───────────────────────────────────────────────
// Recibe notificaciones de SendGrid, Mailgun, etc.
// POST /webhooks/soporte/:provider?key=<ApiKey de la config activa>
// provider: sendgrid, mailgun, generic

type soporteEmailIn struct {
	From      string `json:"from" form:"from"`
	Subject   string `json:"subject" form:"subject"`
	Text      string `json:"text" form:"text"`
	Html      string `json:"html" form:"html"`
	Sender    string `json:"sender" form:"sender"`
	FromName  string `json:"from_name" form:"from_name"`
	MessageID string `json:"message_id" form:"message_id"`
}

var messageIDHeaderRe = regexp.MustCompile(`(?im)^Message-ID:\s*(<[^>\r\n]+>)`)

// validarWebhookKey compara la key recibida (query ?key= o header X-Webhook-Key /
// X-Api-Key) contra el ApiKey guardado en la config activa, en tiempo constante.
// Si la config no tiene ApiKey configurado, se rechaza toda petición: hay que
// definirlo en /app/soporte-webhook y usar esa misma URL con ?key=... en el proveedor.
func validarWebhookKey(c *fiber.Ctx, cfg *models.SoporteWebhookConfig) bool {
	if cfg.ApiKey == "" {
		return false
	}
	key := c.Query("key")
	if key == "" {
		key = c.Get("X-Webhook-Key")
	}
	if key == "" {
		key = c.Get("X-Api-Key")
	}
	if key == "" {
		return false
	}
	return subtle.ConstantTimeCompare([]byte(key), []byte(cfg.ApiKey)) == 1
}

func SoporteWebhook(c *fiber.Ctx) error {
	provider := c.Params("provider", "generic")

	cfg, err := models.GetSoporteWebhookActivo()
	if err != nil {
		log.Printf("[SoporteWebhook] Sin config activa: %v", err)
		return c.Status(200).JSON(fiber.Map{"ok": false, "error": "sin config"})
	}

	if !validarWebhookKey(c, cfg) {
		log.Printf("[SoporteWebhook] Petición rechazada (key inválida o ausente) desde IP %s", c.IP())
		return c.Status(401).JSON(fiber.Map{"ok": false, "error": "no autorizado"})
	}

	var emails []soporteEmailIn

	switch provider {
	case "sendgrid":
		var sg struct {
			From     string `json:"from" form:"from"`
			Subject  string `json:"subject" form:"subject"`
			Text     string `json:"text" form:"text"`
			Html     string `json:"html" form:"html"`
			Sender   string `json:"sender" form:"sender"`
			FromName string `json:"from_name" form:"from_name"`
			Headers  string `json:"headers" form:"headers"`
		}
		if err := c.BodyParser(&sg); err != nil {
			return c.Status(200).JSON(fiber.Map{"ok": false, "error": "body inválido"})
		}
		emails = append(emails, soporteEmailIn{
			From: sg.From, Subject: sg.Subject, Text: sg.Text, Html: sg.Html,
			Sender: sg.Sender, FromName: sg.FromName, MessageID: extractMessageIDFromHeaders(sg.Headers),
		})
	case "mailgun":
		var mg struct {
			From      string `form:"from"`
			Subject   string `form:"subject"`
			Text      string `form:"body-plain"`
			Html      string `form:"body-html"`
			Sender    string `form:"sender"`
			FromName  string `form:"from_name"`
			MessageID string `form:"Message-Id"`
		}
		if err := c.BodyParser(&mg); err != nil {
			return c.Status(200).JSON(fiber.Map{"ok": false})
		}
		emails = append(emails, soporteEmailIn{
			From: mg.From, Subject: mg.Subject, Text: mg.Text,
			Html: mg.Html, Sender: mg.Sender, FromName: mg.FromName, MessageID: mg.MessageID,
		})
	default:
		var generic struct {
			From      string `json:"from"`
			Subject   string `json:"subject"`
			Text      string `json:"text"`
			Html      string `json:"html"`
			MessageID string `json:"message_id"`
		}
		if err := c.BodyParser(&generic); err != nil {
			return c.Status(200).JSON(fiber.Map{"ok": false})
		}
		emails = append(emails, soporteEmailIn{
			From: generic.From, Subject: generic.Subject, Text: generic.Text, Html: generic.Html,
			MessageID: generic.MessageID,
		})
	}

	for _, e := range emails {
		contenido := e.Text
		if contenido == "" {
			contenido = e.Html
		}
		services.IngestarCorreoSoporte(cfg, services.CorreoSoporte{
			From: e.From, FromName: e.FromName, Subject: e.Subject,
			Texto: contenido, MessageID: e.MessageID,
		})
	}

	return c.Status(200).JSON(fiber.Map{"ok": true})
}

func extractMessageIDFromHeaders(headers string) string {
	if headers == "" {
		return ""
	}
	if m := messageIDHeaderRe.FindStringSubmatch(headers); m != nil {
		return m[1]
	}
	return ""
}

// ─── Asignar ticket a usuario ─────────────────────────────────────────────────
// PUT /app/tickets/:ticketID/asignar

func AsignarTicket(c *fiber.Ctx) error {
	ticketID, _ := strconv.ParseUint(c.Params("ticketID"), 10, 32)
	type Req struct {
		AsignadoID uint `json:"asignado_id"`
	}
	var req Req
	if err := c.BodyParser(&req); err != nil {
		return c.Status(400).JSON(fiber.Map{"error": "body inválido"})
	}
	if err := app.Http.Database.DB.Model(&models.ProyectoTicket{}).
		Where("id = ?", ticketID).
		Update("asignado_a", req.AsignadoID).Error; err != nil {
		return c.Status(500).JSON(fiber.Map{"error": err.Error()})
	}
	return c.JSON(fiber.Map{"ok": true})
}

// ─── Listar admins para asignación ────────────────────────────────────────────
// GET /app/tickets/admins

func GetSoporteAdmins(c *fiber.Ctx) error {
	var admins []models.Users
	app.Http.Database.DB.Where("is_admin = ?", true).
		Or("role_id IN (SELECT id FROM roles WHERE name = 'soporte' OR name = 'admin')").
		Find(&admins)
	type item struct {
		ID   uint   `json:"id"`
		Name string `json:"name"`
	}
	result := make([]item, 0)
	for _, a := range admins {
		result = append(result, item{ID: a.ID, Name: a.Name})
	}
	return c.JSON(result)
}

// ─── Configuración del webhook ────────────────────────────────────────────────

func SoporteWebhookConfigPage(c *fiber.Ctx) error {
	cfg, _ := models.GetSoporteWebhookActivo()
	return c.Render("soporte_webhook", fiber.Map{
		"user":    c.Locals("user"),
		"modules": c.Locals("userModules"),
		"cfg":     cfg,
	}, "layouts/main")
}

func GetSoporteWebhookConfig(c *fiber.Ctx) error {
	cfg, err := models.GetSoporteWebhookActivo()
	if err != nil {
		return c.JSON(fiber.Map{"data": nil})
	}
	cfg.TieneImapPassword = cfg.ImapPasswordEnc != ""
	return c.JSON(fiber.Map{"data": cfg})
}

func SaveSoporteWebhookConfig(c *fiber.Ctx) error {
	type body struct {
		ID               uint   `json:"id"`
		Nombre           string `json:"nombre"`
		Provider         string `json:"provider"`
		ApiKey           string `json:"api_key"`
		EmailDestino     string `json:"email_destino"`
		ResponderAuto    bool   `json:"responder_auto"`
		MensajeAuto      string `json:"mensaje_auto"`
		AsignarA         *uint  `json:"asignar_a"`
		SmtpHost         string `json:"smtp_host"`
		SmtpPort         int    `json:"smtp_port"`
		SmtpUsername     string `json:"smtp_username"`
		SmtpPassword     string `json:"smtp_password"`
		SmtpEncryption   string `json:"smtp_encryption"`
		SmtpFromAddr     string `json:"smtp_from_addr"`
		SmtpFromName     string `json:"smtp_from_name"`
		ImapActivo       bool   `json:"imap_activo"`
		ImapHost         string `json:"imap_host"`
		ImapPort         int    `json:"imap_port"`
		ImapUsername     string `json:"imap_username"`
		ImapPassword     string `json:"imap_password"`
		ImapEncryption   string `json:"imap_encryption"`
		ImapCarpeta      string `json:"imap_carpeta"`
		ImapHorasAtras   int    `json:"imap_horas_atras"`
		AgenteBorradorID *uint  `json:"agente_borrador_id"`
		ClasificarConIA  bool   `json:"clasificar_con_ia"`
		ContextoNegocio  string `json:"contexto_negocio"`
	}
	var b body
	if err := c.BodyParser(&b); err != nil {
		return c.Status(400).JSON(fiber.Map{"error": "body inválido"})
	}
	port := b.SmtpPort
	if port == 0 {
		port = 587
	}
	enc := b.SmtpEncryption
	if enc == "" {
		enc = "starttls"
	}
	imapPort := b.ImapPort
	if imapPort == 0 {
		imapPort = 993
	}
	imapEnc := b.ImapEncryption
	if imapEnc == "" {
		imapEnc = "ssl"
	}
	carpeta := b.ImapCarpeta
	if carpeta == "" {
		carpeta = "INBOX"
	}
	// La contraseña IMAP solo viaja cuando el admin la escribe de nuevo: si el
	// formulario la manda vacía, se conserva la que ya estaba guardada.
	passEnc := ""
	if b.ImapPassword != "" {
		enc, err := services.CifrarSecretoUmind(b.ImapPassword)
		if err != nil {
			return c.Status(500).JSON(fiber.Map{"error": err.Error()})
		}
		passEnc = enc
	} else if b.ID > 0 {
		if actual, err := models.GetSoporteWebhookActivo(); err == nil && actual != nil && actual.ID == b.ID {
			passEnc = actual.ImapPasswordEnc
		}
	}

	cfg := &models.SoporteWebhookConfig{
		Nombre:           b.Nombre,
		Provider:         b.Provider,
		ApiKey:           b.ApiKey,
		EmailDestino:     b.EmailDestino,
		ResponderAuto:    b.ResponderAuto,
		MensajeAuto:      b.MensajeAuto,
		AsignarA:         b.AsignarA,
		SmtpHost:         b.SmtpHost,
		SmtpPort:         port,
		SmtpUsername:     b.SmtpUsername,
		SmtpPassword:     b.SmtpPassword,
		SmtpEncryption:   enc,
		SmtpFromAddr:     b.SmtpFromAddr,
		SmtpFromName:     b.SmtpFromName,
		ImapActivo:       b.ImapActivo,
		ImapHost:         b.ImapHost,
		ImapPort:         imapPort,
		ImapUsername:     b.ImapUsername,
		ImapPasswordEnc:  passEnc,
		ImapEncryption:   imapEnc,
		ImapCarpeta:      carpeta,
		ImapHorasAtras:   b.ImapHorasAtras,
		ClasificarConIA:  b.ClasificarConIA,
		ContextoNegocio:  b.ContextoNegocio,
		AgenteBorradorID: b.AgenteBorradorID,
		Activo:           true,
	}
	cfg.ID = b.ID
	if err := models.SaveSoporteWebhookConfig(cfg); err != nil {
		return c.Status(500).JSON(fiber.Map{"error": err.Error()})
	}
	return c.JSON(fiber.Map{"ok": true})
}

// ─── helpers ──────────────────────────────────────────────────────────────────

// ProbarImapSoporte valida las credenciales del buzón contra el servidor.
// POST /app/api/soporte-webhook/probar-imap
func ProbarImapSoporte(c *fiber.Ctx) error {
	cfg, err := models.GetSoporteWebhookActivo()
	if err != nil || cfg == nil {
		return c.Status(400).JSON(fiber.Map{"error": "Guardá la configuración antes de probar"})
	}
	detalle, err := services.ProbarConexionImap(cfg)
	if err != nil {
		return c.Status(400).JSON(fiber.Map{"error": err.Error()})
	}
	return c.JSON(fiber.Map{"ok": true, "message": detalle})
}

// RevisarBuzonAhora dispara una lectura del buzón sin esperar al cron.
// POST /app/api/soporte-webhook/revisar-buzon
func RevisarBuzonAhora(c *fiber.Ctx) error {
	encontrados, procesados, err := services.RevisarBuzonSoporteConDetalle()
	if err != nil {
		if encontrados > 0 {
			// Se hizo trabajo igual: decir las dos cosas, no solo el fallo.
			return c.Status(200).JSON(fiber.Map{"ok": false, "message": fmt.Sprintf(
				"%d correo(s) encontrados, %d convertido(s) en ticket — %s", encontrados, procesados, err.Error())})
		}
		return c.Status(400).JSON(fiber.Map{"error": err.Error()})
	}
	if encontrados == 0 {
		return c.JSON(fiber.Map{"ok": true, "message": "Conectó bien, pero no hay correos sin leer en el buzón"})
	}
	msg := fmt.Sprintf("%d correo(s) sin leer, %d convertido(s) en ticket. El resto ya estaba registrado.", encontrados, procesados)
	// Si el filtro descartó algo hay que decirlo acá: un correo de un cliente
	// que se comió la IA es exactamente lo que nadie va a ir a buscar al log.
	if descartes := services.UltimosCorreosDescartados(); len(descartes) > 0 {
		msg += fmt.Sprintf(" El filtro descartó %d: %s", len(descartes), strings.Join(descartes, " | "))
	}
	if e := services.UltimoErrorAcuse(); e != "" {
		msg += " ⚠️ " + e
	}
	return c.JSON(fiber.Map{"ok": true, "message": msg})
}

// BorradorRespuestaTicket propone una respuesta usando la base de conocimiento.
// No envía nada: el borrador vuelve al cuadro de respuesta para que lo revise
// una persona.
// POST /app/tickets/:ticketID/borrador
func BorradorRespuestaTicket(c *fiber.Ctx) error {
	id, err := strconv.ParseUint(c.Params("ticketID"), 10, 32)
	if err != nil {
		return c.Status(400).JSON(fiber.Map{"error": "ID inválido"})
	}
	ticket, err := models.GetTicketByID(uint(id))
	if err != nil {
		return c.Status(404).JSON(fiber.Map{"error": "Ticket no encontrado"})
	}
	borrador, err := services.RedactarBorradorTicket(ticket)
	if err != nil {
		return c.Status(422).JSON(fiber.Map{"error": err.Error()})
	}
	return c.JSON(fiber.Map{"borrador": borrador})
}

// GetAgentesParaBorrador lista los agentes de uMind para elegir de cuál sale la
// documentación de los borradores.
// GET /app/soporte/agentes
func GetAgentesParaBorrador(c *fiber.Ctx) error {
	items, err := models.GetTodosLosUmindAgentes()
	if err != nil {
		return c.Status(500).JSON(fiber.Map{"error": err.Error()})
	}
	salida := make([]fiber.Map, 0, len(items))
	for _, a := range items {
		salida = append(salida, fiber.Map{"id": a.ID, "nombre": a.Nombre})
	}
	return c.JSON(salida)
}

// ProbarEnvioSoporte manda un correo de prueba por el mismo camino que el acuse
// automático de los tickets.
// POST /app/soporte/webhook/probar-envio
func ProbarEnvioSoporte(c *fiber.Ctx) error {
	var b struct {
		Email string `json:"email"`
	}
	if err := c.BodyParser(&b); err != nil {
		return c.Status(400).JSON(fiber.Map{"error": "body inválido"})
	}
	if err := services.ProbarEnvioSoporte(b.Email); err != nil {
		return c.Status(400).JSON(fiber.Map{"error": err.Error()})
	}
	return c.JSON(fiber.Map{"ok": true, "message": "Correo de prueba enviado a " + b.Email})
}