from flask import Blueprint, render_template, request, session, redirect, url_for, flash, jsonify
from backend.db_core import get_connection
from backend.security import requiere_ejecutivo

grupos_bp = Blueprint('grupos', __name__, url_prefix='/configuracion/grupos')

def sincronizar_grupos_sistema(cursor, db):
    """Crea y actualiza automáticamente los grupos estatutarios basados en los roles."""
    # 1. Asegurar que existen los grupos base
    cursor.execute("SELECT id_grupo, nombre_grupo FROM utrau_grupos WHERE nombre_grupo IN ('DIRECTIVA (Sistema)', 'EJECUTIVO (Sistema)')")
    grupos_sis = cursor.fetchall()
    ids_sis = {g['nombre_grupo']: g['id_grupo'] for g in grupos_sis}

    if 'DIRECTIVA (Sistema)' not in ids_sis:
        cursor.execute("INSERT INTO utrau_grupos (nombre_grupo, id_padre) VALUES ('DIRECTIVA (Sistema)', NULL)")
        ids_sis['DIRECTIVA (Sistema)'] = cursor.lastrowid
    if 'EJECUTIVO (Sistema)' not in ids_sis:
        cursor.execute("INSERT INTO utrau_grupos (nombre_grupo, id_padre) VALUES ('EJECUTIVO (Sistema)', NULL)")
        ids_sis['EJECUTIVO (Sistema)'] = cursor.lastrowid

    id_dir = ids_sis['DIRECTIVA (Sistema)']
    id_eje = ids_sis['EJECUTIVO (Sistema)']

    # 2. Vaciar los integrantes actuales de estos grupos automáticos
    cursor.execute("DELETE FROM utrau_usuarios_grupos WHERE id_grupo IN (%s, %s)", (id_dir, id_eje))

    # 3. Llenar Directiva (Roles 2, 3 y 4)
    cursor.execute("""
        INSERT INTO utrau_usuarios_grupos (id_usuario, id_grupo)
        SELECT id_usuario, %s FROM utrau_usuarios WHERE rol >= 2 AND estado = 'ACTIVO'
    """, (id_dir,))

    # 4. Llenar Ejecutivo (Roles 3 y 4)
    cursor.execute("""
        INSERT INTO utrau_usuarios_grupos (id_usuario, id_grupo)
        SELECT id_usuario, %s FROM utrau_usuarios WHERE rol >= 3 AND estado = 'ACTIVO'
    """, (id_eje,))

    db.commit()

@grupos_bp.route('/')
@requiere_ejecutivo
def index():
    db = get_connection()
    cursor = db.cursor(dictionary=True)

    # EJECUTAMOS LA SINCRONIZACIÓN AUTOMÁTICA
    sincronizar_grupos_sistema(cursor, db)

    # 1. Traemos todos los grupos
    cursor.execute("""
        SELECT g1.id_grupo, g1.nombre_grupo, g1.id_padre, g2.nombre_grupo as nombre_padre
        FROM utrau_grupos g1
        LEFT JOIN utrau_grupos g2 ON g1.id_padre = g2.id_grupo
        ORDER BY g1.id_padre ASC, g1.nombre_grupo ASC
    """)
    grupos = cursor.fetchall()

    # 2. Traemos a todos los compañeros
    cursor.execute("""
        SELECT ug.id_grupo, u.id_usuario, u.nombre_completo, u.path_foto
        FROM utrau_usuarios_grupos ug
        JOIN utrau_usuarios u ON ug.id_usuario = u.id_usuario
        ORDER BY u.nombre_completo ASC
    """)
    integrantes_raw = cursor.fetchall()

    integrantes_por_grupo = {}
    for row in integrantes_raw:
        id_g = row['id_grupo']
        if id_g not in integrantes_por_grupo:
            integrantes_por_grupo[id_g] = []
        integrantes_por_grupo[id_g].append(row)

    for g in grupos:
        g['integrantes'] = integrantes_por_grupo.get(g['id_grupo'], [])

    cursor.execute("SELECT id_usuario, nombre_completo, alias FROM utrau_usuarios WHERE estado = 'ACTIVO' ORDER BY nombre_completo")
    usuarios = cursor.fetchall()

    cursor.close()
    db.close()

    return render_template('config_grupos.html',
                           user_nom=session.get('user_alias'),
                           grupos=grupos,
                           usuarios=usuarios)

@grupos_bp.route('/guardar', methods=['POST'])
@requiere_ejecutivo
def guardar():
    id_grupo = request.form.get('id_grupo')
    nombre = request.form.get('nombre_grupo', '').strip()
    id_padre = request.form.get('id_padre')

    if '(Sistema)' in nombre:
        flash('No podés usar la etiqueta reservada "(Sistema)" para grupos manuales.', 'error')
        return redirect(url_for('grupos.index'))

    if not id_padre or id_padre == '':
        id_padre = None

    if not nombre:
        flash('El nombre del grupo es obligatorio.', 'error')
        return redirect(url_for('grupos.index'))

    db = get_connection()
    cursor = db.cursor()

    try:
        if id_grupo:
            cursor.execute("SELECT nombre_grupo FROM utrau_grupos WHERE id_grupo=%s", (id_grupo,))
            grupo_actual = cursor.fetchone()
            if grupo_actual and '(Sistema)' in grupo_actual[0]:
                flash('Los grupos del sistema no se pueden editar.', 'error')
                return redirect(url_for('grupos.index'))

            if str(id_grupo) == str(id_padre):
                flash('Un grupo no puede estar dentro de sí mismo.', 'error')
                return redirect(url_for('grupos.index'))

            cursor.execute("UPDATE utrau_grupos SET nombre_grupo=%s, id_padre=%s WHERE id_grupo=%s", (nombre, id_padre, id_grupo))
            flash('Estructura de grupo actualizada.', 'success')
        else:
            cursor.execute("INSERT INTO utrau_grupos (nombre_grupo, id_padre) VALUES (%s, %s)", (nombre, id_padre))
            flash('Nuevo grupo creado con éxito.', 'success')
        db.commit()
    except Exception as e:
        db.rollback()
        flash(f'Error al guardar el grupo: {e}', 'error')
    finally:
        cursor.close()
        db.close()

    return redirect(url_for('grupos.index'))

@grupos_bp.route('/asignar_usuarios', methods=['POST'])
@requiere_ejecutivo
def asignar_usuarios():
    id_grupo = request.form.get('id_grupo_asignar')
    usuarios_seleccionados = request.form.getlist('usuarios_ids')

    if not id_grupo:
        return redirect(url_for('grupos.index'))

    db = get_connection()
    cursor = db.cursor()

    try:
        cursor.execute("SELECT nombre_grupo FROM utrau_grupos WHERE id_grupo=%s", (id_grupo,))
        grupo_actual = cursor.fetchone()
        if grupo_actual and '(Sistema)' in grupo_actual[0]:
            flash('La asignación de estos grupos es automática. No se pueden agregar manualmente.', 'error')
            return redirect(url_for('grupos.index'))

        for u_id in usuarios_seleccionados:
            cursor.execute("INSERT IGNORE INTO utrau_usuarios_grupos (id_usuario, id_grupo) VALUES (%s, %s)", (u_id, id_grupo))
        db.commit()
        flash('Compañeros asignados correctamente al grupo.', 'success')
    except Exception as e:
        db.rollback()
        flash(f'Error al asignar compañeros: {e}', 'error')
    finally:
        cursor.close()
        db.close()

    return redirect(url_for('grupos.index'))

@grupos_bp.route('/quitar_usuario', methods=['POST'])
@requiere_ejecutivo
def quitar_usuario():
    id_grupo = request.form.get('id_grupo')
    id_usuario = request.form.get('id_usuario')

    db = get_connection()
    cursor = db.cursor()

    try:
        cursor.execute("SELECT nombre_grupo FROM utrau_grupos WHERE id_grupo=%s", (id_grupo,))
        grupo_actual = cursor.fetchone()
        if grupo_actual and '(Sistema)' in grupo_actual[0]:
            flash('No podés quitar usuarios de un grupo automático.', 'error')
            return redirect(url_for('grupos.index'))

        cursor.execute("DELETE FROM utrau_usuarios_grupos WHERE id_grupo=%s AND id_usuario=%s", (id_grupo, id_usuario))
        db.commit()
        flash('Compañero desvinculado del grupo.', 'success')
    except Exception as e:
        db.rollback()
        flash('Error al quitar compañero.', 'error')
    finally:
        cursor.close()
        db.close()

    return redirect(url_for('grupos.index'))

@grupos_bp.route('/eliminar', methods=['POST'])
@requiere_ejecutivo
def eliminar_grupo():
    id_grupo = request.form.get('id_grupo')
    
    db = get_connection()
    cursor = db.cursor()
    try:
        cursor.execute("SELECT nombre_grupo FROM utrau_grupos WHERE id_grupo=%s", (id_grupo,))
        grupo_actual = cursor.fetchone()
        if grupo_actual and '(Sistema)' in grupo_actual[0]:
            flash('Los grupos del sistema no se pueden eliminar.', 'error')
            return redirect(url_for('grupos.index'))

        cursor.execute("DELETE FROM utrau_grupos WHERE id_grupo=%s", (id_grupo,))
        db.commit()
        flash('Grupo eliminado con éxito.', 'success')
    except Exception as e:
        db.rollback()
        flash('No se pudo eliminar el grupo.', 'error')
    finally:
        cursor.close()
        db.close()
        
    return redirect(url_for('grupos.index'))