<?php
// Versão do Backend PHP - COMPLETA E CORRIGIDA (Erros de sintaxe removidos + "unonovo" adicionado)

header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: POST, GET, OPTIONS");
header("Access-Control-Allow-Headers: Content-Type");
header("Content-Type: application/json; charset=UTF-8");

// --- DADOS DE CONEXÃO COM O BANCO DE DADOS ---
$db_host = "localhost";
$db_name = "vini_vfsystem";
$db_user = "vini_vfuser";
$db_pass = "5@;NwUBzhhRc"; // 

// --- FUNÇÃO AUXILIAR ---
function getData($conn, $sql) {
    $stmt = $conn->prepare($sql);
    if ($stmt === false) { throw new Exception("Erro na preparação da query: " . $conn->error); }
    $stmt->execute();
    $result = $stmt->get_result();
    $data = [];
    while ($row = $result->fetch_assoc()) { $data[] = $row; }
    $stmt->close();
    return ['status' => 'success', 'data' => $data];
}

// --- CONEXÃO ---
try {
    $conn = new mysqli($db_host, $db_user, $db_pass, $db_name);
    if ($conn->connect_error) { throw new Exception("Erro de Conexão: " . $conn->connect_error); }
    $conn->query("SET time_zone = '-03:00'");
} catch (Exception $e) {
    http_response_code(500);
    echo json_encode(['status' => 'error', 'message' => 'Erro interno no servidor.']);
    exit();
}

$action = isset($_POST['action']) ? $_POST['action'] : (isset($_GET['action']) ? $_GET['action'] : '');
$response = [];

// Lista de veículos (MANUAL - CONFORME SOLICITADO)
// ADICIONADO 'unonovo'
$VEHICLE_TABLE_NAMES = ['montana', 'uno', 'pajero', 'estoquealternativo', 'unonovo'];

try {
    switch ($action) {
        
        // --- AÇÕES DE LEITURA (GET) ---
        case 'USER_LOGIN':
            $loginIdentifier = $_POST['email'] ?? '';
            $password = $_POST['password'] ?? '';
            $stmt = $conn->prepare("SELECT id, nome AS name, email, senha, funcao AS role, primeiro_login FROM usuarios WHERE email = ? OR nome = ?");
            $stmt->bind_param("ss", $loginIdentifier, $loginIdentifier);
            $stmt->execute();
            $result = $stmt->get_result();
            if ($result->num_rows === 1) {
                $user = $result->fetch_assoc();
                if (password_verify($password, $user['senha'])) {
                    unset($user['senha']);
                    $response = ['status' => 'success', 'user' => $user];
                } else {
                    $response = ['status' => 'error', 'message' => 'Login ou senha inválidos.'];
                }
            } else { $response = ['status' => 'error', 'message' => 'Login ou senha inválidos.']; }
            $stmt->close();
            break;
        
        case 'CHECK_EMAIL_EXISTS':
            $email = $_POST['email'] ?? '';
            if (empty($email)) {
                $response = ['status' => 'error', 'message' => 'E-mail não fornecido.'];
                http_response_code(400);
                break;
            }
            $stmt = $conn->prepare("SELECT id FROM usuarios WHERE email = ?");
            $stmt->bind_param("s", $email);
            $stmt->execute();
            $stmt->store_result();
            if ($stmt->num_rows > 0) {
                $response = ['status' => 'success', 'message' => 'Usuário encontrado.'];
            } else {
                $response = ['status' => 'error', 'message' => 'E-mail não cadastrado no sistema.'];
                http_response_code(404);
            }
            $stmt->close();
            break;

        case 'UPDATE_PASSWORD_BY_EMAIL':
            $email = $_POST['email'] ?? '';
            $newPassword = $_POST['newPassword'] ?? '';
            if (empty($email) || empty($newPassword)) {
                $response = ['status' => 'error', 'message' => 'E-mail ou nova senha não fornecidos.'];
                http_response_code(400);
                break;
            }
            $hashed_new_password = password_hash($newPassword, PASSWORD_DEFAULT);
            $stmt = $conn->prepare("UPDATE usuarios SET senha = ?, primeiro_login = 0 WHERE email = ?");
            $stmt->bind_param("ss", $hashed_new_password, $email);
            if ($stmt->execute()) {
                if ($stmt->affected_rows > 0) {
                    $response = ['status' => 'success', 'message' => 'Senha alterada com sucesso!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Nenhum usuário encontrado com este e-mail.'];
                    http_response_code(404);
                }
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao executar a atualização da senha: ' . $stmt->error];
                http_response_code(500);
            }
            $stmt->close();
            break;

        case 'CHANGE_PASSWORD':
            $userId = $_POST['userId'] ?? 0;
            $currentPassword = $_POST['currentPassword'] ?? '';
            $newPassword = $_POST['newPassword'] ?? '';
            $newUsername = $_POST['newUsername'] ?? null;
            $isFirstLogin = !empty($_POST['isFirstLogin']) && filter_var($_POST['isFirstLogin'], FILTER_VALIDATE_BOOLEAN);

            if (empty($newPassword) || strlen($newPassword) < 8) {
                $response = ['status' => 'error', 'message' => 'A nova senha não atende aos requisitos de segurança.'];
                break;
            }

            if ($isFirstLogin) {
                if (empty($newUsername)) {
                    $response = ['status' => 'error', 'message' => 'O novo nome de usuário é obrigatório no primeiro acesso.'];
                    break;
                }
                $hashed_new_password = password_hash($newPassword, PASSWORD_DEFAULT);
                $stmt = $conn->prepare("UPDATE usuarios SET nome = ?, senha = ?, primeiro_login = 0, termos_aceitos_em = NOW() WHERE id = ?");
                $stmt->bind_param("ssi", $newUsername, $hashed_new_password, $userId);
                if ($stmt->execute()) {
                    $response = ['status' => 'success', 'message' => 'Usuário e senha definidos com sucesso!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Erro ao definir usuário e senha: ' . $stmt->error];
                }
                $stmt->close();
            } else {
                $stmt_check = $conn->prepare("SELECT senha FROM usuarios WHERE id = ?");
                $stmt_check->bind_param("i", $userId);
                $stmt_check->execute();
                $result = $stmt_check->get_result();
                if ($result->num_rows === 1) {
                    $user = $result->fetch_assoc();
                    if (password_verify($currentPassword, $user['senha'])) {
                        $hashed_new_password = password_hash($newPassword, PASSWORD_DEFAULT);
                        $stmt_update = $conn->prepare("UPDATE usuarios SET senha = ? WHERE id = ?");
                        $stmt_update->bind_param("si", $hashed_new_password, $userId);
                        if ($stmt_update->execute()) {
                            $response = ['status' => 'success', 'message' => 'Senha alterada com sucesso!'];
                        } else {
                            $response = ['status' => 'error', 'message' => 'Erro ao alterar a senha: ' . $stmt_update->error];
                        }
                        $stmt_update->close();
                    } else {
                        $response = ['status' => 'error', 'message' => 'A senha atual está incorreta.'];
                    }
                } else {
                    $response = ['status' => 'error', 'message' => 'Usuário não encontrado.'];
                }
                $stmt_check->close();
            }
            break;

        case 'GET_USERS':
            $sql = "SELECT id, nome AS name, email, funcao AS role FROM usuarios WHERE funcao != 'Desenvolvedor' ORDER BY nome ASC";
            $response = getData($conn, $sql);
            break;
        case 'GET_PRODUCTS_INFO': $response = getData($conn, "SELECT id, nome, safetyStock FROM produtos ORDER BY nome ASC"); break;
        case 'GET_INVENTORY': $response = getData($conn, "SELECT produto_id as id, produto, endereco, patrimonio FROM inventario_principal ORDER BY produto ASC"); break;
        
        case 'GET_ALL_VEHICLE_INVENTORIES':
            $all_inventories = [];
            foreach ($VEHICLE_TABLE_NAMES as $vehicle_name) { // USA A LISTA ATUALIZADA
                $items_com_patrimonio = [];
                $items_consumiveis = [];

                $table_name = 'inventario_veiculos_' . strtolower($vehicle_name);
                if ($conn->query("SHOW TABLES LIKE '{$table_name}'")->num_rows > 0) {
                    $sql_assets = "SELECT produto_id as id, produto, patrimonio, 1 as quantidade FROM `{$table_name}`";
                    $result_assets = $conn->query($sql_assets);
                    if ($result_assets) {
                        $items_com_patrimonio = $result_assets->fetch_all(MYSQLI_ASSOC);
                    }
                }
                
                $sql_consumables = "
                    SELECT ic.id as id, ic.nome as produto, vc.quantidade 
                    FROM veiculos_consumiveis vc
                    JOIN itens_consumiveis ic ON vc.item_consumivel_id = ic.id
                    WHERE vc.veiculo_nome = ?";
                $stmt = $conn->prepare($sql_consumables);
                $stmt->bind_param("s", $vehicle_name);
                $stmt->execute();
                $result_consumables = $stmt->get_result();
                if ($result_consumables) {
                    $items_consumiveis = $result_consumables->fetch_all(MYSQLI_ASSOC);
                }
                $stmt->close();
                $all_inventories[$vehicle_name] = array_merge($items_com_patrimonio, $items_consumiveis);
            }
            $response = ['status' => 'success', 'data' => $all_inventories];
            break;

        case 'GET_REDIRECT_INVENTORY': $response = getData($conn, "SELECT produto_id as id, produto, patrimonio, removedFrom FROM redirecionamento ORDER BY id ASC"); break;
        case 'GET_RECTIFICATION_ITEMS': $response = getData($conn, "SELECT produto_id as id, produto, patrimonio, removedFrom FROM materiais_retifica ORDER BY id ASC"); break;
        case 'GET_CLIENT_ACTIVITIES': 
            $sql = "SELECT clientId, clientName, userName, patrimonio, reason, DATE_FORMAT(date, '%Y-%m-%dT%H:%i:%S') AS date, tower, sector FROM atividades_cliente ORDER BY date DESC";
            $response = getData($conn, $sql); 
            break;
        case 'GET_CLIENTS': $response = getData($conn, "SELECT id, name, tower, sector, telefone FROM clientes ORDER BY name ASC"); break;
        case 'GET_TRANSACTION_LOGS': $response = getData($conn, "SELECT timestamp, user, action, patrimonio, source, destination FROM logs_transacoes ORDER BY timestamp DESC"); break;
        
        case 'GET_TOWERS':
            try {
                $torres_sql = "SELECT id, nome FROM torres ORDER BY nome ASC";
                $torres_result = $conn->query($torres_sql);
                $torres = $torres_result->fetch_all(MYSQLI_ASSOC);

                $setores_sql = "SELECT id as setor_id, torre_id, nome_setor, limite_clientes FROM setores";
                $setores_result = $conn->query($setores_sql);
                $todos_os_setores = $setores_result->fetch_all(MYSQLI_ASSOC);

                $itens_sql = "SELECT ia.torre_id, ia.setor_id, ia.patrimonio, p.nome as nomeProduto 
                            FROM itens_alocados ia 
                            JOIN produtos p ON ia.produto_id = p.id";
                $itens_result = $conn->query($itens_sql);
                $todos_os_itens = $itens_result->fetch_all(MYSQLI_ASSOC);

                $clientes_sql = "SELECT c.tower, c.sector, COUNT(*) as client_count, GROUP_CONCAT(c.name SEPARATOR ', ') as client_names 
                                FROM clientes c
                                WHERE c.tower IS NOT NULL AND c.sector IS NOT NULL AND c.tower != '' AND c.sector != '' 
                                GROUP BY c.tower, c.sector";
                $conn->query("SET SESSION group_concat_max_len = 1000000;");
                $clientes_result = $conn->query($clientes_sql);
                $contagem_clientes = [];
                while($row = $clientes_result->fetch_assoc()) {
                    $torre_key = strtoupper(str_replace(' ', '', $row['tower']));
                    $setor_key = strtoupper(str_replace(' ', '', $row['sector']));
                    if (!empty($torre_key) && !empty($setor_key)) {
                        $contagem_clientes[$torre_key][$setor_key] = [
                            'count' => $row['client_count'],
                            'names' => $row['client_names']
                        ];
                    }
                }

                foreach ($torres as $key => $torre) {
                    $torre_id = $torre['id'];
                    $torre_nome = $torre['nome'];
                    $setores_da_torre = array_filter($todos_os_setores, function($setor) use ($torre_id) { return $setor['torre_id'] == $torre_id; });

                    $setores_formatados = [];
                    foreach($setores_da_torre as $setor) {
                        $nome_setor_original = $setor['nome_setor'];
                        $torre_key_lookup = strtoupper(str_replace(' ', '', $torre_nome));
                        $setor_key_lookup = strtoupper(str_replace(' ', '', $nome_setor_original));
                        $client_data = $contagem_clientes[$torre_key_lookup][$setor_key_lookup] ?? ['count' => 0, 'names' => ''];
                        
                        $setores_formatados[] = [
                            'id' => $setor['setor_id'], 
                            'nome' => $nome_setor_original, 
                            'clientes' => $client_data['count'], 
                            'client_names' => $client_data['names'],
                            'limite' => (int)$setor['limite_clientes']
                        ];
                    }
                    $torres[$key]['setores'] = $setores_formatados;
                    $itens_da_torre = array_filter($todos_os_itens, function($item) use ($torre_id) { return $item['torre_id'] == $torre_id; });
                    $torres[$key]['itens'] = array_values($itens_da_torre);
                }
                $response = ['status' => 'success', 'data' => $torres];
            } catch (Exception $e) {
                http_response_code(500);
                $response = ['status' => 'error', 'message' => 'Erro no servidor: ' . $e->getMessage()];
            }
            break;

        case 'GET_TOWER_HISTORY':
            $torreId = (int)($_POST['torreId'] ?? 0);
            if ($torreId > 0) {
                $sql = "SELECT data_evento, tipo_evento, descricao, usuario_responsavel 
                        FROM torres_historico 
                        WHERE torre_id = ? 
                        ORDER BY data_evento DESC";
                $stmt = $conn->prepare($sql);
                $stmt->bind_param("i", $torreId);
                $stmt->execute();
                $result = $stmt->get_result();
                $response = ['status' => 'success', 'data' => $result->fetch_all(MYSQLI_ASSOC)];
            } else {
                $response = ['status' => 'error', 'message' => 'ID da torre inválido.'];
            }
            break;
        
        case 'ADD_TOWER_OBSERVATION':
            $torreId = (int)($_POST['torreId'] ?? 0);
            $descricao = trim($_POST['descricao'] ?? '');
            $userName = trim($_POST['userName'] ?? '');
            if ($torreId > 0 && !empty($descricao) && !empty($userName)) {
                $sql = "INSERT INTO torres_historico (torre_id, tipo_evento, descricao, usuario_responsavel) VALUES (?, 'OBSERVACAO', ?, ?)";
                $stmt = $conn->prepare($sql);
                $stmt->bind_param("iss", $torreId, $descricao, $userName);
                if ($stmt->execute()) {
                    $response = ['status' => 'success', 'message' => 'Observação adicionada com sucesso!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Falha ao salvar a observação.'];
                }
            } else {
                $response = ['status' => 'error', 'message' => 'Dados insuficientes para adicionar observação.'];
            }
            break;

        case 'UPDATE_SECTOR_LIMIT':
            $setorId = (int)($_POST['setorId'] ?? 0);
            $novoLimite = (int)($_POST['limite'] ?? 0);
            if ($setorId <= 0 || $novoLimite <= 0) {
                $response = ['status' => 'error', 'message' => 'Dados inválidos para atualizar o limite.'];
                break;
            }
            $stmt = $conn->prepare("UPDATE setores SET limite_clientes = ? WHERE id = ?");
            $stmt->bind_param("ii", $novoLimite, $setorId);
            if ($stmt->execute()) {
                if ($stmt->affected_rows > 0) {
                    $response = ['status' => 'success', 'message' => 'Limite do setor atualizado com sucesso!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Setor não encontrado ou o limite já era o mesmo.'];
                }
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao atualizar o limite: ' . $stmt->error];
            }
            $stmt->close();
            break;

        case 'GET_SECTOR_CLIENT_COUNTS':
            $sql = "SELECT tower, sector, COUNT(*) as client_count 
                    FROM clientes 
                    WHERE tower IS NOT NULL AND tower != '' AND sector IS NOT NULL AND sector != ''
                    GROUP BY tower, sector";
            $result = $conn->query($sql);
            $counts = [];
            while($row = $result->fetch_assoc()) {
                $counts[$row['tower']][$row['sector']] = $row['client_count'];
            }
            $response = ['status' => 'success', 'data' => $counts];
            break;

        case 'GET_CONFIGURACAO':
            $chave = $_POST['chave'] ?? '';
            if (empty($chave)) {
                $response = ['status' => 'error', 'message' => 'Chave de configuração não fornecida.'];
                break;
            }
            $stmt = $conn->prepare("SELECT valor FROM configuracoes WHERE chave = ?");
            $stmt->bind_param("s", $chave);
            $stmt->execute();
            $result = $stmt->get_result();
            if ($row = $result->fetch_assoc()) {
                $response = ['status' => 'success', 'data' => $row];
            } else {
                $response = ['status' => 'success', 'data' => null];
            }
            $stmt->close();
            break;

        case 'GET_VEHICLES': // <-- NOSSO NOVO CASE
            $response = getData($conn, "SELECT id, nome_exibicao, nome_tabela FROM veiculos ORDER BY nome_exibicao ASC");
            break;

        case 'GET_ALL_STOCK_DEFINITIONS':
            try {
                $data = [];
                $produtos_sql = "SELECT id, nome, safetyStock as estoque_minimo, 'produto' as tipo FROM produtos";
                $produtos_result = $conn->query($produtos_sql);
                if ($produtos_result) {
                    while($row = $produtos_result->fetch_assoc()) { $data[] = $row; }
                } else {
                    throw new Exception("Falha na consulta SQL de Produtos: " . $conn->error);
                }

                $consumiveis_sql = "SELECT id, nome, estoque_minimo, 'consumivel' as tipo FROM itens_consumiveis";
                $consumiveis_result = $conn->query($consumiveis_sql);
                if ($consumiveis_result) {
                    while($row = $consumiveis_result->fetch_assoc()) { $data[] = $row; }
                } else {
                    throw new Exception("Falha na consulta SQL de Consumíveis: " . $conn->error);
                }

                usort($data, function($a, $b) { return strcasecmp($a['nome'], $b['nome']); });
                $response = ['status' => 'success', 'data' => $data];
            } catch (Exception $e) {
                http_response_code(500);
                $response = ['status' => 'error', 'message' => $e->getMessage()];
            }
            break;

        case 'UPDATE_CONSUMABLE_SAFETY_STOCK':
            $itemId = (int)($_POST['itemId'] ?? 0);
            $newStockLevel = (int)($_POST['newStockLevel'] ?? 0);
            if ($itemId <= 0 || $newStockLevel < 0) {
                $response = ['status' => 'error', 'message' => 'Dados inválidos.'];
                break;
            }
            $stmt = $conn->prepare("UPDATE itens_consumiveis SET estoque_minimo = ? WHERE id = ?");
            $stmt->bind_param("ii", $newStockLevel, $itemId);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Estoque de segurança do consumível atualizado!'];
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao atualizar: ' . $stmt->error];
            }
            $stmt->close();
            break;

        case 'UPDATE_CONFIGURACAO':
            $chave = $_POST['chave'] ?? '';
            $valor = $_POST['valor'] ?? '';
            if (empty($chave)) {
                $response = ['status' => 'error', 'message' => 'Chave de configuração não fornecida.'];
                break;
            }
            $stmt = $conn->prepare("REPLACE INTO configuracoes (chave, valor) VALUES (?, ?)");
            $stmt->bind_param("ss", $chave, $valor);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Configuração salva com sucesso!'];
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao salvar configuração: ' . $stmt->error];
            }
            $stmt->close();
            break;

        // ******** O ERRO DE SINTAXE (BLOCO DUPLICADO) FOI REMOVIDO DAQUI ********

        // --- AÇÕES DE ESCRITA E MOVIMENTAÇÃO ---
        case 'ADD_INVENTORY_ITEM':
            $conn->begin_transaction();
            try {
                $patrimonio = $_POST['patrimonio'] ?? '';
                $produto_id = $_POST['id'] ?? '';
                $produto_nome = $_POST['produto_nome'] ?? '';
                $mac_address = $_POST['mac_address'] ?? null;

                $stmt_main = $conn->prepare("INSERT INTO inventario_principal (produto_id, produto, endereco, patrimonio, mac_address) VALUES (?, ?, ?, ?, ?)");
                $stmt_main->bind_param("sssss", $produto_id, $produto_nome, $_POST['endereco'], $patrimonio, $mac_address);
                $stmt_main->execute();
                $stmt_main->close();

                $stmt_history = $conn->prepare("INSERT IGNORE INTO patrimonio_historico (patrimonio, produto_id, produto_nome) VALUES (?, ?, ?)");
                $stmt_history->bind_param("sss", $patrimonio, $produto_id, $produto_nome);
                $stmt_history->execute();
                $stmt_history->close();

                $conn->commit();
                $response = ['status' => 'success', 'message' => "Item '{$patrimonio}' cadastrado!"];
            } catch (Exception $e) {
                $conn->rollback();
                if ($conn->errno == 1062) {
                    $response = ['status' => 'error', 'message' => "Patrimônio '{$patrimonio}' já existe."];
                } else {
                    $response = ['status' => 'error', 'message' => 'Erro: ' . $e->getMessage()];
                }
            }
            break;

        case 'ADD_PRODUCT_DEFINITION':
            $stmt = $conn->prepare("INSERT INTO produtos (id, nome, safetyStock) VALUES (?, ?, ?)");
            $stmt->bind_param("ssi", $_POST['id'], $_POST['name'], $_POST['safetyStock']);
            if ($stmt->execute()) { $response = ['status' => 'success', 'message' => 'Definição de produto adicionada.']; } 
            else { $response = ['status' => 'error', 'message' => 'Erro: ' . $stmt->error]; }
            $stmt->close();
            break;
            
        case 'ADD_USER':
            $hashed_password = password_hash($_POST['password'], PASSWORD_DEFAULT);
            $stmt = $conn->prepare("INSERT INTO usuarios (nome, email, senha, funcao, primeiro_login) VALUES (?, ?, ?, ?, ?)");
            $first_login_flag = 1;
            $stmt->bind_param("ssssi", $_POST['name'], $_POST['email'], $hashed_password, $_POST['role'], $first_login_flag);
            if ($stmt->execute()) { 
                $response = ['status' => 'success', 'message' => "Usuário cadastrado!"]; 
            } else { 
                if ($conn->errno == 1062) { 
                    $response = ['status' => 'error', 'message' => "Erro: O e-mail já está cadastrado."]; 
                } else { 
                    $response = ['status' => 'error', 'message' => 'Erro: ' . $stmt->error]; 
                } 
            }
            $stmt->close();
            break;
            
        case 'ADD_CLIENT':
            $stmt = $conn->prepare("INSERT INTO clientes (name, tower, sector, telefone) VALUES (?, ?, ?, ?)");
            $stmt->bind_param("ssss", $_POST['name'], $_POST['tower'], $_POST['sector'], $_POST['telefone']);
            if ($stmt->execute()) { $response = ['status' => 'success', 'message' => "Cliente cadastrado!"]; } 
            else { $response = ['status' => 'error', 'message' => 'Erro: ' . $stmt->error]; }
            $stmt->close();
            break;
            
        case 'ADD_ITEM_TO_VEHICLE':
            $patrimonio = $_POST['patrimonio'] ?? '';
            $receivedVehicleName = $_POST['vehicleName'] ?? ''; // Mantém o nome original para a mensagem de erro

            // Normaliza o nome do veículo: remove espaços e converte para minúsculas
            $normalizedVehicleName = strtolower(str_replace(' ', '', $receivedVehicleName));
            
            // VERIFICA SE O vehicleName NORMALIZADO É VÁLIDO
            if (!in_array($normalizedVehicleName, $VEHICLE_TABLE_NAMES)) {
                // Usa o nome ORIGINAL na mensagem de erro para o usuário
                $response = ['status' => 'error', 'message' => "Veículo de destino '{$receivedVehicleName}' não é válido."];
                break;
            }

            // A partir daqui, use $normalizedVehicleName para construir o nome da tabela
            $stmt_find = $conn->prepare("SELECT produto_id, produto, endereco, patrimonio, mac_address FROM inventario_principal WHERE patrimonio = ?");
            $stmt_find->bind_param("s", $patrimonio);
            $stmt_find->execute();
            $result_find = $stmt_find->get_result();
            if ($result_find->num_rows === 1) {
                $item_data = $result_find->fetch_assoc();
                $stmt_find->close();
                
                // Usa o nome normalizado para o nome da tabela do veículo
                $vehicle_table = 'inventario_veiculos_' . $normalizedVehicleName; 
                
                $stmt_insert = $conn->prepare("INSERT INTO `{$vehicle_table}` (produto_id, produto, endereco, patrimonio, mac_address) VALUES (?, ?, ?, ?, ?)");
                $stmt_insert->bind_param("sssss", $item_data['produto_id'], $item_data['produto'], $item_data['endereco'], $item_data['patrimonio'], $item_data['mac_address']);
                
                if ($stmt_insert->execute()) {
                    $stmt_insert->close();
                    $stmt_delete = $conn->prepare("DELETE FROM inventario_principal WHERE patrimonio = ?");
                    $stmt_delete->bind_param("s", $patrimonio);
                    $stmt_delete->execute();
                    $stmt_delete->close();
                    $response = ['status' => 'success', 'message' => "Item adicionado ao veículo."];
                } else { 
                    $response = ['status' => 'error', 'message' => 'Erro ao adicionar ao veículo: ' . $stmt_insert->error]; 
                }
            } else { 
                $response = ['status' => 'error', 'message' => "Item {$patrimonio} não encontrado no estoque principal."]; 
            }
            break;

        case 'GET_PENDING_FINANCIAL':
            $sql_activities = "SELECT id, clientId, clientName, reason, patrimonio, metragem_cabo, cobrar_cabo, tipo_local, date 
                           FROM atividades_cliente 
                           WHERE status_financeiro = 'Pendente' 
                           ORDER BY date DESC";
            $activities_result = $conn->query($sql_activities);
            $pending_activities = $activities_result->fetch_all(MYSQLI_ASSOC);

            // CORREÇÃO: Traz a lista de veículos da nova tabela
            $vehicle_tables_sql = [];
            foreach ($VEHICLE_TABLE_NAMES as $vehicle_name) {
                $vehicle_tables_sql[] = "SELECT patrimonio, produto, mac_address FROM inventario_veiculos_" . strtolower($vehicle_name);
            }

            // Garante que o array não esteja vazio antes de implodir
            $union_sql = "";
            if (!empty($vehicle_tables_sql)) {
                $union_sql = "UNION ALL " . implode(" UNION ALL ", $vehicle_tables_sql);
            }

            $patrimonio_map_sql = "
                SELECT patrimonio, produto, mac_address FROM inventario_principal
                $union_sql
                UNION ALL SELECT patrimonio, produto, mac_address FROM redirecionamento
                UNION ALL SELECT patrimonio, produto, mac_address FROM materiais_retifica
            ";
            
            $patrimonio_map_result = $conn->query($patrimonio_map_sql);
            $patrimonio_map = [];
            while ($row = $patrimonio_map_result->fetch_assoc()) {
                $patrimonio_map[trim($row['patrimonio'])] = ['produto' => $row['produto'], 'mac_address' => $row['mac_address']];
            }

            $billable_activities = [];
            $reasons_to_bill = ['Instalacao', 'Troca de endereco', 'Venda', 'Retirada'];

            foreach ($pending_activities as $activity) {
                $details = [];
                $is_billable = false;

                if (in_array($activity['reason'], $reasons_to_bill)) { $is_billable = true; }

                if (!empty($activity['metragem_cabo']) && floatval($activity['metragem_cabo']) > 0) {
                    $is_billable = true; 
                    if (!empty($activity['cobrar_cabo']) && $activity['cobrar_cabo'] == 1) {
                        $details[] = "Cabo: " . $activity['metragem_cabo'] . " metros - Cabo Vendido (Cobrar do Cliente)";
                    } else {
                        $details[] = "Cabo - " . $activity['metragem_cabo'] . " metros";
                    }
                }

                if (!empty($activity['patrimonio'])) {
                    $patrimonios = explode(',', $activity['patrimonio']);
                    foreach ($patrimonios as $p_num) {
                        $p_num_trimmed = trim($p_num);
                        if (isset($patrimonio_map[$p_num_trimmed])) {
                            $item_info = $patrimonio_map[$p_num_trimmed];
                            if (stripos($item_info['produto'], 'roteador') !== false) {
                                $detail_string = 'Roteador - ' . $p_num_trimmed;
                                if (!empty($item_info['mac_address'])) { $detail_string .= ", Mac " . $item_info['mac_address']; }
                                $details[] = $detail_string;
                                $is_billable = true;
                            }
                        }
                    }
                }
                
                if (!empty($activity['tipo_local'])) {
                    $details[] = "Local: " . $activity['tipo_local'];
                }

                if ($is_billable) {
                    $activity['details'] = $details;
                    $billable_activities[] = $activity;
                }
            }
            $response = ['status' => 'success', 'data' => $billable_activities];
            break;

        case 'GET_BILLED_ACTIVITIES':
            $sql = "SELECT id, clientName, reason, date, detalhes_faturamento 
                    FROM atividades_cliente 
                    WHERE status_financeiro = 'Faturado' 
                    ORDER BY date DESC";
            $response = getData($conn, $sql);
            break;

        case 'FINALIZE_BILLING':
            $activityId = $_POST['activityId'] ?? 0;
            $billingDetails = $_POST['billingDetails'] ?? null;
            if (empty($activityId) || empty($billingDetails)) {
                $response = ['status' => 'error', 'message' => 'Dados insuficientes para faturar.'];
                http_response_code(400);
                break;
            }
            $stmt = $conn->prepare("UPDATE atividades_cliente SET status_financeiro = 'Faturado', detalhes_faturamento = ? WHERE id = ?");
            $stmt->bind_param("si", $billingDetails, $activityId);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Atividade faturada com sucesso!'];
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao atualizar o banco de dados: ' . $stmt->error];
                http_response_code(500);
            }
            $stmt->close();
            break;

        case 'REMOVE_ITEM_FROM_VEHICLE':
            $patrimonio = $_POST['patrimonio'] ?? '';
            $vehicleName = $_POST['vehicleName'] ?? '';
            
            // VERIFICA SE O vehicleName É VÁLIDO
            if (!in_array(strtolower($vehicleName), $VEHICLE_TABLE_NAMES)) {
                $response = ['status' => 'error', 'message' => "Veículo de origem '{$vehicleName}' não é válido."];
                break;
            }
            
            $vehicle_table = 'inventario_veiculos_' . strtolower($vehicleName);
            $stmt_find = $conn->prepare("SELECT produto_id, produto, endereco, patrimonio, mac_address FROM `{$vehicle_table}` WHERE patrimonio = ?");
            $stmt_find->bind_param("s", $patrimonio);
            $stmt_find->execute();
            $result_find = $stmt_find->get_result();
            if ($result_find->num_rows === 1) {
                $item_data = $result_find->fetch_assoc();
                $stmt_find->close();
                $removedFrom = ucfirst($vehicleName);
                $stmt_insert = $conn->prepare("INSERT INTO redirecionamento (produto_id, produto, patrimonio, removedFrom, mac_address) VALUES (?, ?, ?, ?, ?)");
                $stmt_insert->bind_param("sssss", $item_data['produto_id'], $item_data['produto'], $item_data['patrimonio'], $removedFrom, $item_data['mac_address']);
                if ($stmt_insert->execute()) {
                    $stmt_insert->close();
                    $stmt_delete = $conn->prepare("DELETE FROM `{$vehicle_table}` WHERE patrimonio = ?");
                    $stmt_delete->bind_param("s", $patrimonio);
                    $stmt_delete->execute();
                    $stmt_delete->close();
                    $response = ['status' => 'success', 'message' => "Item retirado e enviado para redirecionamento."];
                } else { $response = ['status' => 'error', 'message' => 'Erro ao mover item: ' . $stmt_insert->error]; }
            } else { $response = ['status' => 'error', 'message' => "Item {$patrimonio} não encontrado no veículo."]; }
            break;

        case 'UPDATE_SAFETY_STOCK':
            $productId = $_POST['productId'] ?? '';
            $newStockLevel = (int)($_POST['newStockLevel'] ?? 0);
            if (empty($productId) || $newStockLevel < 0) {
                $response = ['status' => 'error', 'message' => 'Dados inválidos para atualizar o estoque de segurança.'];
                break;
            }
            $stmt = $conn->prepare("UPDATE produtos SET safetyStock = ? WHERE id = ?");
            $stmt->bind_param("is", $newStockLevel, $productId);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Estoque de segurança atualizado!'];
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao atualizar o estoque de segurança: ' . $stmt->error];
            }
            $stmt->close();
            break;

        case 'ADD_ABASTECIMENTO':
            // VERIFICA SE O vehicleName É VÁLIDO
            $vehicleName = $_POST['veiculoNome'] ?? '';
            if (!in_array(strtolower($vehicleName), $VEHICLE_TABLE_NAMES)) {
                $response = ['status' => 'error', 'message' => "Veículo '{$vehicleName}' não é válido."];
                break;
            }
            $stmt = $conn->prepare("INSERT INTO abastecimentos (veiculo_nome, data_abastecimento, hodometro, litros, valor_total) VALUES (?, ?, ?, ?, ?)");
            $stmt->bind_param("ssidd", $vehicleName, $_POST['data'], $_POST['hodometro'], $_POST['litros'], $_POST['valor']);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Abastecimento registrado com sucesso!'];
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao registrar abastecimento: ' . $stmt->error];
            }
            $stmt->close();
            break;
            
        case 'REMOVE_ITEM_FROM_RECTIFICATION':
            $patrimonio = $_POST['patrimonio'] ?? '';
            if (empty($patrimonio)) {
                $response = ['status' => 'error', 'message' => 'Patrimônio não fornecido.'];
                break;
            }
            $conn->begin_transaction();
            try {
                $stmt_find = $conn->prepare("SELECT produto_id, produto, patrimonio, removedFrom FROM materiais_retifica WHERE patrimonio = ?");
                $stmt_find->bind_param("s", $patrimonio);
                $stmt_find->execute();
                $result_find = $stmt_find->get_result();
                if ($result_find->num_rows === 1) {
                    $item_data = $result_find->fetch_assoc();
                    $stmt_find->close();
                    $stmt_insert = $conn->prepare("INSERT INTO redirecionamento (produto_id, produto, patrimonio, removedFrom) VALUES (?, ?, ?, ?)");
                    $stmt_insert->bind_param("ssss", $item_data['produto_id'], $item_data['produto'], $item_data['patrimonio'], $item_data['removedFrom']);
                    $stmt_insert->execute();
                    $stmt_insert->close();
                    $stmt_delete = $conn->prepare("DELETE FROM materiais_retifica WHERE patrimonio = ?");
                    $stmt_delete->bind_param("s", $patrimonio);
                    $stmt_delete->execute();
                    $stmt_delete->close();
                    $conn->commit();
                    $response = ['status' => 'success', 'message' => 'Item retirado da retífica e enviado para redirecionamento.'];
                } else {
                    throw new Exception("Item com patrimônio {$patrimonio} não encontrado na retífica.");
                }
            } catch (Exception $e) {
                $conn->rollback();
                $response = ['status' => 'error', 'message' => 'Erro no servidor: ' . $e->getMessage()];
                http_response_code(500);
            }
            break; 

        case 'REDIRECT_ITEM':
            $patrimonio = $_POST['patrimonio'] ?? '';
            $destination = $_POST['destination'] ?? '';
            $endereco = $_POST['endereco'] ?? ''; 
            $stmt_find = $conn->prepare("SELECT produto_id, produto, patrimonio FROM redirecionamento WHERE patrimonio = ?");
            $stmt_find->bind_param("s", $patrimonio);
            $stmt_find->execute();
            $result_find = $stmt_find->get_result();
            if ($result_find->num_rows === 1) {
                $item_data = $result_find->fetch_assoc();
                $stmt_find->close();
                
                $destination_table = '';
                if ($destination === 'mainInventory') {
                    $destination_table = 'inventario_principal';
                    if (empty($endereco)) {
                        $response = ['status' => 'error', 'message' => 'O endereço é obrigatório para retornar ao Estoque Principal.'];
                        http_response_code(400);
                        break;
                    }
                } else {
                    // VERIFICA SE O vehicleName É VÁLIDO
                    if (!in_array(strtolower($destination), $VEHICLE_TABLE_NAMES)) {
                        $response = ['status' => 'error', 'message' => "Veículo de destino '{$destination}' não é válido."];
                        break;
                    }
                    $destination_table = 'inventario_veiculos_' . strtolower($destination);
                }
                
                $stmt_insert = $conn->prepare("INSERT INTO `{$destination_table}` (produto_id, produto, endereco, patrimonio) VALUES (?, ?, ?, ?)");
                $stmt_insert->bind_param("ssss", $item_data['produto_id'], $item_data['produto'], $endereco, $item_data['patrimonio']);
                
                if ($stmt_insert->execute()) {
                    $stmt_insert->close();
                    $stmt_delete = $conn->prepare("DELETE FROM redirecionamento WHERE patrimonio = ?");
                    $stmt_delete->bind_param("s", $patrimonio);
                    $stmt_delete->execute();
                    $stmt_delete->close();
                    $response = ['status' => 'success', 'message' => "Item redirecionado com sucesso."];
                } else { 
                    $response = ['status' => 'error', 'message' => 'Erro ao inserir no destino: ' . $stmt_insert->error]; 
                }
            } else { 
                $response = ['status' => 'error', 'message' => "Item {$patrimonio} não encontrado para redirecionamento."]; 
            }
            break;

        case 'ADD_ITEM_TO_RECTIFICATION':
            $patrimonio = $_POST['patrimonio'] ?? '';
            $stmt_find = $conn->prepare("SELECT produto_id, produto, patrimonio, removedFrom FROM redirecionamento WHERE patrimonio = ?");
            $stmt_find->bind_param("s", $patrimonio);
            $stmt_find->execute();
            $result_find = $stmt_find->get_result();
            if ($result_find->num_rows === 1) {
                $item_data = $result_find->fetch_assoc();
                $stmt_find->close();
                $stmt_insert = $conn->prepare("INSERT INTO materiais_retifica (produto_id, produto, patrimonio, removedFrom) VALUES (?, ?, ?, ?)");
                $stmt_insert->bind_param("ssss", $item_data['produto_id'], $item_data['produto'], $item_data['patrimonio'], $item_data['removedFrom']);
                if ($stmt_insert->execute()) {
                    $stmt_insert->close();
                    $stmt_delete = $conn->prepare("DELETE FROM redirecionamento WHERE patrimonio = ?");
                    $stmt_delete->bind_param("s", $patrimonio);
                    $stmt_delete->execute();
                    $stmt_delete->close();
                    $response = ['status' => 'success', 'message' => "Item enviado para retífica."];
                } else { $response = ['status' => 'error', 'message' => 'Erro ao enviar para retífica: ' . $stmt_insert->error]; }
            } else { $response = ['status' => 'error', 'message' => "Item {$patrimonio} não encontrado para retífica."]; }
            break;
        
        case 'ADD_CLIENT_ACTIVITY':
            $conn->begin_transaction();
            try {
                $clientId = $_POST['clientId'] ?? 0;
                $clientName = $_POST['clientName'] ?? '';
                $userName = $_POST['userName'] ?? '';
                $patrimonio_string = $_POST['patrimonio'] ?? '';
                $reason = $_POST['reason'] ?? '';
                $tower = $_POST['tower'] ?? '';
                $sector = $_POST['sector'] ?? '';
                $consumablesJSON = $_POST['consumables'] ?? '[]';
                $vehicleName = $_POST['vehicleName'] ?? '';
                $metragem_cabo = (float)($_POST['metragem_cabo'] ?? 0);
                $cobrar_cabo = isset($_POST['cobrar_cabo']) ? 1 : 0;
                $tipo_local = $_POST['tipo_local'] ?? null;

                $stmt_activity = $conn->prepare("INSERT INTO atividades_cliente (clientId, clientName, userName, patrimonio, reason, date, tower, sector, consumiveis_usados, metragem_cabo, cobrar_cabo, tipo_local) VALUES (?, ?, ?, ?, ?, NOW(), ?, ?, ?, ?, ?, ?)");
                $stmt_activity->bind_param("isssssssdis", $clientId, $clientName, $userName, $patrimonio_string, $reason, $tower, $sector, $consumablesJSON, $metragem_cabo, $cobrar_cabo, $tipo_local);
                $stmt_activity->execute();
                $stmt_activity->close();
                
                if (!empty($patrimonio_string) && !empty($vehicleName)) {
                    // VERIFICA SE O vehicleName É VÁLIDO
                    if (!in_array(strtolower($vehicleName), $VEHICLE_TABLE_NAMES)) {
                        throw new Exception("Veículo '{$vehicleName}' não é válido para debitar estoque.");
                    }
                    $patrimonios = array_map('trim', explode(',', $patrimonio_string));
                    $vehicle_table = 'inventario_veiculos_' . strtolower($vehicleName);
                    
                    $stmt_find = $conn->prepare("SELECT produto_id, produto, mac_address FROM `{$vehicle_table}` WHERE patrimonio = ?");
                    $stmt_insert_redirect = $conn->prepare("INSERT INTO redirecionamento (produto_id, produto, patrimonio, mac_address, removedFrom) VALUES (?, ?, ?, ?, ?)");
                    $stmt_delete_vehicle = $conn->prepare("DELETE FROM `{$vehicle_table}` WHERE patrimonio = ?");

                    foreach ($patrimonios as $p) {
                        if (empty($p)) continue;
                        $stmt_find->bind_param("s", $p);
                        $stmt_find->execute();
                        $item_result = $stmt_find->get_result();
                        if ($item_data = $item_result->fetch_assoc()) {
                            $removedFrom = "Cliente: " . $clientName;
                            $stmt_insert_redirect->bind_param("sssss", $item_data['produto_id'], $item_data['produto'], $p, $item_data['mac_address'], $removedFrom);
                            $stmt_insert_redirect->execute();
                            $stmt_delete_vehicle->bind_param("s", $p);
                            $stmt_delete_vehicle->execute();
                        }
                    }
                    $stmt_find->close();
                    $stmt_insert_redirect->close();
                    $stmt_delete_vehicle->close();
                }

                $consumables = json_decode($consumablesJSON, true);
                if (!empty($consumables) && !empty($vehicleName)) {
                    // VERIFICA SE O vehicleName É VÁLIDO
                    if (!in_array(strtolower($vehicleName), $VEHICLE_TABLE_NAMES)) {
                        throw new Exception("Veículo '{$vehicleName}' não é válido para debitar consumíveis.");
                    }
                    $stmt_decr_consumable = $conn->prepare("UPDATE veiculos_consumiveis SET quantidade = quantidade - ? WHERE veiculo_nome = ? AND item_consumivel_id = ? AND quantidade >= ?");
                    foreach ($consumables as $item) {
                        $quantidadeUsada = (int)($item['quantidade'] ?? 0);
                        $itemId = (int)($item['id'] ?? 0);
                        if ($quantidadeUsada > 0 && $itemId > 0) {
                            $stmt_decr_consumable->bind_param("isii", $quantidadeUsada, $vehicleName, $itemId, $quantidadeUsada);
                            $stmt_decr_consumable->execute();
                            if ($stmt_decr_consumable->affected_rows === 0) {
                                throw new Exception("Estoque do consumível (ID: {$itemId}) insuficiente no veículo '{$vehicleName}'.");
                            }
                        }
                    }
                    $stmt_decr_consumable->close();
                }

                $conn->commit();
                $response = ['status' => 'success', 'message' => 'Atividade registrada e estoque debitado com sucesso!'];

            } catch (Exception $e) {
                $conn->rollback();
                $response = ['status' => 'error', 'message' => 'Erro no servidor: ' . $e->getMessage()];
                http_response_code(500);
            }
            break;

        case 'LOG_TRANSACTION':
            $log_user_name = $_POST['user'] ?? '';
            if ($log_user_name === 'VF_Soluções' || $log_user_name === 'DEV_Master') {
                $response = ['status' => 'success', 'message' => 'Log not recorded for Dev user.'];
                break;
            }
            $log_action = $_POST['action_log'] ?? 'N/A';
            $log_patrimonio = $_POST['patrimonio'] ?? 'N/A';
            $log_source = $_POST['source'] ?? 'N/A';
            $log_destination = $_POST['destination'] ?? 'N/A';
            $stmt = $conn->prepare("INSERT INTO logs_transacoes (user, action, patrimonio, source, destination) VALUES (?, ?, ?, ?, ?)");
            $stmt->bind_param("sssss", $log_user_name, $log_action, $log_patrimonio, $log_source, $log_destination);
            if ($stmt->execute()) {
                $response = ['status' => 'success'];
            } else {
                $response = ['status' => 'error', 'message' => 'Falha ao registrar log.'];
            }
            $stmt->close();
            break;

        // --- AÇÕES DO MÓDULO DE CONSUMO ---
        case 'GET_ITENS_CONSUMIVEIS':
            if (isset($_POST['userRole']) && $_POST['userRole'] === 'Desenvolvedor') {
                $response = ['status' => 'success', 'data' => ['total' => 0]]; 
                break;
            }
            $response = getData($conn, "SELECT id, nome, unidade, quantidadeEstoque, estoque_minimo FROM itens_consumiveis ORDER BY nome ASC");
            break;
            
        case 'ADD_ITEM_CONSUMIVEL':
            $nome = $_POST['nome'] ?? '';
            $unidade = $_POST['unidade'] ?? '';
            $quantidade = (int)($_POST['quantidadeEstoque'] ?? 0);
            
            if (empty($nome) || empty($unidade)) {
                $response = ['status' => 'error', 'message' => 'Nome e Unidade são campos obrigatórios.'];
                http_response_code(400);
                break;
            }
            $stmt = $conn->prepare("INSERT INTO itens_consumiveis (nome, unidade, quantidadeEstoque) VALUES (?, ?, ?)");
            $stmt->bind_param("ssi", $nome, $unidade, $quantidade);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Item de consumo cadastrado com sucesso!'];
            } else {
                if ($conn->errno == 1062) {
                    $response = ['status' => 'error', 'message' => "Erro: O item '{$nome}' já existe."];
                } else {
                    $response = ['status' => 'error', 'message' => 'Erro ao cadastrar item: ' . $stmt->error];
                }
            }
            $stmt->close();
            break; 
            
        case 'RECARREGAR_ITEM_CONSUMIVEL':
            $itemId = (int)($_POST['itemId'] ?? 0);
            $quantidadeAdicionada = (int)($_POST['quantidadeAdicionada'] ?? 0);
            if ($itemId <= 0 || $quantidadeAdicionada <= 0) {
                $response = ['status' => 'error', 'message' => 'ID do item e quantidade devem ser válidos e maiores que zero.'];
                http_response_code(400);
                break;
            }
            $stmt = $conn->prepare("UPDATE itens_consumiveis SET quantidadeEstoque = quantidadeEstoque + ? WHERE id = ?");
            $stmt->bind_param("ii", $quantidadeAdicionada, $itemId);
            if ($stmt->execute()) {
                if ($stmt->affected_rows > 0) {
                    $response = ['status' => 'success', 'message' => 'Estoque recarregado com sucesso!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Item não encontrado para recarregar. Verifique o ID.'];
                }
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao recarregar estoque: ' . $stmt->error];
            }
            $stmt->close();
            break;
            
        case 'REGISTRAR_CONSUMO':
            if (isset($_POST['userRole']) && $_POST['userRole'] === 'Desenvolvedor') {
                $response = ['status' => 'success', 'data' => ['total' => 0]]; 
                break;
            }
            $itemId = (int)($_POST['itemId'] ?? 0);
            $quantidadeConsumida = (int)($_POST['quantidadeConsumida'] ?? 0);
            $usuarioId = (int)($_POST['usuarioId'] ?? 0);
            $conn->begin_transaction();
            $stmt_get = $conn->prepare("SELECT nome, quantidadeEstoque FROM itens_consumiveis WHERE id = ? FOR UPDATE");
            $stmt_get->bind_param("i", $itemId);
            $stmt_get->execute();
            $result_item = $stmt_get->get_result();
            if($result_item->num_rows === 1) {
                $item = $result_item->fetch_assoc();
                $stmt_get->close();
                if ($item['quantidadeEstoque'] >= $quantidadeConsumida) {
                    $novoEstoque = $item['quantidadeEstoque'] - $quantidadeConsumida;
                    $stmt_update = $conn->prepare("UPDATE itens_consumiveis SET quantidadeEstoque = ? WHERE id = ?");
                    $stmt_update->bind_param("ii", $novoEstoque, $itemId);
                    $update_success = $stmt_update->execute();
                    $stmt_update->close();
                    
                    $stmt_user = $conn->prepare("SELECT nome FROM usuarios WHERE id = ?");
                    $stmt_user->bind_param("i", $usuarioId);
                    $stmt_user->execute();
                    $usuarioNome = $stmt_user->get_result()->fetch_assoc()['nome'] ?? 'Desconhecido';
                    $stmt_user->close();

                    $stmt_log = $conn->prepare("INSERT INTO historico_consumo (item_id, item_nome, quantidade_consumida, usuario_id, usuario_nome) VALUES (?, ?, ?, ?, ?)");
                    $stmt_log->bind_param("isiss", $itemId, $item['nome'], $quantidadeConsumida, $usuarioId, $usuarioNome);
                    $log_success = $stmt_log->execute();
                    $stmt_log->close();
                    
                    if($update_success && $log_success) {
                        $conn->commit();
                        $response = ['status' => 'success', 'message' => 'Consumo registrado com sucesso!'];
                    } else {
                        $conn->rollback();
                        $response = ['status' => 'error', 'message' => 'Falha ao registrar o consumo. Tente novamente.'];
                    }
                } else {
                    $conn->rollback();
                    $response = ['status' => 'error', 'message' => 'Quantidade insuficiente em estoque.'];
                }
            } else {
                $conn->rollback();
                $response = ['status' => 'error', 'message' => 'Item consumível não encontrado.'];
            }
            break;

        case 'TRANSFER_CONSUMABLE_TO_VEHICLE':
            $itemId = (int)($_POST['itemId'] ?? 0);
            $receivedVehicleName = $_POST['vehicleName'] ?? ''; // O nome como veio do front-end
            $quantity = (int)($_POST['quantity'] ?? 0);

            if (empty($itemId) || empty($receivedVehicleName) || empty($quantity) || $quantity <= 0) {
                $response = ['status' => 'error', 'message' => 'Dados inválidos para a transferência.'];
                http_response_code(400);
                break;
            }

            // Normaliza o nome do veículo para a validação e nome da tabela
            $normalizedVehicleName = strtolower(str_replace(' ', '', $receivedVehicleName));

            // VERIFICA SE O vehicleName NORMALIZADO É VÁLIDO
            if (!in_array($normalizedVehicleName, $VEHICLE_TABLE_NAMES)) {
                $response = ['status' => 'error', 'message' => "Veículo '{$receivedVehicleName}' não é válido."];
                break;
            }

            $conn->begin_transaction();
            try {
                $stmt_decr = $conn->prepare("UPDATE itens_consumiveis SET quantidadeEstoque = quantidadeEstoque - ? WHERE id = ? AND quantidadeEstoque >= ?");
                $stmt_decr->bind_param("iii", $quantity, $itemId, $quantity);
                $stmt_decr->execute();
                if ($stmt_decr->affected_rows === 0) {
                    throw new Exception("Estoque geral insuficiente ou item não encontrado.");
                }
                $stmt_decr->close();

                // Para a tabela `veiculos_consumiveis`, usamos o nome original ($receivedVehicleName)
                // Se a coluna veiculo_nome nessa tabela espera o nome normalizado, mude para $normalizedVehicleName
                // Assumo que você quer o nome legível no histórico de abastecimento/consumíveis do veículo.
                $stmt_upsert = $conn->prepare("INSERT INTO veiculos_consumiveis (veiculo_nome, item_consumivel_id, quantidade) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE quantidade = quantidade + VALUES(quantidade)");
                $stmt_upsert->bind_param("sii", $receivedVehicleName, $itemId, $quantity);
                if (!$stmt_upsert->execute()) {
                    throw new Exception("Erro ao creditar no veículo: " . $stmt_upsert->error);
                }
                $stmt_upsert->close();

                $conn->commit();
                $response = ['status' => 'success', 'message' => 'Transferência realizada com sucesso!'];
            } catch (Exception $e) {
                $conn->rollback();
                $response = ['status' => 'error', 'message' => 'Erro na transferência: ' . $e->getMessage()];
                http_response_code(500);
            }
            break;  
            
        case 'GET_HISTORICO_CONSUMO':
            if (isset($_POST['userRole']) && $_POST['userRole'] === 'Desenvolvedor') {
                $response = ['status' => 'success', 'data' => ['total' => 0]]; 
                break;
            }
            $month = isset($_POST['month']) ? (int)$_POST['month'] : date('m');
            $year = isset($_POST['year']) ? (int)$_POST['year'] : date('Y');
            $sql = "SELECT id, item_nome, quantidade_consumida, usuario_nome, DATE_FORMAT(data_consumo, '%d/%m/%Y') as data_consumo_formatada, data_consumo FROM historico_consumo WHERE MONTH(data_consumo) = ? AND YEAR(data_consumo) = ? ORDER BY data_consumo DESC";
            $stmt = $conn->prepare($sql);
            $stmt->bind_param("ii", $month, $year);
            $stmt->execute();
            $result = $stmt->get_result();
            $data = [];
            while ($row = $result->fetch_assoc()) { $data[] = $row; }
            $stmt->close();
            $response = ['status' => 'success', 'data' => $data];
            break;
            
        case 'GET_CONSUMPTION_LOG_COUNT':
            if (isset($_POST['userRole']) && $_POST['userRole'] === 'Desenvolvedor') {
                $response = ['status' => 'success', 'data' => ['total' => 0]]; 
                break;
            }
            $sql = "SELECT COUNT(*) as total FROM historico_consumo WHERE MONTH(data_consumo) = MONTH(CURDATE()) AND YEAR(data_consumo) = YEAR(CURDATE())";
            $result = $conn->query($sql);
            $data = $result->fetch_assoc();
            $response = ['status' => 'success', 'data' => $data];
            break;

        // --- AÇÕES DO MÓDULO DE COMBUSTÍVEL ---
        case 'GET_HISTORICO_COMBUSTIVEL':
            if (isset($_POST['userRole']) && $_POST['userRole'] === 'Desenvolvedor') {
                $response = ['status' => 'success', 'data' => ['total' => 0]]; 
                break;
            }
            $response = getData($conn, "SELECT id, veiculo_id, veiculo_nome, data_abastecimento, DATE_FORMAT(data_abastecimento, '%d/%m/%Y') as data_formatada, hodometro, litros, valor_total FROM abastecimentos ORDER BY data_abastecimento DESC, id DESC");
            break; 
            
        case 'GET_MONTHLY_FUEL_REPORT':
            $month = isset($_POST['month']) ? (int)$_POST['month'] : date('m');
            $year = isset($_POST['year']) ? (int)$_POST['year'] : date('Y');
            $sql = "SELECT id, veiculo_nome, data_abastecimento, hodometro, litros, valor_total FROM abastecimentos WHERE MONTH(data_abastecimento) = ? AND YEAR(data_abastecimento) = ? ORDER BY data_abastecimento DESC";
            $stmt = $conn->prepare($sql);
            $stmt->bind_param("ii", $month, $year);
            $stmt->execute();
            $result = $stmt->get_result();
            $data = [];
            while ($row = $result->fetch_assoc()) { $data[] = $row; }
            $stmt->close();
            $response = ['status' => 'success', 'data' => $data];
            break; 
            
        // --- NOVAS AÇÕES DO MÓDULO DE TORRES ---
        case 'GET_TORRES_DATA': // Esta função parece ser um GERAL, mantida por enquanto
            $torres_sql = "SELECT id, nome FROM torres ORDER BY nome ASC";
            $torres_result = getData($conn, $torres_sql);
            $setores_sql = "SELECT torre_id, nome_setor FROM setores";
            $setores_result = getData($conn, $setores_sql);
            $itens_sql = "SELECT torre_id, produto_id, patrimonio FROM itens_alocados";
            $itens_result = getData($conn, $itens_sql);
            $torres_data = $torres_result['data'];
            foreach ($torres_data as $key => $torre) {
                $torre_id = $torre['id'];
                $setores_filtrados = array_filter($setores_result['data'], function($s) use ($torre_id) { return $s['torre_id'] == $torre_id; });
                $torres_data[$key]['setores'] = array_column($setores_filtrados, 'nome_setor');
                $itens_filtrados = array_filter($itens_result['data'], function($i) use ($torre_id) { return $i['torre_id'] == $torre_id; });
                $torres_data[$key]['itens'] = array_values($itens_filtrados);
            }
            $response = ['status' => 'success', 'data' => $torres_data];
            break;

        case 'ADD_TORRE':
            $conn->begin_transaction();
            try {
                $nome_torre = $_POST['nome'] ?? '';
                $setores = isset($_POST['setores']) ? json_decode($_POST['setores'], true) : [];
                $stmt_torre = $conn->prepare("INSERT INTO torres (nome) VALUES (?)");
                $stmt_torre->bind_param("s", $nome_torre);
                $stmt_torre->execute();
                $torre_id = $conn->insert_id;
                $stmt_torre->close();
                if (!empty($setores) && $torre_id > 0) {
                    $stmt_setor = $conn->prepare("INSERT INTO setores (torre_id, nome_setor) VALUES (?, ?)");
                    foreach($setores as $setor) {
                        $stmt_setor->bind_param("is", $torre_id, $setor);
                        $stmt_setor->execute();
                    }
                    $stmt_setor->close();
                }
                $conn->commit();
                $response = ['status' => 'success', 'message' => 'Torre e setores cadastrados com sucesso!'];
            } catch (Exception $ex) {
                $conn->rollback();
                $response = ['status' => 'error', 'message' => 'Erro ao cadastrar a torre: ' . $ex->getMessage()];
            }
            break;
            case 'ALOCAR_ITEM_TORRE':
            $conn->begin_transaction();
            try {
                $torre_id = (int)($_POST['torreId'] ?? 0);
                $setor_id = !empty($_POST['setorId']) ? (int)$_POST['setorId'] : null;
                $patrimonios = isset($_POST['patrimonios']) ? json_decode($_POST['patrimonios'], true) : [];
                if ($torre_id <= 0 || empty($patrimonios)) {
                    throw new Exception("Dados insuficientes para alocação.");
                }
                $stmt_find = $conn->prepare("SELECT produto_id, produto FROM inventario_principal WHERE patrimonio = ? FOR UPDATE");
                $stmt_insert = $conn->prepare("INSERT INTO itens_alocados (torre_id, setor_id, produto_id, patrimonio) VALUES (?, ?, ?, ?)");
                $stmt_delete = $conn->prepare("DELETE FROM inventario_principal WHERE patrimonio = ?");
                foreach ($patrimonios as $p) {
                    $stmt_find->bind_param("s", $p);
                    $stmt_find->execute();
                    $result_find = $stmt_find->get_result();
                    if ($item_data = $result_find->fetch_assoc()) {
                        $stmt_insert->bind_param("iiis", $torre_id, $setor_id, $item_data['produto_id'], $p);
                        if (!$stmt_insert->execute()) {
                            throw new Exception("Erro ao alocar o item {$p}: " . $stmt_insert->error);
                        }
                        $stmt_delete->bind_param("s", $p);
                        if (!$stmt_delete->execute()) {
                            throw new Exception("Erro ao remover o item {$p} do estoque: " . $stmt_delete->error);
                        }
                    } else {
                        throw new Exception("Item com patrimônio {$p} não encontrado no estoque principal.");
                    }
                }
                $stmt_find->close();
                $stmt_insert->close();
                $stmt_delete->close();
                $conn->commit();
                $response = ['status' => 'success', 'message' => count($patrimonios) . ' item(s) alocado(s) com sucesso!'];
            } catch (Exception $e) {
                $conn->rollback();
                $response = ['status' => 'error', 'message' => 'Erro no servidor: ' . $e->getMessage()];
                http_response_code(500);
            }
            break;

        case 'RETIRAR_ITEM_TORRE':
            $conn->begin_transaction();
            try {
                $patrimonios = isset($_POST['patrimonios']) ? json_decode($_POST['patrimonios'], true) : [];
                if (empty($patrimonios)) {
                    throw new Exception("Nenhum item selecionado para retirada.");
                }
                $stmt_find = $conn->prepare("SELECT produto_id, patrimonio FROM itens_alocados WHERE patrimonio = ?");
                $stmt_insert = $conn->prepare("INSERT INTO redirecionamento (produto_id, patrimonio, removedFrom) VALUES (?, ?, 'Torre')");
                $stmt_delete = $conn->prepare("DELETE FROM itens_alocados WHERE patrimonio = ?");
                foreach ($patrimonios as $p) {
                    $stmt_find->bind_param("s", $p);
                    $stmt_find->execute();
                    $result_find = $stmt_find->get_result();
                    if ($item_data = $result_find->fetch_assoc()) {
                        $stmt_insert->bind_param("is", $item_data['produto_id'], $item_data['patrimonio']);
                        if (!$stmt_insert->execute()) {
                            throw new Exception("Erro ao mover o item {$p} para redirecionamento.");
                        }
                        $stmt_delete->bind_param("s", $p);
                        if (!$stmt_delete->execute()) {
                            throw new Exception("Erro ao deletar o item {$p} da torre.");
                        }
                    } else {
                        throw new Exception("Item com patrimônio {$p} não encontrado na torre.");
                    }
                }
                $stmt_find->close();
                $stmt_insert->close();
                $stmt_delete->close();
                $conn->commit();
                $response = ['status' => 'success', 'message' => count($patrimonios) . ' item(s) retirado(s) com sucesso!'];
            } catch (Exception $e) {
                $conn->rollback();
                $response = ['status' => 'error', 'message' => 'Erro no servidor: ' . $e->getMessage()];
                http_response_code(500);
            }
            break;
            
        case 'GET_PRODUCTS_SUMMARY':
            $sql = "SELECT p.id AS id, p.nome AS nome, p.safetyStock AS safetyStock, (SELECT COUNT(*) FROM inventario_principal ip WHERE ip.produto_id = p.id) AS quantidadeTotal FROM produtos p ORDER BY p.nome ASC";
            $response = getData($conn, $sql);
            break;
            
        case 'GET_CLIENT_ACTIVITY_DETAILS':
            $clients_sql = "SELECT id, name, tower, sector, telefone FROM clientes ORDER BY name ASC";
            $clients_result = $conn->query($clients_sql);
            $all_clients = $clients_result->fetch_all(MYSQLI_ASSOC);

            $activities_sql = "SELECT * FROM atividades_cliente ORDER BY date DESC";
            $activities_result = $conn->query($activities_sql);
            $all_activities = $activities_result->fetch_all(MYSQLI_ASSOC);

            // CORREÇÃO: Traz a lista de veículos da nova tabela
            $vehicle_tables_sql = [];
            foreach ($VEHICLE_TABLE_NAMES as $vehicle_name) {
                $vehicle_tables_sql[] = "SELECT patrimonio, produto, mac_address FROM inventario_veiculos_" . strtolower($vehicle_name);
            }

            // Garante que o array não esteja vazio antes de implodir
            $union_sql = "";
            if (!empty($vehicle_tables_sql)) {
                $union_sql = "UNION ALL " . implode(" UNION ALL ", $vehicle_tables_sql);
            }

            $patrimonio_map_sql = "
                SELECT patrimonio, produto_nome as produto, mac_address FROM patrimonio_historico
                UNION SELECT patrimonio, produto, mac_address FROM inventario_principal
                $union_sql
                UNION SELECT patrimonio, produto, mac_address FROM redirecionamento
                UNION SELECT patrimonio, produto, NULL AS mac_address FROM materiais_retifica
                UNION SELECT ia.patrimonio, p.nome as produto, NULL AS mac_address 
                      FROM itens_alocados ia 
                      JOIN produtos p ON ia.produto_id = p.id
            ";
            $patrimonio_map_result = $conn->query($patrimonio_map_sql);
            $patrimonio_map = [];
            while ($row = $patrimonio_map_result->fetch_assoc()) {
                $patrimonio_map[trim($row['patrimonio'])] = ['produto' => $row['produto'], 'mac_address' => $row['mac_address']];
            }
            
            $consumables_map_sql = "SELECT id, nome FROM itens_consumiveis";
            $consumables_map_result = $conn->query($consumables_map_sql);
            $consumables_map = [];
            while($row = $consumables_map_result->fetch_assoc()){
                $consumables_map[$row['id']] = $row['nome'];
            }

            foreach ($all_clients as $key => $client) {
                $client_id = $client['id'];
                $client_activities = array_filter($all_activities, function($activity) use ($client_id) {
                    return $activity['clientId'] == $client_id;
                });

                foreach ($client_activities as $activity_key => $activity) {
                    $patrimonios_details = [];
                    if (!empty($activity['patrimonio'])) {
                        $patrimonio_array = explode(',', $activity['patrimonio']);
                        foreach ($patrimonio_array as $p_num) {
                            $p_num_trimmed = trim($p_num);
                            if (!empty($p_num_trimmed)) {
                                $patrimonios_details[] = [
                                    'patrimonio' => $p_num_trimmed,
                                    'productName' => $patrimonio_map[$p_num_trimmed]['produto'] ?? 'Item não localizado',
                                    'macAddress' => $patrimonio_map[$p_num_trimmed]['mac_address'] ?? null
                                ];
                            }
                        }
                    }
                    $client_activities[$activity_key]['patrimonios_details'] = $patrimonios_details;
                    
                    $consumiveis_details = [];
                    if (!empty($activity['consumiveis_usados']) && $activity['consumiveis_usados'] !== '[]') {
                        $consumiveis_array = json_decode($activity['consumiveis_usados'], true);
                        if (is_array($consumiveis_array)) {
                            foreach ($consumiveis_array as $item) {
                                $consumiveis_details[] = [
                                    'productName' => $consumables_map[$item['id']] ?? 'Consumível desconhecido',
                                    'quantidade' => $item['quantidade']
                                ];
                            }
                        }
                    }
                    $client_activities[$activity_key]['consumiveis_details'] = $consumiveis_details;
                    $client_activities[$activity_key]['metragem_cabo'] = (float)($activity['metragem_cabo'] ?? 0);
                }
                $all_clients[$key]['activities'] = array_values($client_activities);
            }
            $response = ['status' => 'success', 'data' => $all_clients];
            break;

        case 'ADD_SECTOR_TO_TOWER':
            $torreId = (int)($_POST['torreId'] ?? 0);
            $novoSetorNome = trim($_POST['novoSetorNome'] ?? '');
            if (empty($torreId) || empty($novoSetorNome)) {
                $response = ['status' => 'error', 'message' => 'ID da torre e nome do setor são obrigatórios.'];
                http_response_code(400);
                break;
            }
            $check_stmt = $conn->prepare("SELECT id FROM setores WHERE torre_id = ? AND nome_setor = ?");
            $check_stmt->bind_param("is", $torreId, $novoSetorNome);
            $check_stmt->execute();
            if ($check_stmt->get_result()->num_rows > 0) {
                $response = ['status' => 'error', 'message' => "O setor '{$novoSetorNome}' já existe nesta torre."];
                $check_stmt->close();
                break;
            }
            $check_stmt->close();
            $stmt = $conn->prepare("INSERT INTO setores (torre_id, nome_setor, limite_clientes) VALUES (?, ?, 150)");
            $stmt->bind_param("is", $torreId, $novoSetorNome);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Novo setor adicionado com sucesso!'];
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao adicionar setor: ' . $stmt->error];
                http_response_code(500);
            }
            $stmt->close();
            break;

        case 'GET_MESSAGE_TEMPLATES':
            $response = getData($conn, "SELECT id, titulo, mensagem FROM mensagens_modelo ORDER BY titulo ASC");
            break;

        case 'SAVE_MESSAGE_TEMPLATE':
            $titulo = $_POST['titulo'] ?? '';
            $mensagem = $_POST['mensagem'] ?? '';
            if (empty($titulo) || empty($mensagem)) {
                $response = ['status' => 'error', 'message' => 'Título e mensagem são obrigatórios.'];
                break;
            }
            $stmt = $conn->prepare("INSERT INTO mensagens_modelo (titulo, mensagem) VALUES (?, ?)");
            $stmt->bind_param("ss", $titulo, $mensagem);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Modelo de mensagem salvo com sucesso!'];
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao salvar modelo: ' . $stmt->error];
            }
            $stmt->close();
            break;

        case 'UPDATE_CLIENT':
            $clientId = (int)($_POST['id'] ?? 0);
            $name = trim($_POST['name'] ?? '');
            $phone = trim($_POST['telefone'] ?? '');
            if (empty($clientId) || empty($name)) {
                $response = ['status' => 'error', 'message' => 'ID e Nome do cliente são obrigatórios.'];
                http_response_code(400);
                break;
            }
            $stmt = $conn->prepare("UPDATE clientes SET name = ?, telefone = ? WHERE id = ?");
            $stmt->bind_param("ssi", $name, $phone, $clientId);
            if ($stmt->execute()) {
                $response = ['status' => 'success', 'message' => 'Dados do cliente atualizados com sucesso!'];
            } else {
                $response = ['status' => 'error', 'message' => 'Erro ao atualizar cliente: ' . $stmt->error];
            }
            $stmt->close();
            break;
            
        case 'GET_CLIENT_ACTIVITY_SUMMARY':
            $filterDate = $_POST['filterDate'] ?? date('Y-m');
            list($year, $month) = explode('-', $filterDate);
            if (!checkdate($month, 1, $year)) {
                $response = ['status' => 'error', 'message' => 'Data de filtro inválida.'];
                break;
            }
            $sql = "SELECT c.name AS clientName, COUNT(a.id) AS activityCount
                    FROM clientes c
                    JOIN atividades_cliente a ON c.id = a.clientId
                    WHERE YEAR(a.date) = ? AND MONTH(a.date) = ?
                    GROUP BY c.name
                    ORDER BY activityCount DESC";
            $stmt = $conn->prepare($sql);
            $stmt->bind_param("ss", $year, $month);
            $stmt->execute();
            $result = $stmt->get_result();
            $data = $result->fetch_all(MYSQLI_ASSOC);
            $stmt->close();
            $response = ['status' => 'success', 'data' => $data];
            break;
            
        case 'GET_APP_CONFIG':
            $config_data = [];
            $sql = "SELECT valor FROM configuracoes WHERE chave = 'APP_SUBSCRIPTION_START_DATE'";
            $result = $conn->query($sql);
            if ($result && $row = $result->fetch_assoc()) {
                $config_data['APP_SUBSCRIPTION_START_DATE'] = $row['valor'];
            } else {
                $config_data['APP_SUBSCRIPTION_START_DATE'] = '2025-07-21 14:30:00'; // Fallback
            }
            $response = ['status' => 'success', 'data' => $config_data];
            break;

        case 'GET_VERSION_INFO':
            // Esta ação é apenas um exemplo, você pode buscar de um arquivo ou config
            $response = ['status' => 'success', 'data' => ['version' => '1.5.0']];
            break;
            
        case 'EXCLUIR_SETOR':
            $setorId = isset($_POST['setorId']) ? (int)$_POST['setorId'] : 0;
            if ($setorId <= 0) { 
                $response = ['status' => 'error', 'message' => 'ID do setor inválido.']; 
                break; 
            }
            
            try {
                // 1. Limpa os itens alocados neste setor (para não quebrar a chave estrangeira)
                $stmt_limpa = $conn->prepare("DELETE FROM itens_alocados WHERE setor_id = ?");
                $stmt_limpa->bind_param("i", $setorId);
                $stmt_limpa->execute();
                $stmt_limpa->close();

                // 2. Apaga o setor
                $stmt = $conn->prepare("DELETE FROM setores WHERE id = ?");
                $stmt->bind_param("i", $setorId);
                $stmt->execute();
                
                if ($stmt->affected_rows > 0) {
                    $response = ['status' => 'success', 'message' => 'Setor excluído com sucesso!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Setor não encontrado.'];
                }
                $stmt->close();
            } catch (Exception $e) {
                $response = ['status' => 'error', 'message' => 'Erro ao excluir setor: ' . $e->getMessage()];
            }
            break;

        case 'EXCLUIR_TORRE':
            $torreId = isset($_POST['torreId']) ? (int)$_POST['torreId'] : 0;
            if ($torreId <= 0) { 
                $response = ['status' => 'error', 'message' => 'ID da torre inválido.']; 
                break; 
            }
            
            try {
                // 1. Apaga todos os itens alocados nesta torre primeiro (Essencial para não travar o banco!)
                $stmt_limpa = $conn->prepare("DELETE FROM itens_alocados WHERE torre_id = ?");
                $stmt_limpa->bind_param("i", $torreId);
                $stmt_limpa->execute();
                $stmt_limpa->close();

                // 2. Apaga todos os setores atrelados a esta torre
                $stmt1 = $conn->prepare("DELETE FROM setores WHERE torre_id = ?");
                $stmt1->bind_param("i", $torreId);
                $stmt1->execute();
                $stmt1->close();

                // 3. Finalmente, apaga a torre
                $stmt2 = $conn->prepare("DELETE FROM torres WHERE id = ?");
                $stmt2->bind_param("i", $torreId);
                $stmt2->execute();
                
                if ($stmt2->affected_rows > 0) {
                    $response = ['status' => 'success', 'message' => 'Torre excluída com sucesso!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Torre não encontrada.'];
                }
                $stmt2->close();
            } catch (Exception $e) {
                $response = ['status' => 'error', 'message' => 'Erro ao excluir torre: ' . $e->getMessage()];
            }
            break;

        case 'EXCLUIR_ITEM_DEFINITIVO':
            $patrimonio = isset($_POST['patrimonio']) ? trim($_POST['patrimonio']) : '';
            if (empty($patrimonio)) { 
                $response = ['status' => 'error', 'message' => 'Patrimônio não recebido.']; 
                break; 
            }
            
            try {
                $apagouAlgo = false;
                
                // Lista de todas as tabelas onde o item pode estar
                $tabelas = [
                    'inventario_principal',
                    'materiais_retifica',
                    'redirecionamento',
                    'itens_alocados',
                    'inventario_veiculos_estoquealternativo',
                    'inventario_veiculos_montana',
                    'inventario_veiculos_pajero',
                    'inventario_veiculos_uno',
                    'inventario_veiculos_unonovo'
                ];
                
                // Varre e apaga de todas as tabelas
                foreach ($tabelas as $tabela) {
                    $stmt = $conn->prepare("DELETE FROM {$tabela} WHERE patrimonio = ?");
                    if ($stmt) {
                        $stmt->bind_param("s", $patrimonio);
                        $stmt->execute();
                        if ($stmt->affected_rows > 0) {
                            $apagouAlgo = true;
                        }
                        $stmt->close();
                    }
                }

                if ($apagouAlgo) {
                    $response = ['status' => 'success', 'message' => 'Item excluído de todo o sistema!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Item não encontrado no banco de dados.'];
                }
                
            } catch (Exception $e) {
                $response = ['status' => 'error', 'message' => 'Erro ao excluir item: ' . $e->getMessage()];
            }
            break;

        case 'EDITAR_ITEM_ESTOQUE':
            $patrimonioAtual = $_POST['patrimonio_atual'] ?? '';
            $novoNome = $_POST['novo_nome'] ?? '';
            $novoPatrimonio = $_POST['novo_patrimonio'] ?? '';
            $novoEndereco = $_POST['novo_endereco'] ?? '';

            if (empty($patrimonioAtual) || empty($novoPatrimonio) || empty($novoNome)) {
                $response = ['status' => 'error', 'message' => 'O nome e o patrimônio são obrigatórios.'];
                break;
            }

            // Atualiza na tabela inventario_principal (Estoque principal)
            $stmt = $conn->prepare("UPDATE inventario_principal SET produto = ?, patrimonio = ?, endereco = ? WHERE patrimonio = ?");
            // "ssss" significa que vamos passar 4 textos (strings)
            $stmt->bind_param("ssss", $novoNome, $novoPatrimonio, $novoEndereco, $patrimonioAtual);
            
            if ($stmt->execute()) {
                if ($stmt->affected_rows > 0) {
                    $response = ['status' => 'success', 'message' => 'Item corrigido com sucesso!'];
                } else {
                    $response = ['status' => 'error', 'message' => 'Nenhuma alteração realizada ou item não encontrado no estoque principal.'];
                }
            } else {
                if ($conn->errno == 1062) { // 1062 é o código de erro do MySQL para duplicidade (UNIQUE KEY)
                    $response = ['status' => 'error', 'message' => "O patrimônio '{$novoPatrimonio}' já existe no estoque!"];
                } else {
                    $response = ['status' => 'error', 'message' => 'Erro ao atualizar no banco: ' . $stmt->error];
                }
            }
            $stmt->close();
            break;

        // =========================================================
        // GERENCIAMENTO DE USUÁRIOS (ALTERAR E EXCLUIR)
        // =========================================================

        case 'UPDATE_USER_ROLE':
            $userIdToUpdate = isset($_POST['userId']) ? (int)$_POST['userId'] : 0;
            $newRole = isset($_POST['newRole']) ? trim($_POST['newRole']) : '';
            
            if ($userIdToUpdate <= 0 || empty($newRole)) {
                echo json_encode(['status' => 'error', 'message' => 'Dados inválidos.']);
                exit;
            }
            try {
                $stmt = $conn->prepare("UPDATE usuarios SET funcao = ? WHERE id = ?");
                $stmt->bind_param("si", $newRole, $userIdToUpdate);
                $stmt->execute();
                echo json_encode(['status' => 'success', 'message' => 'Função do usuário atualizada!']);
            } catch (Exception $e) {
                echo json_encode(['status' => 'error', 'message' => 'Erro ao atualizar: ' . $e->getMessage()]);
            }
            exit;

        case 'EXCLUIR_USUARIO':
            $userIdToDelete = isset($_POST['userId']) ? (int)$_POST['userId'] : 0;
            if ($userIdToDelete <= 0) {
                echo json_encode(['status' => 'error', 'message' => 'ID de usuário inválido.']);
                exit;
            }
            try {
                $stmt = $conn->prepare("DELETE FROM usuarios WHERE id = ?");
                $stmt->bind_param("i", $userIdToDelete);
                $stmt->execute();
                echo json_encode(['status' => 'success', 'message' => 'Usuário excluído permanentemente!']);
            } catch (Exception $e) {
                echo json_encode(['status' => 'error', 'message' => 'Erro ao excluir usuário: ' . $e->getMessage()]);
            }
            exit;

    } // Fim do switch
} catch (Exception $e) {
    $response = ['status' => 'error', 'message' => 'Erro fatal: ' . $e->getMessage()];
    http_response_code(500);
}

$conn->close();
echo json_encode($response);
?>