package comun

import (
	"encoding/json"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/yeka/zip"
)

// NombreDBValido rechaza los -db que saldrían de exportaciones/ o romperían la URL de descarga.
func NombreDBValido(dbName string) bool {
	return !strings.ContainsAny(dbName, "/?&#")
}

// RutaZip es el ZIP de dbName: un solo archivo por cliente, el que sirve la descarga pública.
func RutaZip(dbName string) string {
	return filepath.Join("exportaciones", dbName+".zip")
}

// ExisteRuta indica si ruta apunta a un archivo o carpeta existente.
func ExisteRuta(ruta string) bool {
	_, err := os.Stat(ruta)
	return err == nil
}

// PrepararExportacion deja lista exportaciones/{db}/ y la devuelve. Aborta si ya existe
// {db}.zip (descarga vigente; límpiela antes con accion=eliminar). Una carpeta {db}/ sin ZIP
// es residuo de una corrida fallida y se borra para reintentar.
func PrepararExportacion(dbName string) string {
	baseDir := filepath.Join("exportaciones", dbName)
	if ExisteRuta(RutaZip(dbName)) {
		LogFatal(fmt.Errorf("ya existe una exportación generada para %s; elimínela antes de generar una nueva", dbName))
	}
	if err := os.RemoveAll(baseDir); err != nil {
		LogFatal(err)
	}
	if err := os.MkdirAll(baseDir, 0755); err != nil {
		LogFatal(err)
	}
	return baseDir
}

// CarpetaZip se agrega al ZIP bajo Prefijo/. Permitidos (si no es nil) limita a las
// subcarpetas de primer nivel cuyo nombre esté en el conjunto.
type CarpetaZip struct {
	Origen     string
	Prefijo    string
	Permitidos map[string]bool
}

// GenerarZIP empaqueta las carpetas en un único {db}.zip cifrado (AES-256). Si algo falla,
// borra el ZIP parcial: su presencia es el marcador de exportación completada.
func GenerarZIP(dbName, password string, carpetas ...CarpetaZip) (err error) {
	zipPath := RutaZip(dbName)
	defer func() {
		if err != nil {
			os.Remove(zipPath) // borra el ZIP parcial para no bloquear un reintento
		}
	}()

	f, err := os.Create(zipPath)
	if err != nil {
		return fmt.Errorf("no se pudo crear %s: %w", filepath.Base(zipPath), err)
	}
	defer f.Close()

	w := zip.NewWriter(f)
	for _, carpeta := range carpetas {
		if err := agregarCarpetaAlZip(w, carpeta.Origen, carpeta.Prefijo, password, carpeta.Permitidos); err != nil {
			w.Close()
			// El error de recorrer/abrir un archivo lleva su ruta (nombre de paciente,
			// título de formato); se devuelve sin ella.
			return LimpiarErrorRuta(err)
		}
	}
	return w.Close()
}

// FinalizarExportacion mide la exportación ya comprimida y deja el estatus en COMPLETADO.
// bytesArchivos es el peso de los archivos que entraron al ZIP sin pasar por baseDir.
func FinalizarExportacion(dbName, baseDir string, inicio, inicioZip time.Time, bytesArchivos int64) {
	fin := time.Now()

	// El ZIP ya está escrito: un fallo al medir solo degrada las cifras.
	_, bytesPdfs, err := DirStats(baseDir, nil)
	if err != nil {
		LogError("no se pudo medir el peso de los PDFs: %v", LimpiarErrorRuta(err))
	}
	var pesoZip float64
	if info, err := os.Stat(RutaZip(dbName)); err == nil {
		pesoZip = BytesAMB(info.Size())
	}

	ActualizarEstatus(func(e *Estatus) {
		e.Estatus = "COMPLETADO"
		e.Mensaje = "Exportación completada"
		e.FechaFin = fin.In(ZonaMX()).Format(FormatoFecha)
		e.DuracionSegundosPdfs = Redondear2(inicioZip.Sub(inicio).Seconds())
		e.DuracionSegundosCompresion = Redondear2(fin.Sub(inicioZip).Seconds())
		e.DuracionSegundos = Redondear2(fin.Sub(inicio).Seconds())
		e.PesoPdfsMB = BytesAMB(bytesPdfs)
		e.PesoArchivosMB = BytesAMB(bytesArchivos)
		e.PesoZipMB = pesoZip
		e.Progreso = 100
	})
	LogInfo("Exportación completada en %.2fs (compresión %.2fs)", Redondear2(fin.Sub(inicio).Seconds()), Redondear2(fin.Sub(inicioZip).Seconds()))
}

// agregarCarpetaAlZip añade el contenido de origen al ZIP abierto w, ubicando
// cada archivo (cifrado AES-256) bajo prefijo/ dentro del ZIP.
func agregarCarpetaAlZip(w *zip.Writer, origen, prefijo, password string, permitidos map[string]bool) error {
	return filepath.Walk(origen, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() {
			if cod := PrimerSegmento(origen, path); permitidos != nil && cod != "" && !permitidos[cod] {
				return filepath.SkipDir
			}
			return nil
		}
		if permitidos != nil {
			if cod := PrimerSegmento(origen, path); cod == "" || !permitidos[cod] {
				return nil
			}
		}
		rel, err := filepath.Rel(origen, path)
		if err != nil {
			return err
		}
		zf, err := w.Encrypt(filepath.Join(prefijo, rel), password, zip.AES256Encryption)
		if err != nil {
			return err
		}
		src, err := os.Open(path)
		if err != nil {
			return err
		}
		_, err = io.Copy(zf, src)
		src.Close()
		return err
	})
}

// DirStats cuenta archivos y bytes bajo raíz. Propaga los errores: una carpeta sin permisos
// no es vacía. Permitidos (si no es nil) limita a esas subcarpetas de primer nivel.
func DirStats(raiz string, permitidos map[string]bool) (archivos int, bytes int64, err error) {
	err = filepath.Walk(raiz, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() {
			if cod := PrimerSegmento(raiz, path); permitidos != nil && cod != "" && !permitidos[cod] {
				return filepath.SkipDir
			}
			return nil
		}
		if permitidos != nil {
			if cod := PrimerSegmento(raiz, path); cod == "" || !permitidos[cod] {
				return nil
			}
		}
		archivos++
		bytes += info.Size()
		return nil
	})
	return archivos, bytes, err
}

// PrimerSegmento devuelve el primer segmento de path relativo a raiz (el código de paciente
// en la carpeta pacientes/), o "" para la propia raiz.
func PrimerSegmento(raiz, path string) string {
	rel, err := filepath.Rel(raiz, path)
	if err != nil || rel == "." {
		return ""
	}
	if i := strings.IndexRune(rel, os.PathSeparator); i >= 0 {
		return rel[:i]
	}
	return rel
}

// EliminarExportacion borra {db}/, {db}.zip y los extras dentro de exportaciones/. NUNCA toca
// la carpeta fuente del cliente. Ante fallo escribe a stderr y sale con código !=0.
func EliminarExportacion(dbName string, extras ...string) {
	rutas := []string{filepath.Join("exportaciones", dbName), RutaZip(dbName)}
	for _, extra := range extras {
		rutas = append(rutas, filepath.Join("exportaciones", extra))
	}
	for _, ruta := range rutas {
		if err := os.RemoveAll(ruta); err != nil {
			fmt.Fprintf(os.Stderr, "Error al eliminar %s: %v\n", filepath.Base(ruta), err)
			os.Exit(1)
		}
	}
	data, _ := json.Marshal(map[string]any{"success": true, "db": dbName})
	fmt.Println(string(data))
}
