<?php
// sincronizar.php - Sincroniza contratos do SGP com painel XUI baseado em planos dinâmicos e lógica de atualização

// ========== CONFIGURAÇÃO PARA LOG EM TEMPO REAL ==========
// Desabilita o buffer de saída para mostrar logs em tempo real
ob_end_flush();
ob_implicit_flush(true);

// Define que não há limite de tempo de execução (cuidado em produção)
set_time_limit(0);

// Configura para mostrar erros
ini_set('display_errors', 1);
error_reporting(E_ALL);

// ========== CONFIGURAÇÃO DE LOG SUPER SEGURO ==========
// Cria diretório de logs se não existir
$log_dir = __DIR__ . '/logs';
if (!is_dir($log_dir)) {
    mkdir($log_dir, 0755, true);
}

// Define permissões liberais nos diretórios
chmod($log_dir, 0777);
chmod($backup_dir, 0777);

// CONFIGURAÇÕES
$sgp_url = 'https://ncinternet.sgp.tsmx.com.br/api/ura/clientes/';
$sgp_token = 'aeb82c71-e5d0-4ef0-8cef-d3678e7dc4cf';
$sgp_app = 'xui';

$xui_url_base = 'http://tv.ncinternet.com.br/FGDwXcHQ/';
$xui_api_key = '5AEC13C46604FDD1AA7A456222B84EC8';

$config_arquivo = __DIR__ . '/config_planos.json';
$log_arquivo = __DIR__ . '/log.txt';

// ========== FUNÇÃO DE LIMPEZA E CONSOLIDAÇÃO DE LOGS ==========
function consolidar_logs() {
    global $log_arquivo;
    $dir = dirname($log_arquivo);
    $arquivo_principal = basename($log_arquivo);
    
    // Procura por arquivos de backup e emergência
    $arquivos_backup = glob($dir . '/*backup*.txt');
    $arquivos_emergency = glob($dir . '/*emergency*.txt');
    $arquivos_merged = glob($dir . '/*merged*.txt');
    $arquivos_temp = glob($dir . '/emergency_*.log');
    $arquivos_temp_tmp = glob('/tmp/sync_log_*.txt');
    
    $todos_arquivos = array_merge($arquivos_backup, $arquivos_emergency, $arquivos_merged, $arquivos_temp, $arquivos_temp_tmp);
    
    if (!empty($todos_arquivos)) {
        $conteudo_consolidado = "";
        $arquivos_processados = [];
        
        // Lê o conteúdo de todos os arquivos de backup
        foreach ($todos_arquivos as $arquivo) {
            if (file_exists($arquivo) && is_readable($arquivo)) {
                $conteudo = @file_get_contents($arquivo);
                if ($conteudo !== false && !empty(trim($conteudo))) {
                    $conteudo_consolidado .= $conteudo;
                    $arquivos_processados[] = $arquivo;
                }
            }
        }
        
        // Adiciona o conteúdo consolidado ao arquivo principal
        if (!empty($conteudo_consolidado)) {
            $resultado = @file_put_contents($log_arquivo, $conteudo_consolidado, FILE_APPEND | LOCK_EX);
            
            // Se conseguiu consolidar, remove os arquivos temporários
            if ($resultado !== false) {
                foreach ($arquivos_processados as $arquivo) {
                    @unlink($arquivo);
                }
                return count($arquivos_processados);
            }
        }
    }
    
    return 0;
}

// ========== FUNÇÃO DE LIMPEZA COMPLETA DE ARQUIVOS TEMPORÁRIOS ==========
function limpar_arquivos_temporarios($manter_dias = 3) {
    $diretorios_limpeza = [
        __DIR__ . '/logs',
        '/tmp'
    ];
    
    $padroes_temporarios = [
        '*backup_*',
        '*emergency*',
        '*merged*',
        'emergency_*.log',
        'sync_log_*.txt'
    ];
    
    $arquivos_removidos = 0;
    $data_limite = time() - ($manter_dias * 24 * 60 * 60);
    
    foreach ($diretorios_limpeza as $dir) {
        if (!is_dir($dir)) continue;
        
        foreach ($padroes_temporarios as $padrao) {
            $arquivos = glob($dir . '/' . $padrao);
            
            foreach ($arquivos as $arquivo) {
                if (file_exists($arquivo)) {
                    $idade_arquivo = filemtime($arquivo);
                    
                    // Remove arquivos mais antigos que X dias
                    if ($idade_arquivo < $data_limite) {
                        if (@unlink($arquivo)) {
                            $arquivos_removidos++;
                        }
                    }
                }
            }
        }
    }
    
    return $arquivos_removidos;
}

// ========== FUNÇÃO DE LIMPEZA DE EMERGÊNCIA (FORÇA TOTAL) ==========
function limpeza_emergencia() {
    $diretorios = [__DIR__ . '/logs', '/tmp'];
    $removidos = 0;
    
    foreach ($diretorios as $dir) {
        if (!is_dir($dir)) continue;
        
        // Lista todos os arquivos temporários
        $arquivos_temp = array_merge(
            glob($dir . '/*backup_*.txt'),
            glob($dir . '/*emergency*.txt'), 
            glob($dir . '/*merged*.txt'),
            glob($dir . '/emergency_*.log'),
            glob($dir . '/sync_log_*.txt')
        );
        
        foreach ($arquivos_temp as $arquivo) {
            if (file_exists($arquivo)) {
                // Tenta ler o conteúdo antes de excluir (última chance)
                $conteudo = @file_get_contents($arquivo);
                if ($conteudo && !empty(trim($conteudo))) {
                    // Se tem conteúdo, tenta salvar no error_log antes de excluir
                    error_log("TEMP_FILE_CONTENT_BACKUP: " . basename($arquivo) . " -> " . $conteudo);
                }
                
                if (@unlink($arquivo)) {
                    $removidos++;
                }
            }
        }
    }
    
    return $removidos;
}

// Função de log ULTRA ROBUSTA - NUNCA perde logs
function registrar_log($msg, $forcar_flush = true) {
    global $log_arquivo;
    $linha = '[' . date('Y-m-d H:i:s') . "] $msg";
    
    // ========== GRAVAÇÃO SUPER SEGURA DO LOG ==========
    $log_salvo = false;
    $tentativas = 0;
    $max_tentativas = 10;
    
    while (!$log_salvo && $tentativas < $max_tentativas) {
        $tentativas++;
        
        try {
            // Garante que o diretório existe
            $dir = dirname($log_arquivo);
            if (!is_dir($dir)) {
                mkdir($dir, 0755, true);
            }
            
            // Tenta várias estratégias de gravação
            if ($tentativas <= 3) {
                // Tentativas 1-3: Método padrão com lock exclusivo
                $resultado = @file_put_contents($log_arquivo, $linha . "\n", FILE_APPEND | LOCK_EX);
                if ($resultado !== false) {
                    $log_salvo = true;
                }
            } elseif ($tentativas <= 6) {
                // Tentativas 4-6: Usando fopen/fwrite/fclose com lock manual
                $handle = @fopen($log_arquivo, 'a');
                if ($handle) {
                    if (@flock($handle, LOCK_EX)) {
                        @fwrite($handle, $linha . "\n");
                        @fflush($handle);
                        @flock($handle, LOCK_UN);
                        $log_salvo = true;
                    }
                    @fclose($handle);
                }
            } else {
                // Tentativas 7-10: Arquivo de backup com timestamp único
                $backup_arquivo = $log_arquivo . '_backup_' . date('Y-m-d_H-i-s') . '_' . getmypid() . '.txt';
                $resultado = @file_put_contents($backup_arquivo, $linha . "\n", FILE_APPEND);
                if ($resultado !== false) {
                    $log_salvo = true;
                    // Tenta mover o backup para o arquivo principal depois
                    @rename($backup_arquivo, $log_arquivo . '_merged_' . time() . '.txt');
                }
            }
            
        } catch (Exception $e) {
            // Se der erro, tenta arquivo de emergência
            $emergencia = __DIR__ . '/log_emergencia_' . date('Y-m-d') . '.txt';
            @file_put_contents($emergencia, $linha . "\n", FILE_APPEND);
        }
        
        if (!$log_salvo) {
            usleep(100000); // Espera 0.1 segundo antes da próxima tentativa
        }
    }
        
    // ========== EXIBIÇÃO NA TELA ==========
    // Mostra na tela com formatação HTML
    if (php_sapi_name() !== 'cli') {
        echo "<div style='margin: 2px 0; padding: 2px; font-family: monospace; font-size: 12px;'>";
        echo "<span style='color: #666;'>[" . date('H:i:s') . "]</span> ";
        echo htmlspecialchars($msg);
        
        // Indicador visual de status do log
        if ($log_salvo) {
            echo "<span style='color: green; font-size: 10px;'> ✓</span>";
        } else {
            echo "<span style='color: red; font-size: 10px;'> ⚠</span>";
        }
        
        echo "</div>\n";
    } else {
        // Se executando via linha de comando
        echo $linha;
        echo $log_salvo ? " ✓\n" : " ⚠\n";
    }
    
    // Força o envio imediato para o navegador
    if ($forcar_flush) {
        if (ob_get_level()) {
            ob_flush();
        }
        flush();
    }
}

// Função para mostrar progresso
function mostrar_progresso($atual, $total, $operacao = '') {
    $percentual = $total > 0 ? round(($atual / $total) * 100, 1) : 0;
    $barra = str_repeat('█', floor($percentual / 2)) . str_repeat('░', 50 - floor($percentual / 2));
    
    if (php_sapi_name() !== 'cli') {
        echo "<div style='margin: 5px 0; font-family: monospace;'>";
        echo "<div style='background: #f0f0f0; padding: 5px; border-radius: 3px;'>";
        echo "$operacao: $atual/$total ($percentual%) <br>";
        echo "<div style='background: #ddd; width: 300px; height: 20px; border-radius: 10px; overflow: hidden;'>";
        echo "<div style='background: linear-gradient(90deg, #4CAF50, #45a049); width: {$percentual}%; height: 100%; transition: width 0.3s;'></div>";
        echo "</div></div></div>";
    } else {
        echo "[$barra] $percentual% - $operacao: $atual/$total\n";
    }
    
    if (ob_get_level()) ob_flush();
    flush();
}

function carregar_configuracoes() {
    global $config_arquivo;
    if (!file_exists($config_arquivo)) file_put_contents($config_arquivo, json_encode(new stdClass(), JSON_PRETTY_PRINT));
    return json_decode(file_get_contents($config_arquivo), true);
}

// Função genérica para GET com cURL (XUI) com timeout maior e retry
function chamar_api($url, $tentativas = 3) {
    $timeout = 60;
    for ($i = 0; $i < $tentativas; $i++) {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['User-Agent: PHP-cURL']);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);

        $res = curl_exec($ch);
        $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $err = curl_errno($ch) ? curl_error($ch) : null;
        curl_close($ch);

        if ($err) {
            registrar_log("Tentativa ".($i+1)." - Erro cURL: $err");
            sleep(5);
            continue;
        }

        if ($http_code >= 200 && $http_code < 300) {
            $json = json_decode($res, true);
            if ($json === null) {
                registrar_log("Tentativa ".($i+1)." - Erro ao decodificar JSON da URL: $url");
                sleep(5);
                continue;
            }
            return $json;
        }

        registrar_log("Tentativa ".($i+1)." - HTTP $http_code para $url");
        sleep(5);
    }

    registrar_log("Falha definitiva ao acessar $url após $tentativas tentativas.");
    return null;
}

// Função POST para o SGP - Versão Otimizada com Logs Reduzidos
function chamar_post_sgp($params, $tentativas = 3) {
    global $sgp_url;
    
    for ($i = 0; $i < $tentativas; $i++) {
        // Só mostra log na primeira tentativa ou se houver erro
        if ($i == 0) {
            // Não loga nada na primeira tentativa (caso comum)
        } else {
            registrar_log("⚠️ Retry SGP (tentativa " . ($i + 1) . " de $tentativas)");
        }
        
        // Configurações otimizadas para CLI/Cron
        $opcoes = [
            'http' => [
                'header' => "Content-Type: application/json\r\n" .
                           "User-Agent: PHP-SGP-Sync\r\n" .
                           "Connection: close\r\n",
                'method' => 'POST',
                'content' => json_encode($params),
                'timeout' => 120,
                'ignore_errors' => true,
            ],
            'ssl' => [
                'verify_peer' => false,
                'verify_peer_name' => false,
                'allow_self_signed' => true
            ]
        ];
        
        $ctx = stream_context_create($opcoes);
        $res = @file_get_contents($sgp_url, false, $ctx);
        
        // Verifica se houve resposta
        if ($res === false) {
            $error = error_get_last();
            registrar_log("❌ Erro SGP: " . ($error['message'] ?? 'Erro desconhecido'));
            
            // Se for a última tentativa, tenta configurações alternativas
            if ($i == $tentativas - 1) {
                $opcoes_simples = [
                    'http' => [
                        'method' => 'POST',
                        'header' => "Content-type: application/json",
                        'content' => json_encode($params),
                        'timeout' => 180,
                    ]
                ];
                
                $ctx_simples = stream_context_create($opcoes_simples);
                $res = @file_get_contents($sgp_url, false, $ctx_simples);
            }
            
            if ($res === false) {
                sleep(10);
                continue;
            }
        }
        
        // Verifica código HTTP apenas se houver erro
        if (isset($http_response_header)) {
            $status_line = $http_response_header[0] ?? '';
            preg_match('/HTTP\/\d\.\d\s+(\d+)/', $status_line, $matches);
            $http_code = isset($matches[1]) ? (int)$matches[1] : 200;
            
            if ($http_code >= 400) {
                registrar_log("❌ SGP HTTP $http_code (tentativa " . ($i + 1) . ")");
                sleep(10);
                continue;
            }
        }
        
        // Tenta decodificar JSON
        $json = json_decode($res, true);
        if ($json === null) {
            registrar_log("❌ JSON inválido do SGP (tentativa " . ($i + 1) . ")");
            sleep(10);
            continue;
        }
        
        // Só loga sucesso se houve retry anteriormente
        if ($i > 0) {
            registrar_log("✅ SGP respondeu após " . ($i + 1) . " tentativas");
        }
        
        return $json;
    }
    
    // Diagnóstico apenas em caso de falha total
    registrar_log("❌ FALHA CRÍTICA: SGP não respondeu após $tentativas tentativas");
    registrar_log("🔧 URL: $sgp_url | allow_url_fopen: " . (ini_get('allow_url_fopen') ? 'ON' : 'OFF'));
    
    die("Sincronização interrompida - SGP inacessível.");
}

// Obter todos os usuários do XUI
function obter_usuarios_xui() {
    global $xui_url_base, $xui_api_key;
    registrar_log("Carregando usuários do XUI...");
    
    $url = "$xui_url_base?api_key=$xui_api_key&action=get_lines&limit=9999999";
    $res = chamar_api($url);

    if (!$res || empty($res['data'])) {
        registrar_log("Nenhum usuário retornado do XUI ou resposta inválida.");
        die("Falha crítica ao carregar usuários do XUI.");
    }

    $usuarios = [];
    $total = count($res['data']);
    $processados = 0;
    
    foreach ($res['data'] as $linha) {
        $usuarios[$linha['username']] = [
            'id' => $linha['id'],
            'enabled' => $linha['enabled'],
            'max_connections' => $linha['max_connections'],
            'admin_notes' => $linha['admin_notes'] ?? ''
        ];
        
        $processados++;
        if ($processados % 200 == 0 || $processados == $total) {
            mostrar_progresso($processados, $total, "Carregando usuários XUI");
        }
    }

    registrar_log("✓ Usuários carregados do XUI: " . count($usuarios));
    return $usuarios;
}

// Criar usuário no XUI
function criar_usuario($cpf, $nome, $plano_id, $bouquet, $maxconn) {
    global $xui_url_base, $xui_api_key;
    registrar_log("🔄 Criando usuário $nome ($cpf)...");
    
    $senha = substr($cpf, 0, 3);
    $url = "$xui_url_base?api_key=$xui_api_key&action=create_line";
    $url .= "&bouquets_selected=[\"$bouquet\"]&username=$cpf&password=$senha&max_connections=$maxconn";
    $url .= "&access_output[]=1&access_output[]=2&access_output[]=3&admin_notes=" . urlencode("$nome | plano_id=$plano_id | bouquet=$bouquet");

    $res = chamar_api($url);
    registrar_log($res ? "✅ [CRIADO] $nome $cpf plano=$plano_id, max_connections=$maxconn, bouquet=$bouquet"
                       : "❌ [ERRO AO CRIAR] $nome $cpf plano=$plano_id");
}

// Ativar usuário
function ativar_usuario($id, $cpf, $nome, $plano_id) {
    global $xui_url_base, $xui_api_key;
    registrar_log("🔄 Ativando usuário $nome ($cpf)...");
    
    $url = "$xui_url_base?api_key=$xui_api_key&action=enable_line&id=$id";
    $res = chamar_api($url);
    registrar_log($res ? "✅ [ATIVADO] $nome $cpf plano=$plano_id" : "❌ [ERRO AO ATIVAR] $nome $cpf plano=$plano_id");
}

// Suspender usuário
function suspender_usuario($id, $cpf, $nome, $plano_id) {
    global $xui_url_base, $xui_api_key;
    registrar_log("🔄 Suspendendo usuário $nome ($cpf)...");
    
    $url = "$xui_url_base?api_key=$xui_api_key&action=disable_line&id=$id";
    $res = chamar_api($url);
    registrar_log($res ? "⚠️ [SUSPENSO] $nome $cpf plano=$plano_id" : "❌ [ERRO AO SUSPENDER] $nome $cpf plano=$plano_id");
}

// Deletar usuário
function deletar_usuario($id, $cpf, $nome, $plano_id, $motivo) {
    global $xui_url_base, $xui_api_key;
    registrar_log("🔄 Excluindo usuário $nome ($cpf) - $motivo...");
    
    $url = "$xui_url_base?api_key=$xui_api_key&action=delete_line&id=$id";
    $res = chamar_api($url);
    registrar_log($res ? "🗑️ [EXCLUIDO] $nome $cpf plano=$plano_id - motivo: $motivo"
                       : "❌ [ERRO AO EXCLUIR] $nome $cpf plano=$plano_id - motivo: $motivo");
}

// ================== EXECUÇÃO PRINCIPAL ==================

// Cabeçalho HTML para melhor visualização no navegador
if (php_sapi_name() !== 'cli') {
    echo "<!DOCTYPE html><html><head><meta charset='UTF-8'>";
    echo "<title>Sincronização SGP → XUI</title>";
    echo "<style>body{font-family:Arial,sans-serif;background:#f5f5f5;padding:20px;}</style>";
    echo "</head><body><h2>🔄 Sincronização SGP → XUI</h2>";
    echo "<div id='log-container' style='background:white;padding:15px;border-radius:5px;box-shadow:0 2px 5px rgba(0,0,0,0.1);'>";
}

// ========== CONSOLIDAÇÃO INICIAL DOS LOGS ==========
$consolidados = consolidar_logs();
if ($consolidados > 0) {
    registrar_log("🔄 Consolidados $consolidados arquivos temporários pendentes");
}

// ========== LIMPEZA DE ARQUIVOS ANTIGOS ==========
$removidos = limpar_arquivos_temporarios(7); // Remove arquivos com mais de 7 dias
if ($removidos > 0) {
    registrar_log("🧹 Removidos $removidos arquivos temporários antigos (>7 dias)");
}

// ========== TESTE DE GRAVAÇÃO DE LOG ==========
registrar_log("🔧 Testando sistema de log...");
if (file_exists($log_arquivo) && is_writable($log_arquivo)) {
    registrar_log("✅ Sistema de log funcionando corretamente!");
} else {
    registrar_log("⚠️ Aviso: Problemas detectados no sistema de log, usando métodos alternativos");
}

registrar_log("🚀 ======= INÍCIO DA SINCRONIZAÇÃO =======");
registrar_log("🔧 Modo de execução: " . (php_sapi_name() === 'cli' ? 'CLI (cron)' : 'Web'));
registrar_log("🔧 Usuário atual: " . get_current_user());
registrar_log("🔧 PHP Version: " . phpversion());
registrar_log("🔧 allow_url_fopen: " . (ini_get('allow_url_fopen') ? 'SIM' : 'NÃO'));
registrar_log("🔧 default_socket_timeout: " . ini_get('default_socket_timeout') . 's');
registrar_log("🔧 user_agent: " . (ini_get('user_agent') ?: 'Não definido'));
registrar_log("🔧 openssl: " . (extension_loaded('openssl') ? 'SIM' : 'NÃO'));

// Teste básico de conectividade para CLI
if (php_sapi_name() === 'cli') {
    registrar_log("🔧 Testando conectividade básica...");
    $test_url = 'https://www.google.com';
    $test_result = @file_get_contents($test_url, false, stream_context_create([
        'http' => ['timeout' => 10]
    ]));
    registrar_log("🔧 Conectividade HTTPS: " . ($test_result !== false ? 'OK' : 'FALHA'));
}

$inicio = time();

$config = carregar_configuracoes();
$usuarios_xui = obter_usuarios_xui();

registrar_log("📋 Carregando clientes do SGP por plano...");
$clientes_sgp = [];
$total_planos = count($config);
$planos_processados = 0;

foreach ($config as $plano_id => $cfg) {
    $planos_processados++;
    registrar_log("📊 Plano $plano_id ($planos_processados/$total_planos): buscando clientes...");
    
    $offset = 0;
    $limit = 100;
    $clientes_plano = 0;
    
    do {
        $res = chamar_post_sgp([
            "token" => $sgp_token,
            "app" => $sgp_app,
            "plano" => (int)$plano_id,
            "offset" => $offset,
            "limit" => $limit,
            "omitir_titulos" => true,
            "omitir_contatos" => true
        ]);
        
        if (!$res || empty($res['clientes'])) break;

        foreach ($res['clientes'] as $cliente) {
            $cpf = preg_replace('/\D/', '', $cliente['cpfcnpj']);
            foreach ($cliente['contratos'] as $contrato) {
                foreach ($contrato['servicos'] as $servico) {
                    if ($servico['tipo'] === 'internet' && $servico['plano']['id'] == $plano_id) {
                        if (in_array(strtolower($contrato['status']), ['ativo', 'suspenso'])) {
                            $clientes_sgp[$cpf] = [
                                'nome' => $cliente['nome'],
                                'status' => strtolower($contrato['status']),
                                'plano_id' => $plano_id,
                                'bouquet' => $cfg['bouquet_id'],
                                'max_connections' => $cfg['max_connections']
                            ];
                            $clientes_plano++;
                        }
                    }
                }
            }
        }
        $offset += $limit;
        
        if ($offset % 500 == 0 && $offset > 0) {
            registrar_log("  📈 Plano $plano_id: processados $offset registros...");
        }
        
    } while (!empty($res['clientes']));
    
    registrar_log("  ✓ Plano $plano_id: $clientes_plano clientes encontrados");
}

registrar_log("✅ Total de clientes carregados do SGP: " . count($clientes_sgp));

// Processamento dos clientes
registrar_log("🔄 Iniciando processamento dos clientes...");
$criados = $ativados = $suspensos = $excluidos = $ignorados = 0;
$total_clientes = count($clientes_sgp);
$processados = 0;

foreach ($clientes_sgp as $cpf => $dados) {
    $processados++;
    $nome = $dados['nome'];
    $status = $dados['status'];
    $plano_id = $dados['plano_id'];
    $bouquet = $dados['bouquet'];
    $maxconn = $dados['max_connections'];

    if ($processados % 50 == 0 || $processados == $total_clientes) {
        mostrar_progresso($processados, $total_clientes, "Processando clientes");
    }

    $usuario = $usuarios_xui[$cpf] ?? null;
    $notas = $usuario['admin_notes'] ?? '';

    // Extrair bouquet via admin_notes
    preg_match('/bouquet=(\d+)/', $notas, $m);
    $usuario_bouquet = $m[1] ?? '';

    // ------------------- LÓGICA DE RECRIAÇÃO -------------------
    if ($usuario) {
        if (!str_contains($notas, "plano_id=$plano_id")
            || $usuario['max_connections'] != $maxconn
            || $usuario_bouquet != $bouquet
            || $usuario_bouquet === '') {

            deletar_usuario($usuario['id'], $cpf, $nome, $plano_id, "mudança de plano, conexões ou bouquet");
            criar_usuario($cpf, $nome, $plano_id, $bouquet, $maxconn);
            $criados++;
            continue;
        }
    } else {
        criar_usuario($cpf, $nome, $plano_id, $bouquet, $maxconn);
        $criados++;

        if ($status === 'suspenso') {
            $usuarios_xui_atual = obter_usuarios_xui();
            $novo = $usuarios_xui_atual[$cpf] ?? null;
            if ($novo) {
                suspender_usuario($novo['id'], $cpf, $nome, $plano_id);
                $suspensos++;
            }
        }
    }

    // ------------------- ATIVAÇÃO / SUSPENSÃO -------------------
    if ($usuario) {
        if ($status === 'ativo' && !$usuario['enabled']) {
            ativar_usuario($usuario['id'], $cpf, $nome, $plano_id);
            $ativados++;
        } elseif ($status === 'suspenso' && $usuario['enabled']) {
            suspender_usuario($usuario['id'], $cpf, $nome, $plano_id);
            $suspensos++;
        } else {
            // Só loga se for ação especial (não loga os "ignorados")
            if ($status === 'ativo' || $status === 'suspenso') {
                // Não loga cada ignorado individual
            }
            $ignorados++;
        }
    }
}

// ------------------- EXCLUSÃO DE USUÁRIOS NÃO ENCONTRADOS -------------------
registrar_log("🔍 Verificando usuários para exclusão...");
$usuarios_para_excluir = [];

foreach ($usuarios_xui as $cpf => $usuario) {
    // Ignora contas que contêm "NC" em qualquer parte do username ou "CONTA_TESTE" no admin_notes
    if (stripos($cpf, 'NC') !== false || stripos($usuario['admin_notes'], 'CONTA_TESTE') !== false) {
        continue;
    }
    if (!isset($clientes_sgp[$cpf])) {
        $usuarios_para_excluir[] = ['cpf' => $cpf, 'usuario' => $usuario];
    }
}

$total_exclusoes = count($usuarios_para_excluir);
if ($total_exclusoes > 0) {
    registrar_log("🗑️ Excluindo $total_exclusoes usuários não encontrados no SGP...");
    
    foreach ($usuarios_para_excluir as $index => $item) {
        $cpf = $item['cpf'];
        $usuario = $item['usuario'];
        
        mostrar_progresso($index + 1, $total_exclusoes, "Excluindo usuários");
        
        $nome = explode('|', $usuario['admin_notes'])[0] ?? '';
        $plano_id = (int)(preg_match('/plano_id=(\d+)/', $usuario['admin_notes'], $m) ? $m[1] : 0);
        deletar_usuario($usuario['id'], $cpf, $nome, $plano_id, "não encontrado no SGP");
        $excluidos++;
    }
}

// ------------------- RESUMO FINAL -------------------
$fim = time();
$tempo_execucao = $fim - $inicio;
$minutos = floor($tempo_execucao / 60);
$segundos = $tempo_execucao % 60;

registrar_log("🎉 ======= RESUMO FINAL =======");
registrar_log("✅ Criados/Recriados: $criados");
registrar_log("🟢 Ativados: $ativados");
registrar_log("⚠️ Suspensos: $suspensos");
registrar_log("🗑️ Excluídos: $excluidos");
registrar_log("ℹ️ Ignorados: $ignorados");
registrar_log("⏱️ Tempo de execução: {$minutos}m {$segundos}s");
registrar_log("🏁 ======= FIM =======");

// ========== CONSOLIDAÇÃO FINAL E LIMPEZA ==========
$consolidados_final = consolidar_logs();
if ($consolidados_final > 0) {
    registrar_log("🔄 Consolidação final: $consolidados_final arquivos temporários processados");
}

// ========== LIMPEZA FINAL DE TEMPORÁRIOS DA SESSÃO ATUAL ==========
$removidos_sessao = 0;
$pid_atual = getmypid();

// Remove arquivos temporários específicos desta execução
$temp_desta_sessao = [
    __DIR__ . "/emergency_{$pid_atual}.log",
    __DIR__ . "/logs/emergency_{$pid_atual}.log", 
    "/tmp/sync_log_" . date('Y-m-d') . ".txt"
];

foreach ($temp_desta_sessao as $arquivo_temp) {
    if (file_exists($arquivo_temp)) {
        // Última verificação se há conteúdo não consolidado
        $conteudo = @file_get_contents($arquivo_temp);
        if ($conteudo && !empty(trim($conteudo))) {
            @file_put_contents($log_arquivo, $conteudo, FILE_APPEND | LOCK_EX);
        }
        
        if (@unlink($arquivo_temp)) {
            $removidos_sessao++;
        }
    }
}

if ($removidos_sessao > 0) {
    registrar_log("🧹 Limpeza da sessão: $removidos_sessao arquivos temporários removidos");
}

// ========== RELATÓRIO DE LIMPEZA ==========
registrar_log("📊 Relatório de arquivos temporários:");
registrar_log("   • Consolidados no início: " . ($consolidados ?? 0));
registrar_log("   • Removidos (antigos): " . ($removidos ?? 0)); 
registrar_log("   • Consolidados no final: " . ($consolidados_final ?? 0));
registrar_log("   • Removidos (sessão atual): $removidos_sessao");

if (php_sapi_name() !== 'cli') {
    echo "</div>";
    echo "<div style='margin-top:15px;padding:10px;background:#e8f5e8;border-radius:5px;'>";
    echo "<strong>✅ Sincronização Concluída!</strong><br>";
    echo "📁 Log principal: <code>log.txt</code><br>";
    echo "💾 Backup: <code>" . basename($backup_final) . "</code><br>";
    echo "🧹 Arquivos temp. removidos: <strong>" . ($removidos + $removidos_sessao) . "</strong><br>";
    echo "⏱️ Tempo total: {$minutos}m {$segundos}s";
    echo "</div>";

    // Botão para limpeza manual de emergência
    echo "<div style='margin-top:10px;'>";
    echo "<button onclick='window.location.href=\"?limpeza_emergencia=1\"' style='background:#ff6b6b;color:white;border:none;padding:8px 16px;border-radius:4px;cursor:pointer;'>";
    echo "🚨 Limpeza de Emergência</button>";
    echo "<small style='display:block;margin-top:5px;color:#666;'>Use apenas se houver muitos arquivos temporários acumulados</small>";
    echo "</div>";
    
    echo "</body></html>";
}

// ========== LIMPEZA DE EMERGÊNCIA VIA GET ==========
if (isset($_GET['limpeza_emergencia']) && $_GET['limpeza_emergencia'] == '1') {
    echo "<div style='background:#fff3cd;border:1px solid #ffeaa7;padding:10px;margin:10px;border-radius:5px;'>";
    echo "<h3>🚨 Executando Limpeza de Emergência...</h3>";
    
    $emergencia_removidos = limpeza_emergencia();
    
    echo "<p>✅ <strong>$emergencia_removidos</strong> arquivos temporários foram removidos na limpeza de emergência.</p>";
    echo "<p><a href='?' style='color:#0066cc;'>← Voltar</a></p>";
    echo "</div>";
    exit;
}
?>