package comun

import (
	"encoding/json"
	"fmt"
	"log"
	"math"
	"os"
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

type Estatus struct {
	// Información general de la ejecución
	DB             string   `json:"db"`
	Modulos        []string `json:"modulos"`
	Medicos        []int    `json:"medicos"`
	PacientesTotal int      `json:"pacientes_total"`

	// Duración de procesos
	FechaInicio                string  `json:"fecha_inicio"`
	FechaFin                   string  `json:"fecha_fin"`
	DuracionSegundos           float64 `json:"duracion_segundos"`
	DuracionSegundosPdfs       float64 `json:"duracion_segundos_pdfs"`
	DuracionSegundosCompresion float64 `json:"duracion_segundos_compresion"`

	// Recursos: pico de RAM del proceso y pesos finales (se llenan al completar).
	PicoRAMMB      float64 `json:"pico_ram_mb"`
	PesoPdfsMB     float64 `json:"peso_pdfs_mb"`
	PesoArchivosMB float64 `json:"peso_archivos_mb"`
	PesoZipMB      float64 `json:"peso_zip_mb"`

	// Progreso
	Progreso float64 `json:"progreso"`
	Estatus  string  `json:"estatus"`
	Mensaje  string  `json:"mensaje"`
}

// RutaEstatus es única para todos los exportadores: medis-back corre una sola
// exportación a la vez y el frontend sigue su avance en este archivo.
const RutaEstatus = "exportaciones/estatus.json"

// FormatoFecha es el formato de fecha_inicio/fecha_fin en estatus.json.
const FormatoFecha = "2006-01-02 03:04:05 PM"

var (
	estatus Estatus
	// estatusMu protege estatus y la escritura de estatus.json: el hilo principal y el
	// watchdog (VigilarMemoria → LogFatal) los tocan a la vez.
	estatusMu sync.Mutex
	// picoRAMBytes es el máximo de runtime.MemStats.Sys observado.
	picoRAMBytes atomic.Uint64
	// exportacionActiva es true solo durante la acción exportar, la única que lleva
	// estatus.json. Fuera de ella (alcance) LogFatal no debe escribir ese archivo:
	// lo estaría leyendo una exportación en curso.
	exportacionActiva atomic.Bool
)

// ZonaMX es la zona horaria de todas las fechas exportadas (UTC si falta tzdata).
func ZonaMX() *time.Location {
	loc, err := time.LoadLocation("America/Mexico_City")
	if err != nil {
		return time.UTC
	}
	return loc
}

// IniciarEstatus reemplaza el estatus en memoria y lo escribe en estatus.json.
func IniciarEstatus(inicial Estatus) {
	exportacionActiva.Store(true)
	estatusMu.Lock()
	defer estatusMu.Unlock()
	estatus = inicial
	guardarEstatusLocked()
}

// guardarEstatusLocked serializa y escribe estatus.json. Asume estatusMu tomado.
func guardarEstatusLocked() {
	estatus.PicoRAMMB = BytesAMB(int64(picoRAMBytes.Load()))
	data, err := json.MarshalIndent(estatus, "", "\t")
	if err != nil {
		log.Fatal("Error al serializar estatus:", err)
	}
	if err := os.WriteFile(RutaEstatus, data, 0644); err != nil {
		log.Fatal("Error al guardar estatus:", err)
	}
}

// ActualizarEstatus aplica fn sobre el estatus y lo guarda, bajo estatusMu para no
// entrelazarse con el watchdog. fn solo debe mutar el estatus.
func ActualizarEstatus(fn func(e *Estatus)) {
	estatusMu.Lock()
	defer estatusMu.Unlock()
	fn(&estatus)
	guardarEstatusLocked()
}

// ActualizarMensaje fija el mensaje de avance que muestra el frontend.
func ActualizarMensaje(mensaje string) {
	ActualizarEstatus(func(e *Estatus) { e.Mensaje = mensaje })
}

// LogFatal registra el fallo y termina el proceso. Durante una exportación escribe
// ESTATUS=ERROR en estatus.json, estado del que depende el frontend para dejar de
// esperar. En una acción de solo lectura (alcance) no hay exportación propia: tocar ese
// archivo pisaría el de una exportación en curso, así que el error va a stderr, de donde
// lo lee el controlador que invocó la acción.
func LogFatal(err error) {
	LogError("%s", err.Error())
	if exportacionActiva.Load() {
		ActualizarEstatus(func(e *Estatus) {
			e.Estatus = "ERROR"
			e.Mensaje = err.Error()
		})
	} else {
		fmt.Fprintln(os.Stderr, err.Error())
	}
	os.Exit(1)
}

func ConsultarEstatus() Estatus {
	data, err := os.ReadFile(RutaEstatus)
	if err != nil {
		return Estatus{Estatus: "SIN_DATOS", Mensaje: "No hay exportaciones previas"}
	}
	var s Estatus
	if err := json.Unmarshal(data, &s); err != nil {
		return Estatus{Estatus: "ERROR", Mensaje: "Error leyendo estatus: " + err.Error()}
	}
	return s
}

// ImprimirEstatus escribe en stdout el estatus.json vigente (acción "estatus").
func ImprimirEstatus() {
	data, _ := json.MarshalIndent(ConsultarEstatus(), "", "\t")
	fmt.Println(string(data))
}

// Redondear2 redondea un valor a 2 decimales.
func Redondear2(v float64) float64 {
	return math.Round(v*100) / 100
}

// BytesAMB convierte bytes a megabytes redondeados a 2 decimales.
func BytesAMB(b int64) float64 {
	return Redondear2(float64(b) / 1024 / 1024)
}

// MuestrearRAM lee runtime.MemStats.Sys (cota superior segura con la que VigilarMemoria
// corta), actualiza el pico y lo devuelve. Asume un único escritor.
func MuestrearRAM() uint64 {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	if m.Sys > picoRAMBytes.Load() {
		picoRAMBytes.Store(m.Sys)
	}
	return m.Sys
}

// VigilarMemoria muestrea la RAM cada 500 ms para registrar el pico y, si limiteMB > 0,
// cancela con ESTATUS=ERROR al superarlo (evita agotar la RAM del servidor). Corre en su
// goroutine; un límite <= 0 solo desactiva el corte, no el muestreo.
func VigilarMemoria(limiteMB int) {
	limiteBytes := uint64(limiteMB) * 1024 * 1024
	ticker := time.NewTicker(500 * time.Millisecond)
	defer ticker.Stop()
	for range ticker.C {
		sys := MuestrearRAM()
		if limiteMB > 0 && sys > limiteBytes {
			LogFatal(fmt.Errorf("exportación cancelada: memoria del proceso (%d MB) superó el límite de %d MB", sys/1024/1024, limiteMB))
		}
	}
}
