<?php

/**
 * Usuarios.php - Manejo de usuarios
 */

// Incluir modelos necesarios
require_once '../../modelos/Usuario.php';
require_once '../../modelos/Auth.php';

// Función para enviar respuesta JSON (si no está definida)
if (!function_exists('sendResponse')) {
    function sendResponse($success, $message = '', $data = null)
    {
        echo json_encode([
            "success" => $success,
            "message" => $message,
            "data" => $data
        ]);
        exit;
    }
}

// Función para validar token (si no está definida)
if (!function_exists('validateToken')) {
    function validateToken($conn, $authHeader)
    {
        error_log("Validando token en Usuarios.php...");

        if (empty($authHeader)) {
            error_log("Header Authorization vacío");
            return null;
        }

        $token = str_replace('Bearer ', '', $authHeader);
        error_log("Token extraído: " . substr($token, 0, 20) . "...");

        // Usar el modelo Auth para verificar el JWT
        $auth = new Auth($conn);
        $userData = $auth->obtenerUsuarioDeToken($token);

        if ($userData) {
            error_log("Usuario validado: " . $userData['username']);
            return $userData;
        }

        return null;
    }
}

// Verificar autenticación para todas las operaciones
$authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
if (empty($authHeader)) {
    $authHeader = getallheaders()['Authorization'] ?? '';
}

// Validar token
$user = validateToken($conn, $authHeader);
if (!$user) {
    sendResponse(false, "No autorizado " . json_encode($authHeader) . " " . json_encode($user));
}

$usuario = new Usuario($conn);

// === OBTENER TODOS LOS USUARIOS ===
if ($tipo === 'getUsuarios') {
    error_log("=== OBTENIENDO USUARIOS ===");

    // Verificar permisos
    if (!$usuario->verificarPermiso($user['sub'], 'usuarios', 'leer')) {
        sendResponse(false, "Sin permisos para ver usuarios");
    }

    try {
        $usuarios = $usuario->obtenerTodos();
        sendResponse(true, "Usuarios obtenidos", $usuarios);
    } catch (Exception $e) {
        error_log("Error obteniendo usuarios: " . $e->getMessage());
        sendResponse(false, "Error al obtener usuarios");
    }
}

// === OBTENER UN USUARIO ===
if ($tipo === 'getUsuario') {
    error_log("=== OBTENIENDO USUARIO ===");

    $id = isset($datapost['id']) ? $datapost['id'] : null;

    if (!$id) {
        sendResponse(false, "ID de usuario requerido");
    }

    // Verificar permisos
    if (!$usuario->verificarPermiso($user['sub'], 'usuarios', 'leer')) {
        sendResponse(false, "Sin permisos para ver usuarios");
    }

    try {
        $userData = $usuario->obtenerPorId($id);
        if ($userData) {
            // Obtener permisos
            $permisos = $usuario->obtenerPermisos($id);
            $userData['permisos'] = $permisos;
            sendResponse(true, "Usuario obtenido", $userData);
        } else {
            sendResponse(false, "Usuario no encontrado");
        }
    } catch (Exception $e) {
        error_log("Error obteniendo usuario: " . $e->getMessage());
        sendResponse(false, "Error al obtener usuario");
    }
}

// === CREAR USUARIO ===
if ($tipo === 'createUsuario') {
    error_log("=== CREANDO USUARIO ===");

    // Verificar permisos
    if (!$usuario->verificarPermiso($user['sub'], 'usuarios', 'crear')) {
        sendResponse(false, "Sin permisos para crear usuarios");
    }

    // Validar datos requeridos
    $requiredFields = ['username', 'email', 'password', 'nombre', 'apellido'];
    foreach ($requiredFields as $field) {
        if (empty($datapost[$field])) {
            sendResponse(false, "Campo requerido: $field");
        }
    }

    try {
        // Verificar si el username ya existe
        $query = "SELECT COUNT(*) as count FROM usuarios WHERE username = :username";
        $stmt = $conn->prepare($query);
        $stmt->bindParam(':username', $datapost['username']);
        $stmt->execute();
        $result = $stmt->fetch(PDO::FETCH_ASSOC);

        if ($result['count'] > 0) {
            sendResponse(false, "El nombre de usuario ya existe");
        }

        // Verificar si el email ya existe
        $query = "SELECT COUNT(*) as count FROM usuarios WHERE email = :email";
        $stmt = $conn->prepare($query);
        $stmt->bindParam(':email', $datapost['email']);
        $stmt->execute();
        $result = $stmt->fetch(PDO::FETCH_ASSOC);

        if ($result['count'] > 0) {
            sendResponse(false, "El email ya está registrado");
        }

        // Crear usuario
        $userId = $usuario->crear($datapost);

        if ($userId) {
            // Asignar rol si se especificó
            if (!empty($datapost['rol_id'])) {
                $usuario->asignarRol($userId, $datapost['rol_id']);
            }

            sendResponse(true, "Usuario creado exitosamente", ['id' => $userId]);
        } else {
            sendResponse(false, "Error al crear usuario");
        }
    } catch (Exception $e) {
        error_log("Error creando usuario: " . $e->getMessage());
        sendResponse(false, "Error al crear usuario");
    }
}

// === ACTUALIZAR USUARIO ===
if ($tipo === 'updateUsuario') {
    error_log("=== ACTUALIZANDO USUARIO ===");

    $id = isset($datapost['id']) ? $datapost['id'] : null;

    if (!$id) {
        sendResponse(false, "ID de usuario requerido");
    }

    // Verificar permisos
    if (!$usuario->verificarPermiso($user['sub'], 'usuarios', 'actualizar')) {
        sendResponse(false, "Sin permisos para actualizar usuarios");
    }

    try {
        $updateData = [];
        $allowedFields = ['username', 'email', 'nombre', 'apellido', 'telefono', 'activo'];

        foreach ($allowedFields as $field) {
            if (isset($datapost[$field])) {
                $updateData[$field] = $datapost[$field];
            }
        }

        // Si se proporciona nueva contraseña
        if (!empty($datapost['password'])) {
            $updateData['password_hash'] = password_hash($datapost['password'], PASSWORD_BCRYPT);
        }

        if (empty($updateData)) {
            sendResponse(false, "No hay datos para actualizar");
        }

        // Construir query de actualización
        $setClause = [];
        foreach (array_keys($updateData) as $field) {
            $setClause[] = "$field = :$field";
        }

        $query = "UPDATE usuarios SET " . implode(', ', $setClause) . ", updated_at = CURRENT_TIMESTAMP WHERE id = :id";
        $stmt = $conn->prepare($query);

        foreach ($updateData as $field => $value) {
            $stmt->bindValue(":$field", $value);
        }
        $stmt->bindParam(':id', $id);

        if ($stmt->execute()) {
            // Actualizar roles si se especificaron
            if (isset($datapost['roles'])) {
                // Primero eliminar roles actuales
                $deleteQuery = "DELETE FROM usuario_roles WHERE usuario_id = :usuario_id";
                $deleteStmt = $conn->prepare($deleteQuery);
                $deleteStmt->bindParam(':usuario_id', $id);
                $deleteStmt->execute();

                // Asignar nuevos roles
                if (is_array($datapost['roles'])) {
                    foreach ($datapost['roles'] as $rolId) {
                        $usuario->asignarRol($id, $rolId);
                    }
                }
            }

            sendResponse(true, "Usuario actualizado exitosamente");
        } else {
            sendResponse(false, "Error al actualizar usuario");
        }
    } catch (Exception $e) {
        error_log("Error actualizando usuario: " . $e->getMessage());
        sendResponse(false, "Error al actualizar usuario");
    }
}

// === ELIMINAR USUARIO ===
if ($tipo === 'deleteUsuario') {
    error_log("=== ELIMINANDO USUARIO ===");

    $id = isset($datapost['id']) ? $datapost['id'] : null;

    if (!$id) {
        sendResponse(false, "ID de usuario requerido");
    }

    // Verificar permisos
    if (!$usuario->verificarPermiso($user['sub'], 'usuarios', 'eliminar')) {
        sendResponse(false, "Sin permisos para eliminar usuarios");
    }

    // No permitir que un usuario se elimine a sí mismo
    if ($id == $user['sub']) {
        sendResponse(false, "No puedes eliminar tu propia cuenta");
    }

    try {
        // Soft delete - solo marcar como inactivo
        $query = "UPDATE usuarios SET activo = 0, updated_at = CURRENT_TIMESTAMP WHERE id = :id";
        $stmt = $conn->prepare($query);
        $stmt->bindParam(':id', $id);

        if ($stmt->execute()) {
            sendResponse(true, "Usuario eliminado exitosamente");
        } else {
            sendResponse(false, "Error al eliminar usuario");
        }
    } catch (Exception $e) {
        error_log("Error eliminando usuario: " . $e->getMessage());
        sendResponse(false, "Error al eliminar usuario");
    }
}

// === ASIGNAR ROL ===
if ($tipo === 'asignarRol') {
    error_log("=== ASIGNANDO ROL ===");

    $usuarioId = isset($datapost['usuario_id']) ? $datapost['usuario_id'] : null;
    $rolId = isset($datapost['rol_id']) ? $datapost['rol_id'] : null;

    if (!$usuarioId || !$rolId) {
        sendResponse(false, "Usuario y rol requeridos");
    }

    // Verificar permisos
    if (!$usuario->verificarPermiso($user['sub'], 'usuarios', 'actualizar')) {
        sendResponse(false, "Sin permisos para asignar roles");
    }

    try {
        if ($usuario->asignarRol($usuarioId, $rolId)) {
            sendResponse(true, "Rol asignado exitosamente");
        } else {
            sendResponse(false, "Error al asignar rol");
        }
    } catch (Exception $e) {
        error_log("Error asignando rol: " . $e->getMessage());
        sendResponse(false, "Error al asignar rol");
    }
}

// === CAMBIAR ESTADO DE USUARIO ===
if ($tipo === 'toggleUsuarioStatus') {
    error_log("=== CAMBIANDO ESTADO DE USUARIO ===");

    $id = isset($datapost['id']) ? $datapost['id'] : null;

    if (!$id) {
        sendResponse(false, "ID de usuario requerido");
    }

    // Verificar permisos
    if (!$usuario->verificarPermiso($user['sub'], 'usuarios', 'actualizar')) {
        sendResponse(false, "Sin permisos para cambiar estado de usuarios");
    }

    try {
        // Obtener estado actual
        $query = "SELECT activo FROM usuarios WHERE id = :id";
        $stmt = $conn->prepare($query);
        $stmt->bindParam(':id', $id);
        $stmt->execute();
        $currentUser = $stmt->fetch(PDO::FETCH_ASSOC);

        if (!$currentUser) {
            sendResponse(false, "Usuario no encontrado");
        }

        // Cambiar estado
        $nuevoEstado = $currentUser['activo'] ? 0 : 1;
        $query = "UPDATE usuarios SET activo = :activo, updated_at = CURRENT_TIMESTAMP WHERE id = :id";
        $stmt = $conn->prepare($query);
        $stmt->bindParam(':activo', $nuevoEstado);
        $stmt->bindParam(':id', $id);

        if ($stmt->execute()) {
            sendResponse(true, "Estado actualizado", ['activo' => $nuevoEstado]);
        } else {
            sendResponse(false, "Error al cambiar estado");
        }
    } catch (Exception $e) {
        error_log("Error cambiando estado: " . $e->getMessage());
        sendResponse(false, "Error al cambiar estado");
    }
}
