package main

import (
	"database/sql"
	_ "embed"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"gitlab.com/medis365/medis-tools/comun"
)

//go:embed formas365.sql
var formas365SQL string

var queries = comun.ParsearQueries(formas365SQL)

// codigoCartaReapertura solo lleva adjunto, sin preguntas ni firma: no genera PDF.
const codigoCartaReapertura = 2

type resultadoAlcance struct {
	DB               string `json:"db"`
	FormatosEnviados int    `json:"formatos_enviados"`
	FormatosFirmados int    `json:"formatos_firmados"`
	Pacientes        int    `json:"pacientes"`
}

func leerParametros() (accion, db, password string) {
	accionFlag := flag.String("accion", "", "acción a ejecutar: estatus, exportar, alcance, eliminar")
	// -db es el correo de la cuenta de Formas365: identifica la exportación (nombre del ZIP,
	// carpeta, estatus, registro) y a la vez es la cuenta que se resuelve en SFA.
	dbFlag := flag.String("db", "", "correo de la cuenta de Formas365")
	passwordFlag := flag.String("password", "", "contraseña para el ZIP exportado")
	// SFA vive en el cluster global; el flag se acepta porque medis-back lo pasa, pero no se usa.
	flag.Int("cluster", comun.ClusterGlobal, "no usado: SFA vive en el cluster global")
	flag.Parse()

	accionesValidas := map[string]bool{"estatus": true, "exportar": true, "alcance": true, "eliminar": true}
	if !accionesValidas[*accionFlag] {
		fmt.Fprintln(os.Stderr, "Error: -accion debe ser 'estatus', 'exportar', 'alcance' o 'eliminar'")
		os.Exit(1)
	}

	if err := os.MkdirAll("exportaciones", 0755); err != nil {
		log.Fatal(err)
	}

	if *accionFlag == "estatus" {
		return *accionFlag, "", ""
	}

	if *dbFlag == "" {
		fmt.Fprintf(os.Stderr, "Error: -db requerido para %s\n", *accionFlag)
		os.Exit(1)
	}
	if !comun.NombreDBValido(*dbFlag) {
		fmt.Fprintln(os.Stderr, "Error: -db contiene caracteres inválidos")
		os.Exit(1)
	}

	// exportar y alcance resuelven la cuenta por ese correo; se valida solo que tenga @.
	if *accionFlag == "exportar" || *accionFlag == "alcance" {
		if !strings.Contains(*dbFlag, "@") {
			fmt.Fprintln(os.Stderr, "Error: -db debe ser el correo de Formas365 (debe contener @)")
			os.Exit(1)
		}
	}

	if *accionFlag == "exportar" {
		if *passwordFlag == "" {
			fmt.Fprintln(os.Stderr, "Error: -password requerido para exportar")
			os.Exit(1)
		}
		comun.IniciarEstatus(comun.Estatus{
			DB:          *dbFlag,
			Modulos:     []string{},
			FechaInicio: time.Now().In(comun.ZonaMX()).Format(comun.FormatoFecha),
			Estatus:     "EN_PROCESO",
			Mensaje:     "Iniciando",
		})
	}

	return *accionFlag, *dbFlag, *passwordFlag
}

// conectarFormas365 abre la BD de Formas365 (cluster global; la comparten todas las cuentas)
// y resuelve el ID de la cuenta con ese email, por el que filtran las demás queries. El email
// debe corresponder a exactamente un usuario.
func conectarFormas365(config comun.Config, email string) (*sql.DB, string, error) {
	conexion, err := config.ConexionCluster(comun.ClusterGlobal)
	if err != nil {
		return nil, "", err
	}
	dbFormas, err := comun.ConectarDB(conexion.DSN(config.Formas365DB))
	if err != nil {
		return nil, "", err
	}
	_, usuarios := comun.EjecutarQueryPrivada(dbFormas, queries["obtenerUsuarioFormas"], email)
	if len(usuarios) != 1 {
		dbFormas.Close()
		return nil, "", fmt.Errorf("Usuario no encontrado")
	}
	return dbFormas, usuarios[0]["ID"], nil
}

func exportarFormas(dbName, password string) {
	start := time.Now()
	comun.LogInfo("Iniciando exportación de Formas365")

	config, err := comun.CargarConfig()
	if err != nil {
		comun.LogFatal(err)
	}
	comun.MuestrearRAM() // pico inicial para el primer estatus
	go comun.VigilarMemoria(config.LimiteMemoriaMB)

	comun.ActualizarMensaje("Conectando con Formas365")
	db, idUsuario, err := conectarFormas365(config, dbName)
	if err != nil {
		comun.LogFatal(err)
	}
	defer db.Close()
	comun.LogInfo("Cuenta de Formas365 resuelta: usuario %s", idUsuario)

	baseDir := comun.PrepararExportacion(dbName)

	_, formatos := comun.EjecutarQuery(db, queries["obtenerFormatosEnviados"], idUsuario, codigoCartaReapertura)
	if len(formatos) == 0 {
		comun.LogFatal(fmt.Errorf("el cliente %s no tiene formatos de Formas365 para exportar", dbName))
	}
	pacientes := make(map[string]bool)
	for _, formato := range formatos {
		pacientes[formato["CODIGOPACIENTE"]] = true
	}
	total := len(formatos)
	comun.ActualizarEstatus(func(e *comun.Estatus) { e.PacientesTotal = len(pacientes) })
	comun.LogInfo("Exportando %d formato(s) de %d paciente(s)", total, len(pacientes))

	cfg := comun.ConfigCarta()
	for i, formato := range formatos {
		nombrePaciente := formato["PACIENTE"]
		if nombrePaciente == "" {
			nombrePaciente = "Sin nombre"
		}
		carpeta := filepath.Join(baseDir, fmt.Sprintf("%s - %s", formato["CODIGOPACIENTE"], comun.SanitizarDir(nombrePaciente)))
		if err := os.MkdirAll(carpeta, 0755); err != nil {
			comun.LogFatal(fmt.Errorf("paciente %s, formato %s: %w", formato["CODIGOPACIENTE"], formato["CONSECUTIVO"], comun.LimpiarErrorRuta(err)))
		}
		exportarFormato(db, cfg, formato, nombrePaciente, carpeta)

		comun.ActualizarEstatus(func(e *comun.Estatus) {
			e.Progreso = comun.Redondear2(float64(i+1) / float64(total) * 100)
			e.Mensaje = fmt.Sprintf("Exportando formatos (%d/%d)", i+1, total)
		})
	}

	comun.ActualizarMensaje("Comprimiendo ZIP")
	comun.LogInfo("Generando ZIP de exportación")
	startZip := time.Now()
	if err := comun.GenerarZIP(dbName, password, comun.CarpetaZip{Origen: baseDir, Prefijo: dbName + "_Formas365"}); err != nil {
		comun.LogFatal(fmt.Errorf("al comprimir el ZIP: %w", err))
	}
	comun.FinalizarExportacion(dbName, baseDir, start, startZip, 0)
}

// exportarFormato espeja la vista sfa/formato_pdf de medis-back.
func exportarFormato(db *sql.DB, cfg comun.ConfigPDF, formato map[string]string, nombrePaciente, carpeta string) {
	consecutivo := formato["CONSECUTIVO"]
	nombreFormato := formato["FORMATO"]
	if nombreFormato == "" {
		nombreFormato = "Formato"
	}
	fecha := formatearFecha(formato["FECHA"])

	rep := comun.NuevoReporte(cfg, comun.Empresa{Nombre: nombreFormato, Subtitulo: fecha})
	rep.PDF.AddPage()
	comun.CrearParrafosPdf(rep, "Datos del formato",
		[]string{"Folio", "Fecha", "Paciente", "Médico"},
		[]map[string]string{{"Folio": consecutivo, "Fecha": fecha, "Paciente": nombrePaciente, "Médico": formato["MEDICO"]}},
	)

	_, secciones := comun.EjecutarQuery(db, queries["obtenerSecciones"], formato["CODIGOHC"])
	_, respuestas := comun.EjecutarQuery(db, queries["obtenerRespuestas"], formato["CODIGOPACIENTE"], consecutivo, formato["CODIGOHC"])
	respuestasPorSeccion := make(map[string][]map[string]string)
	for _, respuesta := range respuestas {
		seccion := respuesta["CODIGOSECCIONHC"]
		respuestasPorSeccion[seccion] = append(respuestasPorSeccion[seccion], map[string]string{
			"Pregunta":  respuesta["DESCRIPCION"],
			"Respuesta": formatearRespuesta(respuesta["TIPO_RESPUESTA"], respuesta["RESPUESTA"]),
		})
	}

	cols := []string{"Pregunta", "Respuesta"}
	for _, seccion := range secciones {
		if filas, ok := respuestasPorSeccion[seccion["CODIGOSECCION"]]; ok {
			comun.SubtituloSeccion(rep, seccion["DESCRIPCION"])
			comun.CrearTablaPdf(rep, cols, filas)
		} else if seccion["TIENE_PREGUNTAS"] == "0" {
			// Sección informativa: la descripción es el texto que leyó el paciente.
			rep.PDF.Ln(2)
			rep.PDF.SetFont(rep.Cfg.FontName, "", rep.Cfg.FontSize)
			rep.PDF.MultiCell(0, 5, seccion["DESCRIPCION"], "", "L", false)
		}
	}

	renderizarFirma(db, rep, consecutivo, nombrePaciente)

	nombreArchivo := fmt.Sprintf("%s - %s - %s.pdf", consecutivo, comun.SanitizarDir(nombreFormato), formato["FECHA"])
	comun.GuardarPDF(rep, filepath.Join(carpeta, nombreArchivo), fmt.Sprintf("paciente %s, formato %s", formato["CODIGOPACIENTE"], consecutivo))
}

func renderizarFirma(db *sql.DB, rep comun.Reporte, consecutivo, nombrePaciente string) {
	_, firmas := comun.EjecutarQuery(db, queries["obtenerFirma"], consecutivo)
	rep.PDF.Ln(6)
	comun.SubtituloSeccion(rep, "Firma del paciente")
	rep.PDF.Ln(2)

	if len(firmas) == 0 || firmas[0]["BASE64"] == "" {
		rep.PDF.SetFont(rep.Cfg.FontName, "I", rep.Cfg.FontSize)
		rep.PDF.CellFormat(0, 6, "Formato sin firma.", "", 1, "L", false, 0, "")
		return
	}
	if err := comun.InsertarImagenDataURI(rep, "firma", firmas[0]["BASE64"], 60); err != nil {
		comun.LogError("formato %s: %v", consecutivo, err)
		rep.PDF.SetFont(rep.Cfg.FontName, "I", rep.Cfg.FontSize)
		rep.PDF.CellFormat(0, 6, "La firma registrada no se pudo reproducir.", "", 1, "L", false, 0, "")
		return
	}
	rep.PDF.SetDrawColor(0, 0, 0)
	y := rep.PDF.GetY()
	rep.PDF.Line(rep.Cfg.MarginLeft, y, rep.Cfg.MarginLeft+60, y)
	rep.PDF.SetFont(rep.Cfg.FontName, "", rep.Cfg.FontSize)
	rep.PDF.CellFormat(60, 6, nombrePaciente, "", 1, "C", false, 0, "")
}

// formatearRespuesta espeja la codificación de respuestas de sfa/formato_pdf.
func formatearRespuesta(tipo, respuesta string) string {
	switch tipo {
	case "B":
		switch respuesta {
		case "1":
			return "Sí"
		case "0":
			return "No"
		}
	case "D":
		return formatearFecha(respuesta)
	case "G":
		return strings.ReplaceAll(respuesta, ",", ", ")
	}
	return respuesta
}

func formatearFecha(fecha string) string {
	if t, err := time.Parse("2006-01-02", fecha); err == nil {
		return t.Format("02/01/2006")
	}
	return fecha
}

func consultarAlcance(dbName string) {
	config, err := comun.CargarConfig()
	if err != nil {
		fmt.Fprintln(os.Stderr, "Error de configuración:", err)
		os.Exit(1)
	}
	db, idUsuario, err := conectarFormas365(config, dbName)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	defer db.Close()

	_, rows := comun.EjecutarQuery(db, queries["alcanceFormas"], idUsuario, codigoCartaReapertura)
	resultado := resultadoAlcance{DB: dbName}
	resultado.FormatosEnviados, _ = strconv.Atoi(rows[0]["formatos_enviados"])
	resultado.FormatosFirmados, _ = strconv.Atoi(rows[0]["formatos_firmados"])
	resultado.Pacientes, _ = strconv.Atoi(rows[0]["pacientes"])
	data, _ := json.MarshalIndent(resultado, "", "\t")
	fmt.Println(string(data))
}

func main() {
	accion, db, password := leerParametros()

	switch accion {
	case "estatus":
		comun.ImprimirEstatus()
	case "exportar":
		comun.IniciarLog(filepath.Join("exportaciones", "exportacion.log"))
		defer comun.CerrarLog()
		exportarFormas(db, password)
	case "alcance":
		consultarAlcance(db)
	case "eliminar":
		comun.EliminarExportacion(db)
	}
}
