import json
from datetime import datetime, timedelta, timezone
import hashlib
import sys
import requests
import os
from dotenv import load_dotenv

# Cargar las variables de entorno
#load_dotenv(env_path)
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)
token = os.getenv('TokenAu')

if token:
    print(f"🔑 Token obtenido: {repr(token)}")
else:
    print("⚠️ Advertencia: No se pudo cargar el token de la variable de entorno.")


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

from cnxpdo import get_connection
# Obtener token de la variable de entorno
#token = os.getenv('TokenAu')
#token = "btJvDVvI3exbj4Yx_89_0ySw2DfuZs9e-qAwl0lfnrdk4n2NSpWacZgkZHhBAGYI"

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

        cursor = conexionBD.cursor(dictionary=True)
        query = "SELECT * FROM pqrsf_status"
        cursor.execute(query)
        data = cursor.fetchall()

        cursor.close()
        conexionBD.close()

        return {
            "success": 1,
            "message": "Status de soportes encontrados",
            "data": data
        }
    except Exception as e:
        return {
            "success": 0,
            "message": f"Error: {str(e)}"
        }

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

        cursor = conexionBD.cursor(dictionary=True)
        query = "SELECT * FROM modulos"
        cursor.execute(query)
        userData = cursor.fetchall()

        cursor.close()
        conexionBD.close()

        return {
            "success": 1,
            "message": "Módulos encontrados",
            "data": userData
        }
    except Exception as e:
        return {
            "success": 0,
            "message": f"Error: {str(e)}"
        }

def getVistas(id_modulo):
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {
                "success": 0,
                "message": "Error de conexión"
            }

        cursor = conexionBD.cursor(dictionary=True)
        query = "SELECT * FROM modulos_vistas WHERE id_modulo = %s"
        cursor.execute(query, (id_modulo,))
        vistas = cursor.fetchall()

        cursor.close()
        conexionBD.close()

        if vistas:
            return {
                "success": 1,
                "message": "Vistas encontradas",
                "data": vistas
            }
        else:
            return {
                "success": 0,
                "message": "Error al buscar las vistas"
            }
    except Exception as e:
        return {
            "success": 0,
            "message": f"Error: {str(e)}"
        }
        
        
# def getTickets(customer_id=None):
#     url = 'https://tickets.cic-ware.com/api/v1/tickets'
#     headers = {
#         'Authorization': f'Bearer {token}',
#         'Content-Type': 'application/json',
#     }

#     # Realizar la solicitud GET
#     response = requests.get(url, headers=headers)

#     # Verificar el código de estado de la respuesta
#     if response.status_code == 200:
#         tickets = response.json()
        
#         # Filtrar los tickets si se proporcionó un customer_id
#         if customer_id:
#             tickets = [ticket for ticket in tickets if ticket.get('customer_id') == customer_id]

#         return {'success': True, 'data': tickets}
#     else:
#         return {
#             'success': False,
#             'message': 'Error al obtener los tickets.',
#             'response': response.json()
#         }


# def getTickets(customer_id=None):
#     #url = 'https://tickets.cic-ware.com/api/v1/tickets'
#     url = os.getenv('URL_ticket')

#     headers = {
#         'Authorization': f'Bearer {token}',
#         'Content-Type': 'application/json',
#     }


#     response = requests.get(url, headers=headers)

 
#     if response.status_code == 200:
#         tickets = response.json()

    
#         tickets = [ticket for ticket in tickets if ticket.get('state_id') != 4]

#         if customer_id:
#             tickets = [ticket for ticket in tickets if ticket.get('customer_id') == customer_id]

#         return {'success': True, 'data': tickets}
#     else:
#         return {
#             'success': False,
#             'message': 'Error al obtener los tickets.',
#             'response': response.json()
#         }

def getTickets(customer_id=None):
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": 0, "message": "Error de conexión"}
        
        # Usar cursor con dictionary=True para obtener resultados como diccionarios
        cursor = conexionBD.cursor(dictionary=True)

        # Si se proporciona customer_id, filtramos por 'id_empleado' (ajusta si tu campo se llama distinto)
        if customer_id:
            query = "SELECT * FROM soporte WHERE id_empleado = %s"
            cursor.execute(query, (customer_id,))
        else:
            query = "SELECT * FROM soporte"
            cursor.execute(query)
        
        # Obtener todos los registros
        rows = cursor.fetchall()

        cursor.close()
        conexionBD.close()

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

        

def getClosedTickets(customer_id=None):
    #url_tickets = 'https://tickets.cic-ware.com/api/v1/tickets'
    #url_articles = 'https://tickets.cic-ware.com/api/v1/ticket_articles'

    url_tickets = os.getenv('URL_ticket')
    url_articles = os.getenv('URL_ticket_articles')
    headers = {
        'Authorization': f'Bearer {token}',  # Asegúrate de que 'token' esté definido
        'Content-Type': 'application/json',
    }

    # Obtener los tickets cerrados
    response = requests.get(url_tickets, headers=headers)
    
    if response.status_code != 200:
        return {
            'success': False,
            'message': 'Error al obtener los tickets.',
            'response': response.json()
        }

    tickets = response.json()

    # Filtrar tickets cerrados
    tickets = [ticket for ticket in tickets if ticket.get('state_id') == 4]

    # Si se pasa un customer_id, filtrar por ese customer_id
    if customer_id:
        tickets = [ticket for ticket in tickets if ticket.get('customer_id') == customer_id]

    # Obtener todos los artículos de tickets
    articles_response = requests.get(url_articles, headers=headers)
    
    if articles_response.status_code != 200:
        return {
            'success': False,
            'message': 'Error al obtener los artículos.',
            'response': articles_response.json()
        }

    articles = articles_response.json()

    # Filtrar los artículos para que solo contengan los ticket_id correspondientes
    ticket_ids = {ticket['id'] for ticket in tickets}
    filtered_articles = [article for article in articles if article['ticket_id'] in ticket_ids]

    # Ahora agregar los artículos filtrados a los tickets
    for ticket in tickets:
        ticket_articles = [article for article in filtered_articles if article['ticket_id'] == ticket['id']]
        ticket['articles'] = ticket_articles

    return {'success': True, 'data': tickets}
# Post


# def insertarSoporte(data):
#     try:
#         # Establecer conexión con la base de datos
#         conexionBD = get_connection()  # Asegúrate de implementar esta función para obtener la conexión
#         if conexionBD is None:
#             return {"success": 0, "message": "Error de conexión"}

#         # Obtener la fecha y hora en la zona horaria de Bogotá
#         fechaHora = datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=-5))).strftime('%Y-%m-%d %H:%M:%S')

#         # Extraer los datos
#         nombre = data['nombre']
#         modulo = data['id_modulo']
#         vista = data['id_vista']
#         observacion = data['observacion']
#         id_empleado = data['id_empleado']

#         with conexionBD.cursor(dictionary=True) as cursor:
#             # Paso 1: Insertar en la tabla 'soporte'
#             query = """
#                 INSERT INTO soporte (nombre, id_modulo, id_vista, observacion, id_empleado, fecha_hora)
#                 VALUES (%s, %s, %s, %s, %s, %s)
#             """
#             cursor.execute(query, (nombre, modulo, vista, observacion, id_empleado, fechaHora))
#             conexionBD.commit()

#             # Paso 2: Obtener el ID del último registro insertado
#             lastInsertId = cursor.lastrowid

#             # Paso 3: Insertar en la tabla 'soporte_logs' (con el estado por defecto)
#             defaultStatusId = 1  # Ejemplo de ID de estado por defecto
#             logQuery = """
#                 INSERT INTO soporte_logs (id_soporte, id_status, fecha_hora, id_empleado)
#                 VALUES (%s, %s, %s, %s)
#             """
#             cursor.execute(logQuery, (lastInsertId, defaultStatusId, fechaHora, id_empleado))
#             conexionBD.commit()

#             # Paso 4: Consultar los datos recién insertados
#             stmt2 = """
#                 SELECT s.*,
#                        m.modulo AS modulo_name,
#                        v.nombre_vista AS vista_name,
#                        e.id AS id_empleado,
#                        s.id AS id_soporte
#                 FROM soporte s
#                 JOIN modulos m ON s.id_modulo = m.id
#                 JOIN modulos_vistas v ON s.id_vista = v.id
#                 JOIN empleados e ON s.id_empleado = e.id
#                 WHERE s.id = %s
#             """
#             cursor.execute(stmt2, (lastInsertId,))
#             insertedData = cursor.fetchone()

#             # Resultado
#             if insertedData:
#                 return {
#                     "success": 1,
#                     "message": "Soporte insertado y log actualizado",
#                     "data": insertedData
#                 }
#             else:
#                 return {
#                     "success": 0,
#                     "message": "Error al recuperar los datos insertados",
#                     "data": []
#                 }

#     except Exception as e:
#         return {
#             "success": 0,
#             "message": f"Error: {str(e)}"
#         }
#     finally:
#         conexionBD.close()

# def insertarSoporte(data):
#     #url = 'https://tickets.cic-ware.com/api/v1/tickets'
#     url = os.getenv('URL_ticket')
#     headers = {
#         'Authorization': f'Bearer {token}',
#         'Content-Type': 'application/json',
#     }

#     # Validar que los campos necesarios estén presentes
#     if 'prioridad' not in data or 'modulo' not in data or 'vista' not in data or 'asunto' not in data or 'id_empleado' not in data:
#         return {'success': False, 'message': 'Faltan campos requeridos.'}

#     titulo = f'{data["modulo"]} - {data["vista"]}'

#     # Construir el cuerpo de la solicitud para Zammad
#     body = {
#         'title': titulo,
#         'subject': data['asunto'],
#         'group': 'Desarrolladores',
#         'priority_id': data['prioridad'],
#         'state': 'new',
#         'customer_id': data['id_empleado'],
#         #'owner_id': 19,
#         # 'tags': [f'id_empleado_{data["id_empleado"]}'],
#         # 'article': {
#         #     'body': data['observacion'],
#         #     'type': 'note',
#         #     'internal': False,
#         # },
     
#     }
   
#     # Realizar la solicitud POST
#     response = requests.post(url, headers=headers, data=json.dumps(body))

#     # Verificar el código de estado de la respuesta
#     if response.status_code == 201:
#         return {'success': True, 'message': 'Ticket creado correctamente.'}
#     else:
#         return {
#             'success': False,
#             'message': 'Error al crear el ticket.',
#             'response': response.json()
#         }

def insertarSoporte(data):
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": 0, "message": "Error de conexión"}
        
        # Obtener los datos que sí coinciden con la tabla
        asunto = data.get('asunto')  
        prioridad = data.get('prioridad')
        observacion = data.get('observacion')
        id_empleado = data.get('id_empleado')
        id_modulo = data.get('modulo')  
        id_vista = data.get('vista') 
        

        colombia_tz = timezone(timedelta(hours=-5))
        
        fecha_hora = datetime.now(colombia_tz).strftime('%Y-%m-%d %H:%M:%S')

        query = """
            INSERT INTO soporte (asunto, prioridad, observacion, id_empleado, id_modulo, id_vista, fecha_hora)
            VALUES (%s, %s, %s, %s, %s, %s, %s)
        """
        
        cursor = conexionBD.cursor()
        cursor.execute(query, (asunto, prioridad, observacion, id_empleado, id_modulo, id_vista, fecha_hora))
        
        # 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)}"}
    
    
    
def recuperarSoporte(id_empleado=None):
    try:
        conexionBD = get_connection()
        if conexionBD is None:
            return {"success": 0, "message": "Error de conexión"}

        if id_empleado:
            query = """
                SELECT * FROM soporte WHERE id_empleado = %s
            """
            
            cursor = conexionBD.cursor(dictionary=True)
            cursor.execute(query, (id_empleado,))
            
            # Obtener todos los registros
            data = cursor.fetchall()
            
            # Consultas adicionales para obtener el nombre del modulo y nombre de la vista
            for record in data:
                if 'id_modulo' in record:
                    # Obtener el nombre del modulo desde la tabla 'modulos'
                    query_modulo = """
                        SELECT modulo FROM modulos WHERE id = %s
                    """
                    cursor.execute(query_modulo, (record['id_modulo'],))
                    modulo_result = cursor.fetchone()
                    if modulo_result:
                        record['modulo'] = modulo_result['modulo']
                    else:
                        record['modulo'] = None

                if 'id_vista' in record:
                    # Obtener el nombre de la vista desde la tabla 'modulos_vistas'
                    query_vista = """
                        SELECT nombre_vista FROM modulos_vistas WHERE id = %s
                    """
                    cursor.execute(query_vista, (record['id_vista'],))
                    vista_result = cursor.fetchone()
                    if vista_result:
                        record['nombre_vista'] = vista_result['nombre_vista']
                    else:
                        record['nombre_vista'] = None

             
                if 'fecha_hora' in record:
                  
                    if isinstance(record['fecha_hora'], datetime):
                        record['fecha_hora'] = record['fecha_hora'].strftime('%d de %B de %Y, %I:%M %p')
                    else:
                      
                        fecha_hora = datetime.strptime(record['fecha_hora'], '%Y-%m-%dT%H:%M:%S')
                        record['fecha_hora'] = fecha_hora.strftime('%d de %B de %Y, %I:%M %p')

            cursor.close()
            conexionBD.close()
            
            if data:
                return {"success": 1, "message": "Datos encontrados", "data": data}
            else:
                return {"success": 0, "message": "No se encontraron datos"}
        
    except Exception as e:
        return {"success": 0, "message": f"Error al recuperar datos: {str(e)}"}


# PUT

def updateRespuesta(id, data):
    try:
        # Establecer conexión con la base de datos
        conexionBD = get_connection()  # Asegúrate de implementar esta función para obtener la conexión
        if conexionBD is None:
            return {"success": 0, "message": "Error de conexión"}

        # Validar los datos de entrada
        if 'respuesta' not in data:
            return {"success": 0, "message": "Missing respuesta in input data"}

        respuesta = data['respuesta']

        with conexionBD.cursor() as cursor:
            # Preparar la consulta SQL
            query = "UPDATE soporte_logs SET respuesta = %s WHERE id = %s"
            cursor.execute(query, (respuesta, id))
            conexionBD.commit()

            # Lógica mejorada para manejar los resultados de la actualización
            if cursor.rowcount > 0:
                return {"success": 1, "message": "Respuesta updated successfully"}
            else:
                # Comprobar si el registro existe con el ID proporcionado
                checkQuery = "SELECT COUNT(*) FROM soporte_logs WHERE id = %s"
                cursor.execute(checkQuery, (id,))
                recordExists = cursor.fetchone()[0] > 0

                if recordExists:
                    return {"success": 1, "message": "No changes made; respuesta is identical to the current value."}
                else:
                    return {"success": 0, "message": "No record found with the provided ID."}

    except Exception as e:
        return {"success": 0, "message": str(e)}

    finally:
        conexionBD.close()