from asyncio import subprocess
import json
from datetime import datetime
import hashlib
import sys
from fastapi.responses import JSONResponse
import httpx
import os
import paramiko
import re

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

from cnxpdo import get_connection  
from dotenv import load_dotenv


# GET  

def listAssistants():
    # Establecer conexión con la base de datos
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT id, idempresa, empresa, id_asistente, nombre, descripcion, instrucciones,
                   modelo_predeterminado, modelo_actual, cambiar_modelo, openai, anthropic, google,
                   llama, cic, esuchar, hablar, archivos, codigo, tavily, wikipedia, pdf, bi, video, 
                   imgurl, status 
            FROM asistentes
        """
        cursor.execute(query)
        assistants = cursor.fetchall()

        if assistants:
            return {"success": 1, "data": assistants}
        else:
            return {"success": 0, "message": "No se encontraron asistentes"}

    except Exception as e:
        return {"success": 0, "message": f"Error en la consulta: {str(e)}"}

    finally:
        cursor.close()
        conexionBD.close()


def listModelos():
    # Establecer conexión con la base de datos
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT id, modelo, empresa, descripcion 
            FROM modelos_ia
        """
        cursor.execute(query)
        modelos = cursor.fetchall()

        if modelos:
            return {"success": 1, "data": modelos}
        else:
            return {"success": 0, "message": "No se encontraron modelos"}

    except Exception as e:
        return {"success": 0, "message": f"Error en la consulta: {str(e)}"}

    finally:
        cursor.close()
        conexionBD.close()


def listVoces():
    # Establecer conexión con la base de datos
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT id, nombre_voz, ejemplo_voz 
            FROM voces
        """
        cursor.execute(query)
        voces = cursor.fetchall()

        if voces:
            return {"success": 1, "data": voces}
        else:
            return {"success": 0, "message": "No se encontraron voces"}

    except Exception as e:
        return {"success": 0, "message": f"Error en la consulta: {str(e)}"}

    finally:
        cursor.close()
        conexionBD.close()
        
        
        


def asistentes(data):
    id_empresa = data.get('idEmpresa')
    
    if not id_empresa:
        return {"success": 0, "message": "Please retry"}
    
    # Establecer conexión con la base de datos
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT 
                a.id, 
                a.idempresa, 
                a.empresa, 
                a.id_asistente, 
                a.nombre, 
                a.descripcion, 
                a.instrucciones, 
                a.modelo_predeterminado, 
                a.modelo_actual, 
                a.cambiar_modelo, 
                a.openai, 
                a.anthropic, 
                a.google, 
                a.llama, 
                a.cic, 
                a.esuchar, 
                a.hablar, 
                a.archivos, 
                a.codigo, 
                a.pinecone, 
                a.tavily, 
                a.wikipedia, 
                a.pdf, 
                a.bi, 
                a.video, 
                a.imgurl, 
                a.id_voz,
                a.status,
                ia.instruccion AS instrucciones_assistan,
                ia.instruccion_saludo_despedida AS instrucciones_saludo_despedida,
                ia.instruccion_personalidad AS instrucciones_personalidad,
                ia.restricciones,
                av.id_modelo_voz,
                av.similarity_boost,
                av.stability,
                av.style,
                av.use_speaker_boost,
                av.optimize_streaming_latency,
                v.nombre_voz,
                v.id_eleven,
                v.ejemplo_voz,
                m.empresa as empresa_modelo
            FROM asistentes a
            LEFT JOIN asistentes_instrucciones ia ON a.id = ia.id_asistente
            LEFT JOIN asistentes_voces av ON a.id_voz = av.id
            LEFT JOIN voces v ON av.id_modelo_voz = v.id
            LEFT JOIN modelos_ia m ON a.id = m.id
            WHERE a.idempresa = %s
        """
        
        cursor.execute(query, (id_empresa,))
        asistentes = cursor.fetchall()

        if asistentes:
            return {"success": 1, "data": asistentes}
        else:
            return {"success": 0, "message": "Asistentes not found"}
    
    except Exception as e:
        return {"success": 0, "message": f"Error en la consulta: {str(e)}"}
    
    finally:
        cursor.close()
        conexionBD.close()

def obtener_instrucciones_asistentes(data):

    id_empresa = data.get('idAsistente')
    
    if not id_empresa:
        return {"success": 0, "message": "idAsistente es requerido"}
    
    # Establecer conexión con la base de datos
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT 
                id_asistente,
                instruccion_saludo_despedida,
                instruccion_personalidad,
                instruccion,
                restricciones
            FROM asistentes_instrucciones 
            WHERE id_asistente = %s
        """
        
        cursor.execute(query, (id_empresa,))
        instrucciones = cursor.fetchall()

        if instrucciones:
            return {"success": 1, "data": instrucciones}
        else:
            return {"success": 0, "message": "No se encontraron instrucciones"}
    
    except Exception as e:
        return {"success": 0, "message": f"Error en la consulta: {str(e)}"}
    
    finally:
        cursor.close()
        conexionBD.close()
        
def obtenerVectoriales():
    # Establecer conexión con la base de datos
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT 
                id,
                id_asistente,
                nombre_archivo,
                nombre_indexe,
                proposito_archivo,
                extencion
            FROM 
                asistentes_archivos
        """
        cursor.execute(query)
        datos_archivos = cursor.fetchall()

        # Reemplazar valores nulos por cadenas vacías
        for dato in datos_archivos:
            for key, value in dato.items():
                if value is None:
                    dato[key] = ""

        # Devolver los resultados en formato JSON
        return {
            "success": 1,
            "message": "Datos obtenidos correctamente",
            "data": datos_archivos
        }

    except Exception as e:
        # En caso de error, devolver un mensaje en formato JSON
        return {
            "success": 0,
            "message": f"Error al obtener datos de archivos: {str(e)}"
        }

    finally:
        cursor.close()
        conexionBD.close()
        
def chats(assistant_id):
    # Establecer conexión con la base de datos
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT
                chats.id,
                chats.id_asistente,
                chats.imageUrl,
                chats.name,
                chats.thread_id,
                chats.log_conversacion,
                chats.lastMessage,
                chats.unreadCount,
                chats.timestamp,
                a.instrucciones,
                a.id_asistente AS asistente_id,
                modelos_ia.empresa AS empresa_modelo,
                modelos_ia.endpoint AS endpoint_modelo
            FROM chats
            LEFT JOIN asistentes AS a ON chats.id_asistente = a.id
            LEFT JOIN modelos_ia ON modelos_ia.id = a.modelo_actual
            WHERE chats.id_asistente = %s
        """

        cursor.execute(query, (assistant_id,))
        chats_data = cursor.fetchall()

        if chats_data:
            return {"success": 1, "data": chats_data}
        else:
            return {"success": 0, "message": "No se encontraron chats"}

    except Exception as e:
        return {"success": 0, "message": f"Error al obtener los chats: {str(e)}"}

    finally:
        cursor.close()
        conexionBD.close()
        
        
def createIntructions(data):
    id_asistente = data.get('id')
    instruccion_saludo_despedida = data.get('instruccion_saludo_despedida')
    instruccion_personalidad = data.get('instruccion_personalidad')
    instruccion = data.get('instrucciones')

    if id_asistente and instruccion_saludo_despedida and instruccion_personalidad and instruccion:
        # Establecer conexión con la base de datos
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": 0, "message": "Error de conexión"}

        try:
            cursor = conexionBD.cursor()
            query = """
                INSERT INTO asistentes_instrucciones 
                (id_asistente, instruccion_saludo_despedida, instruccion_personalidad, instruccion) 
                VALUES (%s, %s, %s, %s)
            """

            cursor.execute(query, (
                id_asistente, 
                instruccion_saludo_despedida, 
                instruccion_personalidad, 
                instruccion
            ))

            # Confirmar los cambios
            conexionBD.commit()
            cursor.close()

            return {
                "success": 1,
                "message": "Instrucciones creadas correctamente",
                "data": data
            }

        except Exception as e:
            # Deshacer los cambios en caso de error
            conexionBD.rollback()
            if cursor:
                cursor.close()
            return {
                "success": 0,
                "message": f"Error al crear las instrucciones: {str(e)}",
                "data": data
            }
    else:
        return {"success": 0, "message": "Por favor, proporciona todos los datos necesarios"}
    
    
def createVoice(data):
    id_asistente = data.get('id')
    id_modelo_voz = data.get('id_modelo_voz')
    similarity_boost = data.get('similarity_boost')
    stability = data.get('stability')
    style = data.get('style')
    use_speaker_boost = data.get('use_speaker_boost')
    optimize_streaming_latency = data.get('optimize_streaming_latency')

    if id_asistente and id_modelo_voz and similarity_boost and stability and style and use_speaker_boost and optimize_streaming_latency:
        # Establecer conexión con la base de datos
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": 0, "message": "Error de conexión"}

        try:
            cursor = conexionBD.cursor()

            # Inserción en asistentes_voces
            query = """
                INSERT INTO asistentes_voces 
                (id_asistente, id_modelo_voz, similarity_boost, stability, style, use_speaker_boost, optimize_streaming_latency) 
                VALUES (%s, %s, %s, %s, %s, %s, %s)
            """
            cursor.execute(query, (
                id_asistente, 
                id_modelo_voz, 
                similarity_boost, 
                stability, 
                style, 
                use_speaker_boost, 
                optimize_streaming_latency
            ))

            # Obtener el ID insertado en asistentes_voces
            id_voz = cursor.lastrowid

            # Actualizar la tabla asistentes con el id_voz
            update_query = """
                UPDATE asistentes SET id_voz = %s WHERE id = %s
            """
            cursor.execute(update_query, (id_voz, id_asistente))

            # Confirmar los cambios
            conexionBD.commit()
            cursor.close()

            return {
                "success": 1, 
                "message": "Voz creada y asistente actualizado correctamente", 
                "data": data
            }

        except Exception as e:
            # Deshacer los cambios en caso de error
            conexionBD.rollback()
            if cursor:
                cursor.close()
            return {
                "success": 0, 
                "message": f"Error: {str(e)}", 
                "data": data
            }
    else:
        return {"success": 0, "message": "Por favor, proporciona todos los datos necesarios"}
    
    


def generateAsistants(data):
    try:
        nombre = data.get('nombre')
        modelo_actual = data.get('modelo_actual')
        codigo = data.get('codigo')
        archivos = data.get('archivos')

        ruta_script_bash = '/var/www/cobra/ia_general/ejecutable_ia_general_params.sh'

        # Verificar si el archivo de script existe
        if not os.path.exists(ruta_script_bash):
            raise Exception(f"El script bash no se encuentra en la ruta especificada: {ruta_script_bash}")

        # Construir el comando para ejecutar el script
        comando = f"{ruta_script_bash} {nombre} {modelo_actual} {codigo} {archivos}"

        # Ejecutar el comando y capturar la salida
        output = subprocess.check_output(comando, shell=True, stderr=subprocess.STDOUT, text=True)

        # Intentar extraer el JSON de la salida
        match = re.search(r'\{.*\}', output, re.DOTALL)
        if match:
            json_output = match.group(0)
            response = json.loads(json_output)
        else:
            raise Exception("No se pudo extraer el JSON de la salida del script.")

        # Verificar que la respuesta contiene el id_asistente
        if response and 'id_asistente' in response:
            id_asistente = response['id_asistente']
            return json.dumps({
                'success': True,
                'id_asistente': id_asistente
            })
        else:
            raise Exception(f"No se pudo obtener el ID del asistente. JSON: {json_output}")

    except Exception as e:
        return json.dumps({
            'success': False,
            'message': f"Error: {str(e)}",
            'data': None
        })



def updateParams(id, data):
    # Lógica de actualización de parámetros
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}
    
    try:
        conexionBD.autocommit = False
        cursor = conexionBD.cursor()
        
        query1 = """
            UPDATE asistentes SET 
                modelo_predeterminado = %s, 
                modelo_actual = %s, 
                archivos = %s, 
                codigo = %s
            WHERE id = %s
        """
        cursor.execute(query1, (
            data['modelo_predeterminado'], 
            data['modelo_actual'], 
            data['archivos'], 
            data['codigo'], 
            id
        ))
        
        query2 = """
            UPDATE asistentes_instrucciones SET 
                instruccion_saludo_despedida = %s, 
                instruccion_personalidad = %s, 
                instruccion = %s,
                restricciones = %s
            WHERE id_asistente = %s
        """
        cursor.execute(query2, (
            data['instruccion_saludo_despedida'], 
            data['instruccion_personalidad'], 
            data['instrucciones'], 
            data['restricciones'], 
            id
        ))
        
        conexionBD.commit()
        cursor.close()
        return {"success": 1, "message": "Parámetros actualizados correctamente", "data": data}
    
    except Exception as e:
        conexionBD.rollback()
        if cursor:
            cursor.close()
        return {"success": 0, "message": f"Error: {str(e)}", "data": data}

def updateFeature(id, data):
    # Lógica de actualización de características
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}
    
    try:
        conexionBD.autocommit = False
        cursor = conexionBD.cursor()
        
        query = """
            UPDATE asistentes SET 
                modelo_actual = %s,
                cambiar_modelo = %s,
                openai = %s,
                anthropic = %s,
                google = %s,
                llama = %s,
                cic = %s,
                esuchar = %s,
                hablar = %s
            WHERE id = %s
        """
        cursor.execute(query, (
            data['modelo_actual'], 
            data['cambiar_modelo'], 
            data['openai'], 
            data['anthropic'], 
            data['google'], 
            data['llama'], 
            data['cic'], 
            data['escuchar'], 
            data['hablar'], 
            id
        ))
        
        conexionBD.commit()
        cursor.close()
        return {"success": 1, "message": "Características actualizadas correctamente", "data": data}
    
    except Exception as e:
        conexionBD.rollback()
        if cursor:
            cursor.close()
        return {"success": 0, "message": f"Error: {str(e)}", "data": data}

def updateVoice(id, data):
    # Lógica de actualización de voz
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}
    
    try:
        conexionBD.autocommit = False
        cursor = conexionBD.cursor()
        
        query = """
            UPDATE asistentes_voces SET 
                id_modelo_voz = %s, 
                similarity_boost = %s, 
                stability = %s, 
                style = %s, 
                use_speaker_boost = %s, 
                optimize_streaming_latency = %s
            WHERE id_asistente = %s
        """
        cursor.execute(query, (
            data['id_modelo_voz'], 
            data['similarity_boost'], 
            data['stability'], 
            data['style'], 
            data['use_speaker_boost'], 
            data['optimize_streaming_latency'], 
            id
        ))
        
        conexionBD.commit()
        cursor.close()
        return {"success": 1, "message": "Voz actualizada correctamente", "data": data}
    
    except Exception as e:
        conexionBD.rollback()
        if cursor:
            cursor.close()
        return {"success": 0, "message": f"Error: {str(e)}", "data": data}

    
    
def updateAssistant(id, data):
    # Recuperar los datos de la solicitud
    idempresa = data.get('idempresa')
    nombre = data.get('nombre')
    descripcion = data.get('descripcion')
    imgurl = data.get('imgurl')
    id = data.get('id')
    empresa = data.get('empresa')

    # Verificar si se ha cargado un archivo de imagen
    if 'file' in data:
        try:
            # Si se ha subido un archivo, usar el ID del asistente como nombre de archivo
            file = data['file']
            temp_path = file['tmp_name']
            file_extension = os.path.splitext(file['name'])[1]  # Obtener la extensión del archivo
            nombre_archivo = f"{id}.{file_extension}"  # Usar el ID como nombre del archivo

            # Configuración de conexión SFTP
            sftp_server = os.getenv('SFTP_SERVER', '')
            sftp_username = os.getenv('SFTP_USERNAME', '')
            sftp_password = os.getenv('SFTP_PASSWORD', '')
            # Variable de entorno cambiar a variable de entorno
            destination_file = f"/var/www/dev.api.cic-ware.com/api-1/asistente/imagen_asistente/{nombre_archivo}"

            # Conectar al servidor SFTP y subir el archivo
            transport = paramiko.Transport((sftp_server, 22))
            transport.connect(username=sftp_username, password=sftp_password)
            sftp = paramiko.SFTPClient.from_transport(transport)

            sftp.put(temp_path, destination_file)
            sftp.close()
            transport.close()

            # Actualizar la URL de la imagen
            imgurl = f'assets/img/asistente/imagen_asistente/{nombre_archivo}'

        except Exception as e:
            return json.dumps({'success': 0, 'message': f'Error durante la subida del archivo: {str(e)}'})

    # Verificar si los datos son completos
    if idempresa and nombre and descripcion and imgurl:
        try:
            # Establecer conexión a la base de datos
            conexionBD = get_connection()  # Función para obtener conexión a la base de datos
            if conexionBD is None:
                return json.dumps({"success": 0, "message": "Error de conexión a la base de datos"})

            cursor = conexionBD.cursor()

            # Consulta SQL para actualizar el asistente
            query = """
                UPDATE asistentes 
                SET idempresa = %s, nombre = %s, descripcion = %s, imgurl = %s
                WHERE id = %s
            """
            cursor.execute(query, (idempresa, nombre, descripcion, imgurl, id))

            # Confirmar los cambios
            conexionBD.commit()
            cursor.close()

            return JSONResponse(content={
                "success": 1,
                "message": "Asistente actualizado correctamente",
                "data": data
            })

        except Exception as e:
            return json.dumps({
                "success": 0,
                "message": f"Error de base de datos: {str(e)}"
            })

    else:
        return json.dumps({
            "success": 0,
            "message": "Por favor, proporciona todos los datos necesarios"
        })


def updateAssistantStatus(id, data):
    nuevo_status = data.get('status')

    if nuevo_status is None:
        return {"success": 0, "message": "El campo 'status' es obligatorio"}

    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": 0, "message": "Error de conexión a la base de datos"}

        cursor = conexionBD.cursor()

        query = "UPDATE asistentes SET status = %s WHERE id = %s"
        cursor.execute(query, (nuevo_status, id))

        conexionBD.commit()
        cursor.close()

        return {
            "success": 1,
            "message": "Estado del asistente actualizado correctamente"
        }

    except Exception as e:
        return {"success": 0, "message": f"Error en la base de datos: {str(e)}"}
    

# 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)

# Obtenemos las variables desde el entorno y quitamos espacios invisibles
# Obtener las variables y sanitizarlas
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', '').strip()
OPENAI_URL = os.getenv('OPENAI_URL', '').strip().rstrip('/')

# Clave API de OpenAI Variable de entorno cambiar a variable de entorno 
#OPENAI_API_KEY = "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"
#OPENAI_URL = "https://api.openai.com/v1/audio/transcriptions"

def transcribir_audio(audio: bytes, filename: str, keep_case: bool = False) -> dict:
    """
    Envía un archivo de audio a OpenAI Whisper para transcripción (Versión Síncrona).
    
    :param audio: Contenido del archivo de audio en bytes.
    :param filename: Nombre del archivo de audio.
    :param keep_case: Si es False, normaliza el texto para evitar mayúsculas innecesarias.
    :return: Diccionario con resultado de la transcripción.
    """
    try:
        # Detectar el tipo MIME basado en la extensión del archivo
        filename = filename.lower()
        if filename.endswith(".mp3"):
            mime_type = "audio/mpeg"
        elif filename.endswith(".wav"):
            mime_type = "audio/wav"
        elif filename.endswith(".webm"):
            mime_type = "audio/webm"
        elif filename.endswith(".mp4") or filename.endswith(".m4a"):
            mime_type = "audio/mp4"
        elif filename.endswith(".aac"):
            mime_type = "audio/aac"
        elif filename.endswith(".ogg"):
            mime_type = "audio/ogg"
        else:
            # Si no podemos determinar el tipo, intentamos con wav como fallback
            mime_type = "audio/wav"
            print(f"ADVERTENCIA: Formato de archivo no reconocido: {filename}. Usando audio/wav como fallback.")
        
        print(f"Intentando transcribir audio: {filename} con MIME type: {mime_type}")
        
        with httpx.Client(timeout=30.0) as client:  # Aumentamos el timeout para archivos grandes
            files = {
                "file": (filename, audio, mime_type),
                "model": (None, "whisper-1"),
            }
            headers = {"Authorization": f"Bearer {OPENAI_API_KEY}"}
            
            response = client.post(OPENAI_URL, headers=headers, files=files)
        
        # Manejar errores HTTP
        if response.status_code != 200:
            error_info = response.json() if response.headers.get('content-type') == 'application/json' else response.text
            print(f"Error API OpenAI: Status {response.status_code}, Info: {error_info}")
            return {
                'success': 0,
                'message': f"Error en API OpenAI (código {response.status_code})",
                'data': "",
                'error_details': str(error_info)
            }
        
        data = response.json()
        text = data.get("text", "")
        
        # Normalizar la capitalización si no se solicita mantener el caso original
        if not keep_case and text:
            # Verificar si el texto está principalmente en mayúsculas
            uppercase_ratio = sum(1 for c in text if c.isupper() and c.isalpha()) / max(1, sum(1 for c in text if c.isalpha()))
            if uppercase_ratio > 0.7:  # Si más del 70% son mayúsculas, normalizar
                # Convertir a minúsculas pero preservar la primera letra de cada oración
                sentences = re.split(r'([.!?]\s+)', text.lower())
                normalized_text = ""
                capitalize_next = True
                
                for part in sentences:
                    if capitalize_next and part and part[0].isalpha():
                        part = part[0].upper() + part[1:]
                        capitalize_next = False
                    if part in ['. ', '! ', '? ']:
                        capitalize_next = True
                    normalized_text += part
                
                text = normalized_text.strip()
        
        return {
            'success': 1,
            'message': 'Transcripción exitosa',
            'data': text,
        }
    
    except Exception as e:
        import traceback
        error_trace = traceback.format_exc()
        print(f"Error en transcripción: {str(e)}\n{error_trace}")
        return {
            'success': 0,
            'message': f"Error en transcripción: {str(e)}",
            'data': "",
            'error_details': error_trace
        }
def insertar_funcion_openia(data):
    id_asistente = data.get("id_asistente")
    funcion = data.get("funcion")
    
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": 0, "message": "Error de conexión"}

         
        
        # Obtener los datos desde el input    
        query = """
            INSERT INTO data_catastro.funciones_openai (id_asistente, funcion)
            VALUES (%s, %s)
        """
        
        cursor = conexionBD.cursor()
        cursor.execute(query, (id_asistente, json.dumps(funcion)))
        
        # Commit para confirmar la inserción
        conexionBD.commit()

        cursor.close()
        conexionBD.close()

        return {"success": 1, "message": "Datos insertados correctamente", "data": data}
    
    except Exception as e:
        return {"success": 0, "message": f"Error al insertar datos: {str(e)}"}