# chat_n8n.py
import httpx
# import os
# import logging
from datetime import datetime
from typing import Dict, Any
# from config.async_db_connection import insertar_conversacion
# from dotenv import load_dotenv
# from cnxpdo import get_connection

# # Directorio del script actual
# script_dir = os.path.dirname(os.path.abspath(__file__))

# # Subimos un nivel hasta la carpeta 'crm'
# crm_dir = os.path.dirname(script_dir)

# # Ruta completa al archivo .env
# env_path = os.path.join(crm_dir, "configuraciones", ".env")

# # Carga las variables del archivo .env
# load_dotenv(env_path)


# # Configurar logging
# logger = logging.getLogger(__name__)




#CAtia 
async def enviar_chat_n8n_basico(datos: Dict[str, Any]) -> Dict[str, Any]:
    """
    Función básica para enviar chat a n8n
    """
    try:
        # Validar campos básicos
        nombre = datos.get("nombre", "").strip()
        pregunta = datos.get("pregunta", "").strip()

        if not nombre or not pregunta:
            # logger.warning("Campos requeridos faltantes en la petición")
            return {
                "success": False,
                "message": "Faltan campos requeridos: nombre y pregunta",
                "error_code": "MISSING_FIELDS"
            }

        # Preparar payload básico para n8n
        payload = {
            "nombre": nombre,
            "pregunta": pregunta,
            "timestamp": datos.get("timestamp") or datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "idCliente": datos.get("idCliente") or f"user_{int(datetime.now().timestamp())}",
            "threadId": datos.get("threadId") or f"thread_{int(datetime.now().timestamp())}",
            "asistenteIdOpenIa": datos.get("asistenteIdOpenIa", "default"),
            "instrucciones": datos.get("instrucciones", "Eres un asistente especializado en temas catastrales y tributarios."),
            "id_asistente": datos.get("id_asistente", "1"),
            "empresa_modelo": datos.get("empresa_modelo", "catastro"),
            # Campos adicionales para compatibilidad
            "audio_nom": datos.get("audio_nom", ""),
            "volumeUp": datos.get("volumeUp", "false"),
            "humanOn": datos.get("humanOn", "false"),
            "espqr": datos.get("espqr", ""),
            "ruta_script": datos.get("ruta_script", ""),
            "archivoBase64": datos.get("archivoBase64", "no")
        }

        # Obtener URL del webhook de n8n desde variable de entorno
        webhook_url = "https://dev.n8n.catastroantioquia-mas.com/webhook/catia-pru-web"
        
        if not webhook_url:
            # logger.error("Variable de entorno 'CHAT_IA_CATIA' no encontrada")
            return {
                "success": False,
                "message": "Variable de entorno 'CHAT_IA_CATIA' no encontrada o vacía",
                "error_code": "MISSING_WEBHOOK_URL"
            }

        # logger.info(f"Enviando petición a n8n para usuario: {nombre}")

        # Realizar petición HTTP a n8n usando httpx
        async with httpx.AsyncClient(timeout=300) as client:
            response = await client.post(
                webhook_url,
                json=payload,
                headers={
                    "Content-Type": "application/json",
                    "Accept": "application/json",
                    "User-Agent": "CatiaWeb-Backend/1.0"
                }
            )

        # Verificar status code
        if response.status_code != 200:
            # logger.error(f"Error HTTP {response.status_code}: {response.text}")
            return {
                "success": False,
                "message": f"Error HTTP: {response.status_code}",
                "error_code": "HTTP_ERROR",
                "details": response.text[:500]  # Limitar detalles del error
            }

        # Parsear respuesta JSON
        try:
            response_data = response.json()
            #logger.info(f"Respuesta exitosa de n8n para usuario: {nombre}")
        
            # Log para debug - puedes quitar esto en producción
            #logger.debug(f"Estructura de respuesta de n8n: {response_data}")
            
        except Exception as e:
            #logger.error(f"Error parseando respuesta JSON: {str(e)}")
            return {
                "success": False,
                "message": f"Respuesta inválida de n8n: {str(e)}",
                "error_code": "INVALID_JSON"
            }

        # Determinar el mensaje de respuesta
        if isinstance(response_data, dict):
            # Si la respuesta es un diccionario, extraer el mensaje
            mensaje = (
                response_data.get("output") or 
                response_data.get("message") or 
                response_data.get("respuesta") or
                "Respuesta procesada correctamente"
            )
        else:
            # Si la respuesta no es un diccionario, usar como está
            mensaje = str(response_data)
            
        # id_insertado = await insertar_conversacion(payload["id_asistente"], pregunta, mensaje, payload["idCliente"])
        # print("ID de conversación insertado:", id_insertado)
        return {
            "success": True,
            "message": mensaje,
            "data": response_data if isinstance(response_data, dict) else {"output": response_data}
        }

    except httpx.TimeoutException:
        #logger.error("Timeout en la petición a n8n")
        return {
            "success": False,
            "message": "Timeout: El servidor n8n no respondió en el tiempo esperado",
            "error_code": "TIMEOUT"
        }
    except httpx.ConnectError:
        #logger.error("Error de conexión con n8n")
        return {
            "success": False,
            "message": "Error de conexión: No se pudo conectar con el servidor n8n",
            "error_code": "CONNECTION_ERROR"
        }
    except httpx.RequestError as e:
        #logger.error(f"Error de petición HTTP: {str(e)}")
        return {
            "success": False,
            "message": f"Error de conexión con n8n: {str(e)}",
            "error_code": "REQUEST_ERROR"
        }

    except Exception as e:
        #logger.exception("Error inesperado en enviar_chat_n8n_basico")
        return {
            "success": False,
            "message": f"Error interno al procesar el mensaje de chat: {str(e)}",
            "error_code": "INTERNAL_ERROR"
        }