from typing import List, Optional, Dict, Any
import logging
from datetime import datetime
import sys

sys.path.append('/var/www/html/config')

from cnxpdo import get_connection


def insertar_respuestas_encuesta(respuestas: List[Dict[str, Any]]) -> Dict[str, Any]:
    conexion = None
    cursor = None

    try:
        # Establece la conexión a la base de datos
        conexion = get_connection()
        if not conexion:
            raise Exception("No se pudo establecer conexión a la base de datos")

        cursor = conexion.cursor()
        
        # Validar que se envíen respuestas
        if not respuestas or not isinstance(respuestas, list):
            return {
                "success": False,
                "message": "No se proporcionaron respuestas válidas"
            }

        # Query de inserción
        query = """
            INSERT INTO encuestas_respuestas_log
            (id_enc_det, respuesta_usuario)
            VALUES(%s, %s)
        """

        respuestas_insertadas = 0
        errores = []

        # Recorrer cada respuesta y insertarla
        for respuesta in respuestas:
            try:
                # Validar que tenga los campos requeridos
                if 'id_enc_det' not in respuesta or 'respuesta_usuario' not in respuesta:
                    errores.append(f"Respuesta inválida: falta id_enc_det o respuesta_usuario")
                    continue

                # Ejecutar la inserción
                cursor.execute(query, (
                    respuesta['id_enc_det'],
                    respuesta['respuesta_usuario']
                ))
                
                respuestas_insertadas += 1

            except Exception as e:
                errores.append(f"Error al insertar respuesta ID {respuesta.get('id_enc_det', 'desconocido')}: {str(e)}")
                logging.error(f"Error al insertar respuesta individual: {str(e)}")

        # Confirmar las transacciones
        conexion.commit()

        # Preparar respuesta
        if respuestas_insertadas == len(respuestas):
            return {
                "success": True,
                "message": f"Se insertaron correctamente {respuestas_insertadas} respuestas",
                "respuestas_insertadas": respuestas_insertadas,
                "total_enviadas": len(respuestas)
            }
        elif respuestas_insertadas > 0:
            return {
                "success": True,
                "message": f"Se insertaron {respuestas_insertadas} de {len(respuestas)} respuestas",
                "respuestas_insertadas": respuestas_insertadas,
                "total_enviadas": len(respuestas),
                "errores": errores
            }
        else:
            return {
                "success": False,
                "message": "No se pudo insertar ninguna respuesta",
                "errores": errores
            }

    except Exception as e:
        logging.error(f"Error en insertar_respuestas_encuesta: {str(e)}")
        if conexion:
            conexion.rollback()
        return {
            "success": False,
            "message": f"Error interno al insertar respuestas: {str(e)}"
        }
    finally:
        # Asegúrate de cerrar siempre la conexión y el cursor
        if cursor:
            cursor.close()
        if conexion:
            conexion.close()


def obtener_preguntas_con_respuestas(id_enc: Optional[int] = None) -> Dict[str, Any]:
    """
    Obtiene el listado de preguntas con sus posibles respuestas
    
    Args:
        id_enc: ID de la encuesta específica (opcional)
    
    Returns:
        Dict con el resultado de la operación
    """
    conexion = None
    cursor = None

    try:
        # Establece la conexión a la base de datos
        conexion = get_connection()
        if not conexion:
            raise Exception("No se pudo establecer conexión a la base de datos")

        cursor = conexion.cursor(dictionary=True)
        
        # Query para obtener las preguntas
        query_preguntas = """
            SELECT id_enc_det, id_enc, pregunta, tipo_pregunta, obligatorio
            FROM encuestas_detalle
        """
        params_preguntas = []
        
        # Si se especifica un id_enc, filtramos por esa encuesta
        if id_enc is not None:
            query_preguntas += " WHERE id_enc = %s"
            params_preguntas.append(id_enc)
            
        query_preguntas += " ORDER BY id_enc_det"
        
        # Ejecutar consulta de preguntas
        cursor.execute(query_preguntas, params_preguntas)
        preguntas = cursor.fetchall()
        
        if not preguntas:
            return {
                "success": True,
                "message": "No se encontraron preguntas",
                "data": []
            }
        
        # Query para obtener todas las respuestas de las preguntas
        ids_preguntas = [pregunta['id_enc_det'] for pregunta in preguntas]
        placeholders = ','.join(['%s'] * len(ids_preguntas))
        
        query_respuestas = f"""
            SELECT id_enc_res_preg, id_enc_det, respuesta_pregunta
            FROM encuestas_respuestas_pregunta
            WHERE id_enc_det IN ({placeholders})
            ORDER BY id_enc_det, id_enc_res_preg
        """
        
        cursor.execute(query_respuestas, ids_preguntas)
        respuestas = cursor.fetchall()
        
        # Organizar respuestas por pregunta
        respuestas_por_pregunta = {}
        for respuesta in respuestas:
            id_enc_det = respuesta['id_enc_det']
            if id_enc_det not in respuestas_por_pregunta:
                respuestas_por_pregunta[id_enc_det] = []
            respuestas_por_pregunta[id_enc_det].append({
                'id_enc_res_preg': respuesta['id_enc_res_preg'],
                'respuesta_pregunta': respuesta['respuesta_pregunta']
            })
        
        # Combinar preguntas con sus respuestas
        preguntas_completas = []
        for pregunta in preguntas:
            id_enc_det = pregunta['id_enc_det']
            pregunta_completa = {
                'id_enc_det': pregunta['id_enc_det'],
                'id_enc': pregunta['id_enc'],
                'pregunta': pregunta['pregunta'],
                'tipo_pregunta': str(pregunta['tipo_pregunta']),  # Convertir a string
                'obligatorio': bool(pregunta['obligatorio']),
                'respuestas_opciones': respuestas_por_pregunta.get(id_enc_det, [])
            }
            preguntas_completas.append(pregunta_completa)
        
        return {
            "success": True,
            "message": f"Se encontraron {len(preguntas_completas)} preguntas",
            "data": preguntas_completas,
            "total_preguntas": len(preguntas_completas)
        }

    except Exception as e:
        logging.error(f"Error en obtener_preguntas_con_respuestas: {str(e)}")
        return {
            "success": False,
            "message": f"Error interno al obtener preguntas: {str(e)}"
        }
    finally:
        # Asegúrate de cerrar siempre la conexión y el cursor
        if cursor:
            cursor.close()
        if conexion:
            conexion.close()


def traer_lista_encuestas():
    # try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": False,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT 
                e.id_enc, 
                e.nombre_encuesta, 
                ec.categoria as categoria, 
                e.fecha_vencimiento, e.status,  
                e.descripcion
            FROM encuestas e
            LEFT JOIN encuestas_categorias ec  ON  e.categoria =  ec.id_enc_cat 
            LEFT JOIN usuarios u ON e.usuario = u.id
            LEFT JOIN empleados emp ON emp.id  = u.idEmpleado
            ORDER BY e.id_enc DESC
        """

        cursor.execute(query)
        encuestas = cursor.fetchall()


        cursor.close()
        conexionBD.close()
        return {
            "success": True,
            "message": "Encuestas obtenidas correctamente",
            "data": encuestas
        }
    # except Exception as e:
    #     return {
    #         "success": False,
    #         "message": f"Error: {str(e)}"
    #     }