#!/usr/bin/env python3
# 03_import_extensions.py
# Importar extensiones desde CSV a base de datos

import csv
import mysql.connector
from datetime import datetime
import sys

def connect_db():
    """Conectar a la base de datos"""
    try:
        conn = mysql.connector.connect(
            host='localhost',
            user='asteriskuser',
            password='coolla007llama09',
            database='asterisk'
        )
        return conn
    except mysql.connector.Error as err:
        print(f"Error conectando a BD: {err}")
        sys.exit(1)

def clean_existing_data(cursor):
    """Limpiar datos existentes de prueba"""
    print("Limpiando datos existentes...")
    
    # NO truncar, solo marcar como inactivos los que no están en el CSV
    cursor.execute("UPDATE agentes SET activo = 0 WHERE usuario LIKE '3%'")
    cursor.execute("UPDATE coordinadores SET activo = 0")
    print("Datos marcados como inactivos")

def import_extensions(csv_file):
    """Importar extensiones desde CSV"""
    conn = connect_db()
    cursor = conn.cursor()
    
    try:
        # Limpiar datos existentes
        clean_existing_data(cursor)
        
        # Contadores
        counts = {
            'COORDINADOR': 0,
            'TAROT': 0,
            'INFO': 0,
            'USUARIO': 0,
            'RESCATE': 0,
            'CALL_CENTER_EXTERNO': 0
        }
        
        # Leer CSV
        with open(csv_file, 'r', encoding='utf-8') as file:
            csv_reader = csv.DictReader(file)
            
            for row in csv_reader:
                extension = row['EXTENSION'].strip()
                tipo = row['TIPO'].strip()
                nombre = row['NOMBRE'].strip()
                password = row['CONTRASEÑA'].strip()
                telefono = row['TELEFONO DE CONEXIÓN'].strip()
                
                # Determinar grupo para coordinadores
                grupo = None
                if tipo == 'COORDINADOR':
                    if extension in ['234', '238', '232', '233', '223', '224']:
                        grupo = 'respaldo'
                    elif extension == '217':
                        grupo = 'apoyo'
                    else:
                        grupo = 'principal'
                
                # Insertar en extensiones_sistema
                sql_ext = """
                INSERT INTO extensiones_sistema 
                (extension, tipo, nombre, password, telefono_conexion, grupo)
                VALUES (%s, %s, %s, %s, %s, %s)
                ON DUPLICATE KEY UPDATE
                nombre = VALUES(nombre),
                password = VALUES(password),
                telefono_conexion = VALUES(telefono_conexion),
                grupo = VALUES(grupo),
                activo = TRUE
                """
                cursor.execute(sql_ext, (extension, tipo, nombre, password, telefono, grupo))
                
                # Insertar según tipo
                if tipo == 'COORDINADOR':
                    insert_coordinador(cursor, extension, nombre, password)
                elif tipo == 'TAROT':
                    insert_tarotista(cursor, extension, nombre, password, telefono)
                elif tipo == 'INFO':
                    insert_info_agent(cursor, extension, nombre, password, telefono)
                elif tipo == 'CALL_CENTER_EXTERNO':
                    # Los call center externos se tratan como agentes especiales
                    if 'ERO' in nombre:
                        insert_ero_agent(cursor, extension, nombre, password, telefono)
                    else:
                        insert_external_agent(cursor, extension, nombre, password, telefono)
                
                counts[tipo] += 1
                
        # Confirmar cambios
        conn.commit()
        
        # Mostrar resumen
        print("\n=== RESUMEN DE IMPORTACIÓN ===")
        for tipo, count in counts.items():
            if count > 0:
                print(f"{tipo}: {count} extensiones")
        print(f"TOTAL: {sum(counts.values())} extensiones importadas")
        
        # Verificar importación
        cursor.execute("SELECT tipo, COUNT(*) as total FROM extensiones_sistema WHERE activo = 1 GROUP BY tipo")
        print("\nVerificación en BD:")
        for tipo, total in cursor.fetchall():
            print(f"  {tipo}: {total}")
            
    except Exception as e:
        print(f"Error durante importación: {e}")
        conn.rollback()
        raise
    finally:
        cursor.close()
        conn.close()

def insert_coordinador(cursor, extension, nombre, password):
    """Insertar coordinador en tabla coordinadores"""
    sql = """
    INSERT INTO coordinadores (extension, nombre, password, activo)
    VALUES (%s, %s, %s, 1)
    ON DUPLICATE KEY UPDATE 
    nombre = VALUES(nombre),
    password = VALUES(password),
    activo = 1
    """
    cursor.execute(sql, (extension, nombre, password))

def insert_tarotista(cursor, codigo, nombre, password, telefono):
    """Insertar tarotista en tabla agentes"""
    # Separar nombre y apellidos
    parts = nombre.split(' ', 1)
    nombre_solo = parts[0]
    apellidos = parts[1] if len(parts) > 1 else ''
    
    sql = """
    INSERT INTO agentes 
    (usuario, nombre, apellidos, password, telefono, tipo, activo, estado_login, estado_ocupacion, dnd_status)
    VALUES (%s, %s, %s, %s, %s, 'TAROT', 1, 0, 0, 0)
    ON DUPLICATE KEY UPDATE 
    nombre = VALUES(nombre),
    apellidos = VALUES(apellidos),
    telefono = VALUES(telefono),
    password = VALUES(password),
    tipo = 'TAROT',
    activo = 1
    """
    cursor.execute(sql, (codigo, nombre_solo, apellidos, password, telefono))

def insert_info_agent(cursor, extension, nombre, password, telefono):
    """Insertar agente INFO"""
    parts = nombre.split(' ', 1)
    nombre_solo = parts[0]
    apellidos = parts[1] if len(parts) > 1 else ''
    
    # Si no tiene teléfono real, usar CENTRALITA
    if not telefono or telefono == 'CENTRALITA':
        telefono = 'CENTRALITA'
    
    sql = """
    INSERT INTO agentes 
    (usuario, nombre, apellidos, password, telefono, tipo, activo, estado_login, estado_ocupacion, dnd_status)
    VALUES (%s, %s, %s, %s, %s, 'INFO', 1, 0, 0, 0)
    ON DUPLICATE KEY UPDATE 
    nombre = VALUES(nombre),
    apellidos = VALUES(apellidos),
    telefono = VALUES(telefono),
    password = VALUES(password),
    tipo = 'INFO',
    activo = 1
    """
    cursor.execute(sql, (extension, nombre_solo, apellidos, password, telefono))

def insert_ero_agent(cursor, extension, nombre, password, telefono):
    """Insertar agente EROTICO"""
    sql = """
    INSERT INTO agentes 
    (usuario, nombre, apellidos, password, telefono, tipo, activo, estado_login, estado_ocupacion, dnd_status)
    VALUES (%s, %s, '', %s, %s, 'EROTICO', 1, 0, 0, 0)
    ON DUPLICATE KEY UPDATE 
    nombre = VALUES(nombre),
    telefono = VALUES(telefono),
    password = VALUES(password),
    tipo = 'EROTICO',
    activo = 1
    """
    cursor.execute(sql, (extension, nombre, password, telefono))

def insert_external_agent(cursor, extension, nombre, password, telefono):
    """Insertar agente call center externo"""
    sql = """
    INSERT INTO agentes 
    (usuario, nombre, apellidos, password, telefono, tipo, activo, estado_login, estado_ocupacion, dnd_status)
    VALUES (%s, %s, '', %s, %s, 'EXTERNO', 1, 0, 0, 0)
    ON DUPLICATE KEY UPDATE 
    nombre = VALUES(nombre),
    telefono = VALUES(telefono),
    password = VALUES(password),
    tipo = 'EXTERNO',
    activo = 1
    """
    cursor.execute(sql, (extension, nombre, password, telefono))

def create_initial_metrics():
    """Crear métricas iniciales para pruebas"""
    conn = connect_db()
    cursor = conn.cursor()
    
    try:
        # Crear métricas ficticias para algunos tarotistas
        # Esto permite probar el ordenamiento por duración media
        import random
        from datetime import date, timedelta
        
        # Obtener tarotistas
        cursor.execute("SELECT usuario FROM agentes WHERE tipo = 'TAROT' AND activo = 1 LIMIT 10")
        tarotistas = [row[0] for row in cursor.fetchall()]
        
        print("\nCreando métricas iniciales de prueba...")
        for agent in tarotistas:
            # Últimos 7 días
            for i in range(7):
                fecha = date.today() - timedelta(days=i)
                llamadas = random.randint(5, 20)
                duracion_total = llamadas * random.randint(180, 600)  # 3-10 min promedio
                
                sql = """
                INSERT INTO metricas_duracion 
                (agent_code, fecha, total_llamadas, duracion_total_segundos)
                VALUES (%s, %s, %s, %s)
                ON DUPLICATE KEY UPDATE
                total_llamadas = VALUES(total_llamadas),
                duracion_total_segundos = VALUES(duracion_total_segundos)
                """
                cursor.execute(sql, (agent, fecha, llamadas, duracion_total))
        
        conn.commit()
        print("Métricas de prueba creadas")
        
    except Exception as e:
        print(f"Error creando métricas: {e}")
    finally:
        cursor.close()
        conn.close()

if __name__ == "__main__":
    csv_file = '/var/www/html/docs/extensiones_data.csv'
    
    print("=== IMPORTACIÓN DE EXTENSIONES ===")
    print(f"Archivo: {csv_file}")
    print(f"Fecha: {datetime.now()}")
    print("")
    
    try:
        import_extensions(csv_file)
        create_initial_metrics()
        print("\n✓ Importación completada exitosamente")
    except Exception as e:
        print(f"\n✗ Error en importación: {e}")
        sys.exit(1)