import os
import shutil
from fastapi import UploadFile, Form
from cnxpdo import get_connection  # Conexión a la BD
from dotenv import load_dotenv

""" script_dir = os.path.dirname(os.path.abspath(__file__))  # Directorio del script
crm_dir = os.path.dirname(script_dir)  # Sube un nivel hasta crm
env_path = os.path.join(crm_dir, "configuraciones", ".env")  # Ahora sí apunta bien

load_dotenv(env_path)


# 📌 Ubicación de los videos en el servidor
VIDEO_SERVER_PATH = os.getenv('VIDEO_SERVER_PATH')
#VIDEO_SERVER_PATH = "https://dev.core.ayudacatastro.co/Videos/"
#"https://dev.ayudacatastro.co/api/crm/asistente/videos/"
#https://pre.coreayudacatastro.co/Video Asistente
VIDEO_UPLOAD_FOLDER = os.getenv('VIDEO_UPLOAD_FOLDER')
#VIDEO_UPLOAD_FOLDER = "/var/www/dev.core.ayudacatastro.co/Videos"
#"/var/www/html/api/crm/asistente/videos/"
#"/var/www/pre.coreayudacatastro.co/Video Asistente
os.makedirs(VIDEO_UPLOAD_FOLDER, exist_ok=True)  # Asegurar que la carpeta exista """


def configurar_variables_video():
    # 1. Cargar .env desde la ruta correcta
    script_dir = os.path.dirname(os.path.abspath(__file__))  # Directorio actual del script
    crm_dir = os.path.dirname(script_dir)  # Sube un nivel hasta 'crm'
    env_path = os.path.join(crm_dir, "configuraciones", ".env")  # Ruta del .env
    load_dotenv(env_path)  # Carga las variables de entorno

    # 2. Obtener las variables de entorno
    video_server_path = os.getenv('VIDEO_SERVER_PATH')
    video_upload_folder = os.getenv('VIDEO_UPLOAD_FOLDER')

    return video_server_path, video_upload_folder

VIDEO_SERVER_PATH, VIDEO_UPLOAD_FOLDER = configurar_variables_video()

def create_respuesta_con_registro(asistente: str, respuesta: str, video: UploadFile = None):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor()

        # 📌 Insertar la respuesta con un video_url vacío si no hay video
        video_url = ""
        query = "INSERT INTO asistente_con_registro (id_asistente, respuesta, video_url) VALUES (%s, %s, %s)"
        cursor.execute(query, (asistente, respuesta, video_url))
        conexionBD.commit()

        respuesta_id = cursor.lastrowid  # Obtener el ID insertado

        if video:
            # 📌 Subir el video y actualizar la URL
            os.makedirs(VIDEO_UPLOAD_FOLDER, exist_ok=True)
            video_filename = f"respuestas{respuesta_id}.mp4"
            video_path = os.path.join(VIDEO_UPLOAD_FOLDER, video_filename)

            with open(video_path, "wb") as buffer:
                shutil.copyfileobj(video.file, buffer)

            video_url = f"{VIDEO_SERVER_PATH}{video_filename}"

            # 📌 Actualizar la URL del video
            update_query = "UPDATE asistente_con_registro SET video_url = %s WHERE id = %s"
            cursor.execute(update_query, (video_url, respuesta_id))
            conexionBD.commit()

        return {
            "success": 1,
            "message": "Respuesta con registro añadida correctamente",
            "id": respuesta_id,
            "id_asistente": asistente,
            "respuesta": respuesta,
            "video_url": video_url
        }

    except Exception as e:
        return {"success": 0, "message": f"Error al insertar respuesta: {str(e)}"}

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


# 📌 Consultar respuestas con registro
def read_respuestas_con_registro():
    conexionBD = get_connection()
    if not conexionBD:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor(dictionary=True)  # Retorna los datos en formato diccionario

        # ⚠️ Asegurar que los nombres de las columnas sean correctos
        query = "SELECT id, id_asistente, respuesta, video_url FROM asistente_con_registro"
        cursor.execute(query)
        respuestas = cursor.fetchall()

        return {"success": 1, "data": respuestas}

    except Exception as e:
        return {"success": 0, "message": f"Error al consultar respuestas: {str(e)}"}

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


def read_respuestas_sin_registro():
    try:
        conexionBD = get_connection()
        if not conexionBD:
            return {"success": 0, "message": "Error de conexión"}

        cursor = conexionBD.cursor()
        query = "SELECT * FROM asistente_sin_registro"
        cursor.execute(query)
        respuestas = cursor.fetchall()

        # Transformar las respuestas a un formato adecuado
        respuestas_data = [{"id": r[0], "asistente": r[1], "respuesta": r[2]} for r in respuestas]

        return {"success": 1, "data": respuestas_data}

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

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

def update_respuesta_con_registro(respuesta_id: int, asistente: int, respuesta: str, video: UploadFile = None):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor()

        # 📌 Obtener la URL actual del video
        cursor.execute("SELECT video_url FROM asistente_con_registro WHERE id = %s", (respuesta_id,))
        current_video = cursor.fetchone()
        video_url = current_video[0] if current_video else ""

        # 📌 Si se sube un nuevo video, eliminar el anterior y guardar el nuevo
        if video:
            if video_url:  # Eliminar el video anterior
                old_video_path = os.path.join(VIDEO_UPLOAD_FOLDER, os.path.basename(video_url))
                if os.path.exists(old_video_path):
                    os.remove(old_video_path)

            # 📌 Guardar el nuevo video
            video_filename = f"respuestas{respuesta_id}.mp4"
            video_path = os.path.join(VIDEO_UPLOAD_FOLDER, video_filename)

            with open(video_path, "wb") as buffer:
                shutil.copyfileobj(video.file, buffer)

            video_url = f"{VIDEO_SERVER_PATH}{video_filename}"

        # 📌 Actualizar la base de datos con los nuevos datos
        query = """
        UPDATE asistente_con_registro 
        SET id_asistente = %s, respuesta = %s, video_url = %s 
        WHERE id = %s
        """
        cursor.execute(query, (asistente, respuesta, video_url, respuesta_id))  # `respuesta_id` en el WHERE
        conexionBD.commit()

        return {
            "success": 1,
            "message": "Respuesta con registro actualizada correctamente",
            "id": respuesta_id,
            "id_asistente": asistente,
            "respuesta": respuesta,
            "video_url": video_url
        }

    except Exception as e:
        return {"success": 0, "message": f"Error al actualizar respuesta: {str(e)}"}

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


def create_respuesta_sin_registro(data):
    try:
        # Verificar conexión
        conexion_bd = get_connection()
        if conexion_bd is None:
            return {"success": 0, "message": "Error de conexión"}

        # Verificar datos esenciales
        if 'asistente' not in data or 'respuesta' not in data:
            return {"success": 0, "message": "Datos incompletos"}

        # Obtener cursor y comenzar transacción
        cursor = conexion_bd.cursor()
        cursor.execute("START TRANSACTION")

        # Preparar y ejecutar consulta SQL
        query = """
            INSERT INTO asistente_sin_registro (id_asistente, respuesta) 
            VALUES (%s, %s)
        """
        
        cursor.execute(query, (
            data['asistente'],  # El ID del asistente se pasa aquí
            data['respuesta']   # La respuesta proporcionada se pasa aquí
        ))

        # Confirmar transacción
        conexion_bd.commit()

        return {
            "success": 1,
            "message": "Respuesta sin registro añadida correctamente",
            "data": {
                "asistente": data['asistente'],
                "respuesta": data['respuesta']
            }
        }

    except Exception as e:
        return {"success": 0, "message": f"Error al insertar respuesta: {str(e)}"}

    finally:
        cursor.close()
        conexion_bd.close()


# 📌 Editar respuesta sin registro
def update_respuesta_sin_registro(respuesta_id: int, data: dict):
    try:
        # Verificar conexión
        conexion_bd = get_connection()
        if conexion_bd is None:
            return {"success": 0, "message": "Error de conexión"}

        # Verificar datos esenciales
        if 'asistente' not in data or 'respuesta' not in data:
            return {"success": 0, "message": "Datos incompletos"}

        # Obtener cursor y comenzar transacción
        cursor = conexion_bd.cursor()
        cursor.execute("START TRANSACTION")

        # Preparar y ejecutar consulta SQL
        query = """
            UPDATE asistente_sin_registro 
            SET id_asistente = %s, respuesta = %s 
            WHERE id = %s
        """
        
        cursor.execute(query, (
            data['asistente'],  # ID del asistente
            data['respuesta'],   # Respuesta
            respuesta_id        # ID de la respuesta que queremos actualizar
        ))

        # Confirmar transacción
        conexion_bd.commit()

        return {
            "success": 1,
            "message": "Respuesta sin registro actualizada correctamente",
            "data": {
                "asistente": data['asistente'],
                "respuesta": data['respuesta']
            }
        }

    except Exception as e:
        # Manejo de errores y rollback si es necesario
        if conexion_bd:
            conexion_bd.rollback()
        
        # Retornar mensaje de error detallado
        return {"success": 0, "message": f"Error al actualizar respuesta: {str(e)}"}

    finally:
        # Cerrar recursos independientemente del resultado
        if 'cursor' in locals():
            cursor.close()
        if 'conexion_bd' in locals():
            conexion_bd.close()




# 📌 Eliminar respuesta con registro
def delete_respuesta_con_registro(respuesta_id: int):
    conexionBD = get_connection()
    if not conexionBD:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexionBD.cursor()

        # 🔹 Verificar si existe la respuesta antes de eliminar
        cursor.execute("SELECT video_url FROM asistente_con_registro WHERE id = %s", (respuesta_id,))
        video_url = cursor.fetchone()

        if not video_url:
            return {"success": 0, "message": "La respuesta no existe"}

        # 🔹 Eliminar el archivo de video si existe
        if video_url and video_url[0]:
            video_filename = os.path.basename(video_url[0])
            video_path = os.path.join(VIDEO_UPLOAD_FOLDER, video_filename)

            if os.path.exists(video_path):
                os.remove(video_path)

        # 🔹 Eliminar la respuesta de la base de datos
        cursor.execute("DELETE FROM asistente_con_registro WHERE id = %s", (respuesta_id,))
        conexionBD.commit()

        return {"success": 1, "message": "Respuesta con registro eliminada correctamente"}

    except Exception as e:
        return {"success": 0, "message": f"Error al eliminar respuesta: {str(e)}"}

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

# 📌 Eliminar respuesta sin registro
def delete_respuesta_sin_registro(respuesta_id):
    conexion_bd = get_connection()
    if conexion_bd is None:
        return {"success": 0, "message": "Error de conexión"}

    try:
        cursor = conexion_bd.cursor()
        cursor.execute("START TRANSACTION")

        # Preparar y ejecutar consulta SQL para eliminar
        query = """
            DELETE FROM asistente_sin_registro WHERE id = %s
        """
        
        cursor.execute(query, (respuesta_id,))

        # Confirmar transacción
        conexion_bd.commit()

        return {
            "success": 1,
            "message": "Respuesta sin registro eliminada correctamente"
        }

    except Exception as e:
        # Manejar errores y rollback si es necesario
        if conexion_bd:
            conexion_bd.rollback()

        return {"success": 0, "message": f"Error al eliminar respuesta: {str(e)}"}

    finally:
        # Cerrar recursos independientemente del resultado
        if 'cursor' in locals():
            cursor.close()
        if 'conexion_bd' in locals():
            conexion_bd.close()