<?php
/**
 * EXECUTAR FLUXOS DE RECUPERAÇÃO - VERSÃO FINAL COM MÚLTIPLOS PERÍODOS
 * AGORA SUPORTA: Diferentes tempos para diferentes motivos no mesmo fluxo
 * VERSÃO CORRIGIDA - Compatível com motivos_perda e motivos_config
 * 
 * CORREÇÃO: Comparação precisa em minutos para suportar recuperações em horas
 * MELHORIA: Formatação melhorada para execução manual com timestamps em cada linha
 */

// Configurações
error_reporting(E_ALL);
ini_set('display_errors', 1);
ini_set('log_errors', 1);
date_default_timezone_set('America/Sao_Paulo');

// Caminhos
$LOG_DIR = '/home1/tvitec62/logs/';

if (!is_dir($LOG_DIR)) {
    mkdir($LOG_DIR, 0755, true);
}

$LOG_FILE = $LOG_DIR . 'fluxos_recuperacao_' . date('Y-m-d') . '.log';

function log_msg($msg) {
    global $LOG_FILE;
    $timestamp = date('H:i:s');
    $line = "[$timestamp] $msg\n";
    
    // Para execução manual, imprime com formatação colorida se for terminal
    if (php_sapi_name() === 'cli') {
        // Cores ANSI para terminal
        if (strpos($msg, '✅') !== false) {
            echo "\033[32m$line\033[0m"; // Verde
        } elseif (strpos($msg, '❌') !== false || strpos($msg, 'ERRO') !== false) {
            echo "\033[31m$line\033[0m"; // Vermelho
        } elseif (strpos($msg, '⚠️') !== false || strpos($msg, '⚠') !== false) {
            echo "\033[33m$line\033[0m"; // Amarelo
        } elseif (strpos($msg, 'ℹ️') !== false) {
            echo "\033[36m$line\033[0m"; // Ciano
        } elseif (strpos($msg, '🔍') !== false || strpos($msg, '📋') !== false) {
            echo "\033[35m$line\033[0m"; // Magenta
        } elseif (strpos($msg, '✅') !== false) {
            echo "\033[32m$line\033[0m"; // Verde
        } elseif (strpos($msg, '📊') !== false || strpos($msg, '===') !== false) {
            echo "\033[1;37m$line\033[0m"; // Branco brilhante
        } else {
            echo $line;
        }
    } else {
        // Para execução via web
        echo nl2br($line);
    }
    
    file_put_contents($LOG_FILE, $line, FILE_APPEND);
}

// Função para criar separadores visuais
function log_separador($titulo = '', $nivel = 1) {
    $timestamp = date('H:i:s');
    $linha = str_repeat("=", 50);
    
    if ($nivel == 1) {
        log_msg("\n$linha");
        if (!empty($titulo)) {
            log_msg("$titulo");
            log_msg("$linha");
        }
    } elseif ($nivel == 2) {
        log_msg("\n" . str_repeat("-", 40));
        if (!empty($titulo)) {
            log_msg("$titulo");
            log_msg(str_repeat("-", 40));
        }
    } elseif ($nivel == 3) {
        if (!empty($titulo)) {
            log_msg("   " . str_repeat("·", 30));
            log_msg("   $titulo");
            log_msg("   " . str_repeat("·", 30));
        }
    }
}

function conectar_banco() {
    $host = "localhost";
    $user = "tvitec62_adm";
    $password = "Gabrielito@1";
    $database = "tvitec62_son";
    
    $conn = new mysqli($host, $user, $password, $database);
    
    if ($conn->connect_error) {
        throw new Exception("Falha na conexão MySQL: " . $conn->connect_error);
    }
    
    $conn->set_charset("utf8mb4");
    return $conn;
}

// Mapear nomes de motivos
function get_nome_motivo($chave) {
    $map = [
        'desistencia' => 'Desistência',
        'sem_interesse' => 'Sem interesse',
        's/interesse' => 'Sem interesse',
        's/ interesse' => 'Sem interesse',
        'preco_elevado' => 'Preço elevado',
        'preço elevado' => 'Preço elevado',
        'concorrencia' => 'Concorrência',
        'concorrência' => 'Concorrência',
        'nao_atende' => 'Não atende',
        'não atende' => 'Não atende',
        'mudou_ideia' => 'Mudou de ideia',
        'problemas_financeiros' => 'Problemas financeiros',
        'outro' => 'Outro',
        'qualquer' => 'Qualquer motivo'
    ];
    
    return $map[$chave] ?? $chave;
}

// Converter array simples de motivos para estrutura configurada
function converter_motivos_para_config($motivos_perda_simples) {
    if (empty($motivos_perda_simples)) {
        return [];
    }
    
    // Períodos padrão baseados nos nomes dos seus fluxos
    $periodos_padrao = [
        'desistencia' => 1,
        'sem_interesse' => 2,
        'concorrencia' => 3,
        'qualquer' => 30
    ];
    
    $config_motivos = [];
    
    foreach ($motivos_perda_simples as $motivo) {
        $motivo_normalizado = strtolower(trim($motivo));
        
        // Verificar se é "qualquer"
        if ($motivo_normalizado === 'qualquer' || $motivo_normalizado === 'qualquer motivo') {
            $config_motivos['qualquer'] = [
                'ativo' => true,
                'tempo' => 30,
                'unidade' => 'dias'
            ];
            continue;
        }
        
        // Tentar encontrar período padrão
        $tempo_padrao = null;
        foreach ($periodos_padrao as $chave => $dias) {
            if (strpos($motivo_normalizado, $chave) !== false) {
                $tempo_padrao = $dias;
                break;
            }
        }
        
        // Se não encontrou, usar 7 dias como padrão
        $config_motivos[$motivo_normalizado] = [
            'ativo' => true,
            'tempo' => $tempo_padrao ?? 7,
            'unidade' => 'dias'
        ];
    }
    
    return $config_motivos;
}

// Verificar se cliente deve ser recuperado com base na configuração de motivos
function deve_recuperar_cliente($motivo_cliente, $config_motivos) {
    if (empty($config_motivos)) {
        log_msg("   ✅ Nenhuma configuração específica, recupera todos");
        return true;
    }
    
    // Se tem configuração para "qualquer" motivo
    if (isset($config_motivos['qualquer']) && $config_motivos['qualquer']['ativo']) {
        log_msg("   ✅ Configuração 'qualquer' ativa, recupera todos");
        return true;
    }
    
    // Se cliente não tem motivo definido
    if (empty($motivo_cliente)) {
        log_msg("   ⏭️ Cliente sem motivo definido");
        return false;
    }
    
    $motivo_cliente_lower = strtolower(trim($motivo_cliente));
    
    // Verificar cada motivo configurado
    foreach ($config_motivos as $chave => $config) {
        if (!$config['ativo']) continue;
        
        // Obter nome do motivo da configuração
        $motivo_config = strtolower(get_nome_motivo($chave));
        $chave_lower = strtolower($chave);
        
        // 1. Verificação por chave direta
        if ($motivo_cliente_lower === $chave_lower) {
            log_msg("   ✅ Motivo corresponde por chave: '$motivo_cliente' = '$chave'");
            return true;
        }
        
        // 2. Verificação por nome do motivo
        if ($motivo_cliente_lower === $motivo_config) {
            log_msg("   ✅ Motivo corresponde por nome: '$motivo_cliente' = '$motivo_config'");
            return true;
        }
        
        // 3. Verificação parcial
        if (strpos($motivo_cliente_lower, $chave_lower) !== false ||
            strpos($chave_lower, $motivo_cliente_lower) !== false ||
            strpos($motivo_cliente_lower, $motivo_config) !== false ||
            strpos($motivo_config, $motivo_cliente_lower) !== false) {
            log_msg("   ✅ Motivo corresponde parcialmente: '$motivo_cliente' contém '$chave'/'$motivo_config'");
            return true;
        }
    }
    
    log_msg("   ⏭️ Motivo não corresponde a nenhuma configuração: '$motivo_cliente'");
    return false;
}

// Calcular data limite para recuperação baseado no motivo
function calcular_intervalo_recuperacao($motivo_cliente, $config_motivos) {
    if (empty($motivo_cliente) || empty($config_motivos)) {
        return [
            'tempo' => 30,
            'unidade' => 'dias',
            'motivo_config' => 'padrão'
        ];
    }
    
    $motivo_cliente_lower = strtolower(trim($motivo_cliente));
    
    // Períodos padrão baseados nos seus fluxos existentes
    $periodos_padrao = [
        'desistencia' => 1,
        'sem_interesse' => 2,
        'concorrencia' => 3,
        'preco_elevado' => 7,
        'problemas_financeiros' => 14,
        'outro' => 7,
        'qualquer' => 30
    ];
    
    // Primeiro verificar por correspondência exata com chaves
    foreach ($config_motivos as $chave => $config) {
        if (!$config['ativo']) continue;
        
        $chave_lower = strtolower($chave);
        
        if ($motivo_cliente_lower === $chave_lower) {
            return [
                'tempo' => $config['tempo'] ?? $periodos_padrao[$chave_lower] ?? 7,
                'unidade' => $config['unidade'] ?? 'dias',
                'motivo_config' => get_nome_motivo($chave)
            ];
        }
    }
    
    // Depois verificar por correspondência parcial
    foreach ($config_motivos as $chave => $config) {
        if (!$config['ativo']) continue;
        
        $chave_lower = strtolower($chave);
        $motivo_config = strtolower(get_nome_motivo($chave));
        
        if (strpos($motivo_cliente_lower, $chave_lower) !== false ||
            strpos($chave_lower, $motivo_cliente_lower) !== false ||
            strpos($motivo_cliente_lower, $motivo_config) !== false ||
            strpos($motivo_config, $motivo_cliente_lower) !== false) {
            
            return [
                'tempo' => $config['tempo'] ?? $periodos_padrao[$chave_lower] ?? 7,
                'unidade' => $config['unidade'] ?? 'dias',
                'motivo_config' => get_nome_motivo($chave)
            ];
        }
    }
    
    // Se não encontrou, verificar se tem "qualquer"
    if (isset($config_motivos['qualquer']) && $config_motivos['qualquer']['ativo']) {
        return [
            'tempo' => $config_motivos['qualquer']['tempo'] ?? 30,
            'unidade' => $config_motivos['qualquer']['unidade'] ?? 'dias',
            'motivo_config' => 'qualquer'
        ];
    }
    
    // Padrão: 30 dias
    return [
        'tempo' => 30,
        'unidade' => 'dias',
        'motivo_config' => 'padrão'
    ];
}

// Executar recuperação de cliente
function recuperar_cliente($conn, $cliente, $config_recuperacao, $intervalo, $tenant_id) {
    try {
        $cliente_id = $cliente['cliente_id'];
        $cliente_nome = $cliente['Nome_Cliente'];
        $motivo_cliente = $cliente['motivo'] ?? '';
        
        $funil_destino_id = $config_recuperacao['funil_destino_id'] ?? 1;
        $etapa_destino_id = $config_recuperacao['etapa_destino_id'] ?? 1;
        $motivo_recuperacao = $config_recuperacao['motivo_recuperacao'] ?? 'Recuperação automática';
        
        log_msg("   🔄 Iniciando recuperação do cliente $cliente_nome (ID: $cliente_id)");
        log_msg("      ⏰ Intervalo aplicado: {$intervalo['tempo']} {$intervalo['unidade']} (motivo: {$intervalo['motivo_config']})");
        
        // Iniciar transação
        $conn->begin_transaction();
        
        try {
            // 1. Verificar se funil e etapa existem
            $sql_verificar = "SELECT COUNT(*) as total 
                             FROM etapas_funis ef
                             JOIN funis f ON ef.funil_id = f.id
                             WHERE ef.id = ? AND f.id = ? AND f.tenant_id = ?";
            
            $stmt_v = $conn->prepare($sql_verificar);
            $stmt_v->bind_param("iii", $etapa_destino_id, $funil_destino_id, $tenant_id);
            $stmt_v->execute();
            $result_v = $stmt_v->get_result()->fetch_assoc();
            $stmt_v->close();
            
            if ($result_v['total'] == 0) {
                throw new Exception("Funil $funil_destino_id ou etapa $etapa_destino_id não encontrados");
            }
            
            // 2. Atualizar cliente
            $sql_cliente = "UPDATE clientes 
                           SET status = 1, 
                               funil_id = ?, 
                               etapa_funil_id = ?,
                               atualizado_em = NOW()
                           WHERE id = ? AND tenant_id = ?";
            
            $stmt = $conn->prepare($sql_cliente);
            $stmt->bind_param("iiii", $funil_destino_id, $etapa_destino_id, $cliente_id, $tenant_id);
            $stmt->execute();
            $stmt->close();
            
            // 3. Marcar como restaurado na tabela clientes_perdidos
            $observacao = "Recuperado após {$intervalo['tempo']} {$intervalo['unidade']} (motivo: {$motivo_cliente}) via fluxo automático";
            $sql_restaurado = "UPDATE clientes_perdidos 
                              SET restaurado = 1, 
                                  data_restaurado = NOW(),
                                  observacoes = CONCAT(
                                      IFNULL(observacoes, ''), 
                                      ' | $observacao'
                                  )
                              WHERE cliente_id = ? AND tenant_id = ? AND restaurado = 0";
            
            $stmt2 = $conn->prepare($sql_restaurado);
            $stmt2->bind_param("ii", $cliente_id, $tenant_id);
            $stmt2->execute();
            $stmt2->close();
            
            // 4. Registrar log
            $detalhes_log = "Cliente recuperado automaticamente.\n";
            $detalhes_log .= "Motivo original: $motivo_cliente\n";
            $detalhes_log .= "Período configurado: {$intervalo['tempo']} {$intervalo['unidade']}\n";
            $detalhes_log .= "Destino: Funil ID $funil_destino_id, Etapa ID $etapa_destino_id\n";
            $detalhes_log .= "Motivo da recuperação: $motivo_recuperacao";
            
            $sql_log = "INSERT INTO cliente_logs 
                       (cliente_id, usuario_id, nome_usuario, acao, detalhes, tenant_id, observacao_id) 
                       VALUES (?, 0, 'Sistema Automático', 'cliente_recuperado', ?, ?, 0)";
            
            $stmt3 = $conn->prepare($sql_log);
            $stmt3->bind_param("isi", $cliente_id, $detalhes_log, $tenant_id);
            $stmt3->execute();
            $stmt3->close();
            
            $conn->commit();
            
            log_msg("      ✅ Cliente recuperado com sucesso!");
            return true;
            
        } catch (Exception $e) {
            $conn->rollback();
            throw $e;
        }
        
    } catch (Exception $e) {
        log_msg("      ❌ Erro na recuperação: " . $e->getMessage());
        return false;
    }
}

// INÍCIO DA EXECUÇÃO
log_separador("🚀 RECUPERAÇÃO AUTOMÁTICA INICIADA", 1);
log_msg("📅 Data: " . date('Y-m-d H:i:s'));

try {
    // Conectar ao banco
    $conn = conectar_banco();
    log_msg("✅ Conexão MySQL estabelecida");
    
    // BUSCAR TODOS OS FLUXOS ATIVOS
    log_separador("🔍 BUSCANDO FLUXOS ATIVOS", 2);
    
    $sql_fluxos = "SELECT * FROM fluxos_automatizados WHERE ativo = 1";
    $result_fluxos = $conn->query($sql_fluxos);
    
    if (!$result_fluxos) {
        throw new Exception("Erro ao buscar fluxos: " . $conn->error);
    }
    
    $total_fluxos = $result_fluxos->num_rows;
    $clientes_recuperados_total = 0;
    $fluxos_com_recuperacao = 0;
    
    log_msg("📊 Encontrados $total_fluxos fluxo(s) ativo(s)");
    
    if ($total_fluxos == 0) {
        log_msg("ℹ️ Nenhum fluxo ativo encontrado");
        log_separador("🏁 EXECUÇÃO CONCLUÍDA", 1);
        exit(0);
    }
    
    // PROCESSAR CADA FLUXO
    $fluxo_index = 0;
    while ($fluxo = $result_fluxos->fetch_assoc()) {
        $fluxo_index++;
        $fluxo_id = $fluxo['id'];
        $fluxo_nome = $fluxo['nome'];
        $tenant_id = $fluxo['tenant_id'];
        
        log_separador("📋 FLUXO #$fluxo_index: $fluxo_nome", 2);
        log_msg("   ID: $fluxo_id");
        log_msg("   Tenant: $tenant_id");
        
        // DECODIFICAR CONDIÇÕES E AÇÕES
        $condicoes = json_decode($fluxo['condicoes'], true);
        $acoes = json_decode($fluxo['acoes'], true);
        
        if (empty($condicoes) || empty($acoes)) {
            log_msg("   ⚠️ Fluxo sem condições ou ações válidas");
            continue;
        }
        
        // VERIFICAR SE É FLUXO DE RECUPERAÇÃO
        $is_fluxo_recuperacao = false;
        foreach ($condicoes as $condicao) {
            if (isset($condicao['tipo']) && $condicao['tipo'] === 'cliente_perdido') {
                $is_fluxo_recuperacao = true;
                break;
            }
        }
        
        if (!$is_fluxo_recuperacao) {
            log_msg("   ℹ️ Não é fluxo de recuperação");
            continue;
        }
        
        $fluxos_com_recuperacao++;
        
        // BUSCAR AÇÃO DE RECUPERAÇÃO
        $config_recuperacao = null;
        foreach ($acoes as $acao) {
            if ((isset($acao['tipo']) && $acao['tipo'] === 'recuperacao') || 
                (isset($acao['funil_destino_id']) && isset($acao['etapa_destino_id']))) {
                $config_recuperacao = $acao;
                
                // Garantir estrutura correta
                if (!isset($config_recuperacao['tipo'])) {
                    $config_recuperacao['tipo'] = 'recuperacao';
                }
                if (!isset($config_recuperacao['motivo_recuperacao'])) {
                    $config_recuperacao['motivo_recuperacao'] = 'Recuperação automática';
                }
                break;
            }
        }
        
        if (!$config_recuperacao) {
            log_msg("   ❌ Fluxo de recuperação sem ação configurada");
            continue;
        }
        
        // VERIFICAR CONFIGURAÇÕES DE MOTIVOS - CORREÇÃO APLICADA AQUI
        // Suporta ambas as estruturas: motivos_config e motivos_perda
        $config_motivos = $config_recuperacao['motivos_config'] ?? [];
        
        // Se motivos_config está vazio, tenta usar motivos_perda
        if (empty($config_motivos) && isset($config_recuperacao['motivos_perda'])) {
            log_msg("   🔄 Convertendo 'motivos_perda' para estrutura de configuração");
            
            // Se motivos_perda é um array simples, converter para estrutura
            if (is_array($config_recuperacao['motivos_perda'])) {
                $config_motivos = converter_motivos_para_config($config_recuperacao['motivos_perda']);
            }
        }
        
        log_msg("   ✅ Configurações de motivos encontradas:");
        if (empty($config_motivos)) {
            log_msg("      ℹ️ Usando configuração padrão (30 dias para qualquer motivo)");
            // Configuração padrão
            $config_motivos = [
                'qualquer' => [
                    'ativo' => true,
                    'tempo' => 30,
                    'unidade' => 'dias'
                ]
            ];
        } else {
            foreach ($config_motivos as $chave => $config) {
                if ($config['ativo']) {
                    log_msg("      - " . get_nome_motivo($chave) . ": {$config['tempo']} {$config['unidade']}");
                }
            }
        }
        
        // BUSCAR TODOS OS CLIENTES PERDIDOS NÃO RESTAURADOS
        // CORREÇÃO: Adicionado cálculo preciso em minutos
        $sql_clientes = "SELECT cp.cliente_id, c.Nome_Cliente, cp.motivo, cp.data_perdido,
                                TIMESTAMPDIFF(DAY, cp.data_perdido, NOW()) as dias_perdido,
                                TIMESTAMPDIFF(HOUR, cp.data_perdido, NOW()) as horas_perdido,
                                TIMESTAMPDIFF(MINUTE, cp.data_perdido, NOW()) as minutos_perdido
                         FROM clientes_perdidos cp
                         JOIN clientes c ON cp.cliente_id = c.id
                         WHERE cp.tenant_id = ?
                         AND cp.restaurado = 0
                         AND (c.status = 'perdido' OR c.status = 0)
                         ORDER BY cp.data_perdido ASC";
        
        log_msg("   🔍 Buscando clientes perdidos...");
        
        $stmt = $conn->prepare($sql_clientes);
        $stmt->bind_param("i", $tenant_id);
        $stmt->execute();
        $result_clientes = $stmt->get_result();
        
        $total_clientes = $result_clientes->num_rows;
        $clientes_processados = 0;
        $clientes_recuperados = 0;
        $clientes_ignorados = 0;
        
        log_msg("   📋 Encontrados: $total_clientes cliente(s) perdido(s)");
        
        if ($total_clientes == 0) {
            log_msg("   ℹ️ Nenhum cliente para processar");
            $stmt->close();
            continue;
        }
        
        log_separador("👤 PROCESSANDO CLIENTES", 3);
        
        while ($cliente = $result_clientes->fetch_assoc()) {
            $clientes_processados++;
            $cliente_id = $cliente['cliente_id'];
            $cliente_nome = $cliente['Nome_Cliente'];
            $motivo_cliente = $cliente['motivo'] ?? '';
            $dias_perdido = $cliente['dias_perdido'];
            $horas_perdido = $cliente['horas_perdido'];
            $minutos_perdido = $cliente['minutos_perdido'];
            $data_perdido = $cliente['data_perdido'];
            
            log_msg("   👤 Cliente #$clientes_processados: $cliente_nome");
            log_msg("      📅 Perdido em: $data_perdido");
            log_msg("      🎯 Motivo: '$motivo_cliente'");
            log_msg("      ⏱️  Tempo perdido: $dias_perdido dias / $horas_perdido horas / $minutos_perdido minutos");
            
            // VERIFICAR SE DEVE RECUPERAR ESTE CLIENTE
            if (!deve_recuperar_cliente($motivo_cliente, $config_motivos)) {
                log_msg("      ⏭️ Cliente ignorado - motivo não corresponde");
                $clientes_ignorados++;
                continue;
            }
            
            // CALCULAR INTERVALO PARA ESTE MOTIVO ESPECÍFICO
            $intervalo = calcular_intervalo_recuperacao($motivo_cliente, $config_motivos);
            
            log_msg("      ⏰ Configuração: {$intervalo['tempo']} {$intervalo['unidade']} (motivo: {$intervalo['motivo_config']})");
            
            // CORREÇÃO: Converter tempo necessário para minutos para comparação precisa
            $minutos_necessarios = $intervalo['tempo'];
            switch ($intervalo['unidade']) {
                case 'minutos':
                    // Já está em minutos
                    break;
                case 'horas':
                    $minutos_necessarios = $intervalo['tempo'] * 60;
                    break;
                case 'dias':
                    $minutos_necessarios = $intervalo['tempo'] * 24 * 60;
                    break;
                case 'semanas':
                    $minutos_necessarios = $intervalo['tempo'] * 7 * 24 * 60;
                    break;
                case 'meses':
                    $minutos_necessarios = $intervalo['tempo'] * 30 * 24 * 60;
                    break;
                default:
                    $minutos_necessarios = $intervalo['tempo'] * 24 * 60; // Assume dias
            }
            
            log_msg("      ⏳ Necessário: $minutos_necessarios minutos");
            log_msg("      ⏳ Decorrido: $minutos_perdido minutos");
            
            // CORREÇÃO: Verificar se já passou o tempo necessário usando minutos
            if ($minutos_perdido < $minutos_necessarios) {
                $minutos_restantes = ceil($minutos_necessarios - $minutos_perdido);
                $horas_restantes = floor($minutos_restantes / 60);
                $min_restantes = $minutos_restantes % 60;
                $dias_restantes = floor($horas_restantes / 24);
                $horas_restantes_ajustadas = $horas_restantes % 24;
                
                $mensagem_restante = "";
                if ($dias_restantes > 0) {
                    $mensagem_restante .= "$dias_restantes dias, ";
                }
                if ($horas_restantes_ajustadas > 0 || $dias_restantes > 0) {
                    $mensagem_restante .= "$horas_restantes_ajustadas horas e ";
                }
                $mensagem_restante .= "$min_restantes minutos";
                
                log_msg("      ⏳ Aguardando: +$mensagem_restante");
                $clientes_ignorados++;
                continue;
            }
            
            log_msg("      ✅ TEMPO ATINGIDO! Recuperando...");
            
            // EXECUTAR RECUPERAÇÃO
            $sucesso = recuperar_cliente($conn, $cliente, $config_recuperacao, $intervalo, $tenant_id);
            
            if ($sucesso) {
                $clientes_recuperados++;
                $clientes_recuperados_total++;
                log_msg("      ✅ Cliente recuperado com sucesso!");
            } else {
                $clientes_ignorados++;
                log_msg("      ❌ Falha na recuperação");
            }
        }
        
        $stmt->close();
        
        // RESUMO DO FLUXO
        log_separador("📊 RESUMO DO FLUXO #$fluxo_index", 3);
        log_msg("   ✅ Processados: $clientes_processados");
        log_msg("   ✅ Recuperados: $clientes_recuperados");
        log_msg("   ⏭️  Ignorados: $clientes_ignorados");
        
        // ATUALIZAR ÚLTIMA EXECUÇÃO
        $sql_update = "UPDATE fluxos_automatizados SET ultima_execucao = NOW() WHERE id = ?";
        $stmt_update = $conn->prepare($sql_update);
        $stmt_update->bind_param("i", $fluxo_id);
        $stmt_update->execute();
        $stmt_update->close();
        
        log_msg("   ✅ Última execução registrada");
    }
    
    // RELATÓRIO FINAL
    log_separador("📊 RESUMO FINAL DA EXECUÇÃO", 1);
    log_msg("📊 Fluxos analisados: $total_fluxos");
    log_msg("📊 Fluxos com recuperação: $fluxos_com_recuperacao");
    log_msg("📊 Clientes recuperados: $clientes_recuperados_total");
    log_separador("🏁 EXECUÇÃO CONCLUÍDA COM SUCESSO", 1);
    
    $conn->close();
    
    // Saída para cron
    if ($clientes_recuperados_total > 0) {
        echo "SUCESSO: $clientes_recuperados_total clientes recuperados\n";
        exit(0);
    } else {
        echo "INFO: Execução concluída. Nenhum cliente recuperado.\n";
        exit(0);
    }
    
} catch (Exception $e) {
    log_msg("❌ ERRO CRÍTICO: " . $e->getMessage());
    echo "ERRO: " . $e->getMessage() . "\n";
    exit(1);
}
?>