import json
import sys
from datetime import datetime

# Agrega la ruta absoluta al sys.path
sys.path.append('/var/www/html/config')

from cnxpdo import get_connection



def consultarPerfil():
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT ep.*, s.status AS nomstatus 
            FROM empleados_perfiles ep 
            INNER JOIN status s ON ep.status = s.id
        """
        cursor.execute(query)
        result = cursor.fetchall()
        
        if len(result) > 0:
            return {
                "success": True,
                "message": "Perfiles encontrados",
                "data": result
            }
        else:
            return {
                "success": True,  
                "message": "No se encontraron perfiles",
                "data": []
            }
    
    except Exception as e:
        return {
            "success": False,
            "message": f"Error: {str(e)}"
        }
    
    finally:
        cursor.close()
        conexionBD.close()



def insertarPerfil(data):
    conexionBD = get_connection()
    if conexionBD is None:
        return {
            "success": False, 
            "message": "Error de conexión"
        }
    
    try:
        perfiles = data.get("perfiles")
        descripcion = data.get("descripcion")
        status = data.get("status")
        
        cursor = conexionBD.cursor(dictionary=True)
        query = "INSERT INTO empleados_perfiles (perfiles, descripcion, status) VALUES (%s, %s, %s)"
        cursor.execute(query, (perfiles, descripcion, status))
        conexionBD.commit()
        
        id_insertado = cursor.lastrowid
        
        query = "SELECT * FROM status WHERE id = %s"
        cursor.execute(query, (status,))
        nomstatus = cursor.fetchone()
        
        if nomstatus:
            data["nomstatus"] = nomstatus["status"]
        
        data["id"] = id_insertado
        
        cursor.close()
        conexionBD.close()
        return {
            "success": True, 
            "message": "Perfil insertado", 
            "data": data
        }
    
    except Exception as e:
        return {
            "success": False, 
            "message": f"Error: {str(e)}"
        }
    
    finally:
        cursor.close()
        conexionBD.close()



def actualizarPerfil(id, data):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        perfiles = data.get("perfiles")
        descripcion = data.get("descripcion")
        status = data.get("status")
        
        cursor = conexionBD.cursor(dictionary=True)
        query = "UPDATE empleados_perfiles SET perfiles = %s, descripcion = %s, status = %s WHERE id = %s"
        cursor.execute(query, (perfiles, descripcion, status, id))
        conexionBD.commit()
        
        query = "SELECT * FROM status WHERE id = %s"
        cursor.execute(query, (status,))
        nomstatus = cursor.fetchone()
        
        if nomstatus:
            data["nomstatus"] = nomstatus["status"]
        
        cursor.close()
        conexionBD.close()
        data["id"] = id
        return {"success": True, "message": "Perfil actualizado", "data": data}
    
    except Exception as e:
        return {"success": False, "message": f"Error: {str(e)}"}
    
    finally:
        cursor.close()
        conexionBD.close()



def eliminarPerfil(id):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor()
        
        # Verificar si el perfil está asociado a algún usuario
        query = "SELECT COUNT(*) FROM usuarios WHERE idperfil = %s"
        cursor.execute(query, (id,))
        count = cursor.fetchone()[0]
        
        if count > 0:
            return {"success": False, "message": "No se puede eliminar el perfil porque tiene usuarios asociados"}
        
        # Eliminar el perfil
        query = "DELETE FROM empleados_perfiles WHERE id = %s"
        cursor.execute(query, (id,))
        conexionBD.commit()
        
        cursor.close()
        conexionBD.close()
        return {"success": True, "message": "Perfil eliminado correctamente"}
    
    except Exception as e:
        return {"success": False, "message": f"Error: {str(e)}"}
    
    finally:
        cursor.close()
        conexionBD.close()



""" ------------------Permisos  ------------------ """
def consultarPermisosVistas(id_perfil):
    conexionBD = get_connection()
    if conexionBD is None:
        return {
            "success": False, 
            "message": "Error de conexión"
        }
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT p.*, m.modulo, mv.nombre_vista AS vista 
            FROM permisos p 
            INNER JOIN modulos m ON p.id_modulo = m.id 
            INNER JOIN modulos_vistas mv ON p.id_vista = mv.id 
            WHERE p.id_perfil = %s
            AND p.id_elemento IS NULL
        """
        cursor.execute(query, (int(id_perfil),))
        result = cursor.fetchall()
        
        if len(result) > 0:
            return {
                "success": True,
                "message": "Permisos encontrados",
                "data": result
            }
        else:
            return {
                "success": True,  # Puedes cambiar a False según tu lógica de negocio
                "message": "No se encontraron permisos de vistas para este perfil",
                "data": []
            }
    
    except Exception as e:
        return {
            "success": False,
            "message": f"Error: {str(e)}"
        }
    
    finally:
        cursor.close()
        conexionBD.close()



def consultarPermisos(id_perfil):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT p.*, m.modulo, mv.nombre_vista AS vista, pe.elemento 
            FROM permisos p 
            INNER JOIN modulos m ON p.id_modulo = m.id 
            INNER JOIN modulos_vistas mv ON p.id_vista = mv.id 
            LEFT JOIN permisos_elementos pe ON pe.id = p.id_elemento 
            WHERE p.id_perfil = %s
        """
        cursor.execute(query, (id_perfil,))
        result = cursor.fetchall()
        
        if len(result) > 0:
            return {
                "success": True,
                "message": "Permisos encontrados",
                "data": result
            }
        else:
            return {
                "success": True,  # Puedes cambiar a False según tu lógica de negocio
                "message": "No se encontraron permisos para este perfil",
                "data": []
            }
    
    except Exception as e:
        return {
            "success": False,
            "message": f"Error: {str(e)}"
        }
    
    finally:
        cursor.close()
        conexionBD.close()



def consultarPermisosElementos(id_perfil):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            SELECT p.*, m.modulo, mv.nombre_vista AS vista, pe.elemento AS elemento 
            FROM permisos p 
            INNER JOIN modulos m ON p.id_modulo = m.id 
            INNER JOIN modulos_vistas mv ON p.id_vista = mv.id 
            INNER JOIN permisos_elementos pe ON p.id_elemento = pe.id 
            WHERE p.id_perfil = %s
        """
        cursor.execute(query, (id_perfil,))
        result = cursor.fetchall()
        
        if len(result) > 0:
            return {
                "success": True,
                "message": "Permisos encontrados",
                "data": result
            }
        else:
            return {
                "success": True,  # O False, según tu lógica de negocio
                "message": "No se encontraron permisos para este perfil",
                "data": []
            }
    
    except Exception as e:
        return {
            "success": False,
            "message": f"Error: {str(e)}"
        }
    
    finally:
        cursor.close()
        conexionBD.close()



def consultarModulos():
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = "SELECT * FROM modulos"
        cursor.execute(query)
        result = cursor.fetchall()
        
        if result:
            return {
                "success": True,
                "message": "Módulos encontrados",
                "data": result
            }
        else:
            return {"success": False, "message": "Error al buscar los módulos"}
    
    except Exception as e:
        return {
            "success": False,
            "message": f"Error: {str(e)}"
        }
    
    finally:
        cursor.close()
        conexionBD.close()




def consultarVistas(id_modulo):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = "SELECT * FROM modulos_vistas WHERE id_modulo = %s"
        cursor.execute(query, (id_modulo,))
        result = cursor.fetchall()
        
        if result:
            return {
                "success": True,
                "message": "Vistas encontradas",
                "data": result
            }
        else:
            return {"success": False, "message": "Error al buscar las vistas"}
    
    except Exception as e:
        return {
            "success": False,
            "message": f"Error: {str(e)}"
        }
    
    finally:
        cursor.close()
        conexionBD.close()



def consultarElementos(id_vista):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor(dictionary=True)
        query = "SELECT * FROM permisos_elementos WHERE vista = %s"
        cursor.execute(query, (id_vista,))
        result = cursor.fetchall()
        
        if result:
            return {
                "success": True,
                "message": "Elementos encontrados",
                "data": result
            }
        else:
            return {"success": False, "message": "Error al buscar los elementos"}
    
    except Exception as e:
        return {
            "success": False,
            "message": f"Error: {str(e)}"
        }
    
    finally:
        cursor.close()
        conexionBD.close()



def insertarPermiso(data):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        id_perfil = data.get("id_perfil")
        id_modulo = data.get("id_modulo")
        id_vista = data.get("id_vista")
        id_elemento = data.get("id_elemento")
        permiso = data.get("permiso")
        
        cursor = conexionBD.cursor(dictionary=True)
        query = "INSERT INTO permisos (id_perfil, id_modulo, id_vista, id_elemento, permiso) VALUES (%s, %s, %s, %s, %s)"
        cursor.execute(query, (id_perfil, id_modulo, id_vista, id_elemento, permiso))
        conexionBD.commit()
        
        id_permiso = cursor.lastrowid
        
        query = """
            SELECT p.*, m.modulo, mv.nombre_vista AS vista, pe.elemento 
            FROM permisos p 
            INNER JOIN modulos m ON p.id_modulo = m.id 
            INNER JOIN modulos_vistas mv ON p.id_vista = mv.id 
            LEFT JOIN permisos_elementos pe ON pe.id = p.id_elemento 
            WHERE p.id = %s
        """
        cursor.execute(query, (id_permiso,))
        permiso_insertado = cursor.fetchone()
        
        cursor.close()
        conexionBD.close()
        return {"success": True, "message": "Permiso insertado", "data": permiso_insertado}
    
    except Exception as e:
        return {"success": False, "message": f"Error: {str(e)}"}
    
    finally:
        cursor.close()
        conexionBD.close()



def actualizarPermiso(id_permiso, data):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        id_perfil = data.get("id_perfil")
        id_modulo = data.get("id_modulo")
        id_vista = data.get("id_vista")
        id_elemento = data.get("id_elemento")
        permiso = data.get("permiso")
        
        cursor = conexionBD.cursor(dictionary=True)
        query = """
            UPDATE permisos 
            SET id_perfil = %s, id_modulo = %s, id_vista = %s, id_elemento = %s, permiso = %s 
            WHERE id = %s
        """
        cursor.execute(query, (id_perfil, id_modulo, id_vista, id_elemento, permiso, id_permiso))
        conexionBD.commit()
        
        query = """
            SELECT p.*, m.modulo, mv.nombre_vista AS vista, pe.elemento 
            FROM permisos p 
            INNER JOIN modulos m ON p.id_modulo = m.id 
            INNER JOIN modulos_vistas mv ON p.id_vista = mv.id 
            LEFT JOIN permisos_elementos pe ON pe.id = p.id_elemento 
            WHERE p.id = %s
        """
        cursor.execute(query, (id_permiso,))
        permiso_actualizado = cursor.fetchone()
        
        cursor.close()
        conexionBD.close()
        return {"success": True, "message": "Permiso actualizado", "data": permiso_actualizado}
    
    except Exception as e:
        return {"success": False, "message": f"Error: {str(e)}"}
    
    finally:
        cursor.close()
        conexionBD.close()



def eliminarPermiso(id_permiso):
    conexionBD = get_connection()
    if conexionBD is None:
        return {"success": False, "message": "Error de conexión"}
    
    try:
        cursor = conexionBD.cursor()
        query = "DELETE FROM permisos WHERE id = %s"
        cursor.execute(query, (id_permiso,))
        conexionBD.commit()
        
        cursor.close()
        conexionBD.close()
        return {"success": True, "message": "Permiso eliminado correctamente"}
    
    except Exception as e:
        return {"success": False, "message": f"Error: {str(e)}"}
    
    finally:
        cursor.close()
        conexionBD.close()