# handlers/solo_vida.py

import base64
from fastapi import Form, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse
from src.utils.respuesta import generar_respuesta_vida
from src.validators.validacion import validar_cedula
from src.utils.vida import procesar_prueba_vida
from src.utils.vida_avanzada import (
    procesar_prueba_vida_avanzada,
    procesar_prueba_vida_avanzada_one_frame,
)
from connection.save_data import guardar_datos_asincronos

# from src.utils.simulación_vida_avanzada import procesar_prueba_vida_avanzada
from src.validators.validar_video import validar_video
from datetime import datetime
from src.utils.logger_config import logger
import os
import base64
import asyncio
from src.config import VERSION, VIDEO_FOLDER


async def prueba_de_vida(cedula: str = Form(...), file: UploadFile = File(...)):
    logger.info(f"Solicitud recibida para prueba de vida: cédula={cedula}")

    if not validar_cedula(cedula):
        logger.warning(f"Cédula inválida: {cedula}")
        raise HTTPException(status_code=400, detail="Cédula no válida")

    try:
        extension = "webm" if file.filename.lower().endswith(".webm") else "mp4"
        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
        folder_path = "temp_videos"
        os.makedirs(folder_path, exist_ok=True)
        video_path = os.path.join(folder_path, f"{cedula}_{timestamp}.{extension}")

        logger.info(f"Guardando archivo temporal en: {video_path}")
        file_bytes = await file.read()
        with open(video_path, "wb") as f:
            f.write(file_bytes)
        valido, mensaje_validacion = validar_video(video_path)
        logger.info("Procesando prueba de vida...")
        vida_detectada = procesar_prueba_vida(video_path)
        logger.info(f"Vida detectada: {vida_detectada}")

        if os.path.exists(video_path):
            os.remove(video_path)
            logger.info(f"Archivo temporal eliminado: {video_path}")

        return JSONResponse(
            content={
                "validacion_exitosa": vida_detectada,
                "cedula": cedula,
                "vida_detectada": vida_detectada,
                "reconocimiento_exitoso": None,
                "similaridad": None,
                "mensaje": (
                    "Prueba de vida exitosa"
                    if vida_detectada
                    else "No se detectó vida en el video"
                ),
                "version": VERSION,
            }
        )

    except Exception as e:
        logger.exception("Error durante la prueba de vida")
        raise HTTPException(status_code=500, detail=f"Error procesando video: {str(e)}")


async def prueba_de_vidaV2(cedula: str = Form(...), file: UploadFile = File(...)):
    logger.info(f"Solicitud /vida/v2 para prueba avanzada - Cédula: {cedula}")

    if not validar_cedula(cedula):
        logger.warning(f"Cédula inválida: {cedula}")
        raise HTTPException(status_code=400, detail="Cédula no válida")

    try:
        os.makedirs(VIDEO_FOLDER, exist_ok=True)
        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
        extension = "webm" if file.filename.lower().endswith(".webm") else "mp4"
        video_path = os.path.join(VIDEO_FOLDER, f"{cedula}_{timestamp}.{extension}")

        file_bytes = await file.read()
        with open(video_path, "wb") as f:
            f.write(file_bytes)
        logger.info(f"Video guardado: {video_path}")
        valido, mensaje_validacion = validar_video(video_path)
        if not valido:
            return JSONResponse(
                status_code=200,
                content={
                    "cedula": cedula,
                    "vida_detectada": False,
                    "validacion_exitosa": False,
                    "reconocimiento_exitoso": None,
                    "similaridad": None,
                    "mensaje": "No se detecta vida en el video: " + mensaje_validacion,
                    "version": VERSION,
                },
            )
        # Llamar a la función avanzada
        resultado = procesar_prueba_vida_avanzada_one_frame(video_path)
        respuesta = generar_respuesta_vida(cedula, resultado)

        # 2. Leer el video para convertir a base64
        with open(video_path, "rb") as f:
            video_bytes = f.read()
        video_base64 = base64.b64encode(video_bytes).decode("utf-8")

        # 3. Extraer metadatos de uso
        modelo = "gpt-4o-mini"
        resultado_vida = resultado.get("resultado_vida", {})

        tokens = 0
        if isinstance(resultado_vida, dict):
            usage = resultado_vida.get("usage")
            if isinstance(usage, dict):
                tokens = usage.get("total_tokens", 0)

        costo = round(tokens * 0.0000017, 6)

        # 4. Preparar data para insertar
        data_para_guardar = {
            "modelo": modelo,
            "tokens_utilizados": tokens,
            "costo_aproximado": costo,
            "cedula": cedula,
            "estado": "exitoso" if respuesta.get("validacion_exitosa") else "fallido",
            "endpoint": "/vida/v2",
            "respuesta_modelo": resultado_vida,
            "resultado_json": resultado,
            "video_base64": video_base64,
            "tipo_error": respuesta.get("tipo_error"),  # puede ser None
        }

        # 5. Lanzar guardado asincrónico sin bloquear API
        asyncio.create_task(guardar_datos_asincronos(data_para_guardar))

        return JSONResponse(content=respuesta)

    except Exception as e:
        logger.exception("Error en /vida/v2")
        raise HTTPException(status_code=500, detail=f"Error procesando video: {str(e)}")