<?php
require_once 'conexao.php';
session_start();

// Iniciar logs de debug
error_log("=== INICIANDO SALVAR_FLUXO ===");
error_log("Session ID: " . session_id());
error_log("POST Data: " . print_r($_POST, true));

// Verificar CSRF token
if (!isset($_POST['csrf_token']) || $_POST['csrf_token'] !== $_SESSION['csrf_token']) {
    error_log("ERRO: Token CSRF inválido");
    $_SESSION['erro'] = "Token de segurança inválido.";
    header('Location: fluxos_automatizados.php');
    exit;
}

// Verificar se o usuário está logado
if (!isset($_SESSION['logado'])) {
    error_log("ERRO: Usuário não logado");
    header('Location: login.php');
    exit;
}

$tenant_id = $_SESSION['tenant_id'] ?? null;
$usuario_id = $_SESSION['usuario_id'] ?? null;

error_log("Tenant ID: $tenant_id, Usuário ID: $usuario_id");

if (!$tenant_id || !$usuario_id) {
    error_log("ERRO: Dados de sessão inválidos");
    $_SESSION['erro'] = "Dados de sessão inválidos.";
    header('Location: fluxos_automatizados.php');
    exit;
}

// Verificar conexão com o banco
if (!$conn) {
    error_log("ERRO: Conexão com banco falhou");
    $_SESSION['erro'] = "Erro de conexão com o banco de dados.";
    header('Location: fluxos_automatizados.php');
    exit;
}

try {
    // Coletar dados do formulário
    $id = $_POST['id'] ?? null;
    $nome = trim($_POST['nome'] ?? '');
    $descricao = trim($_POST['descricao'] ?? '');
    $ativo = isset($_POST['ativo']) ? 1 : 0;
    $tipo_trigger = $_POST['tipo_trigger'] ?? 'evento';
    
    error_log("Dados básicos - ID: $id, Nome: $nome, Ativo: $ativo, Trigger: $tipo_trigger");
    
    // Configurações de notificações
    $enviar_notificacao_atividades = isset($_POST['enviar_notificacao_atividades']) ? 1 : 0;
    $notificacao_sistema = isset($_POST['notificacao_sistema']) ? 1 : 0;
    $notificar_minutos_antes = $_POST['notificar_minutos_antes'] ?? 5;
    
    error_log("Notificações - Email: $enviar_notificacao_atividades, Sistema: $notificacao_sistema, Minutos: $notificar_minutos_antes");
    
    // Destinatários de notificação
    $notificar_destinatarios = '';
    if (isset($_POST['notificar_destinatarios_json'])) {
        $destinatarios = json_decode($_POST['notificar_destinatarios_json'], true);
        if (is_array($destinatarios)) {
            $notificar_destinatarios = implode(',', $destinatarios);
            error_log("Destinatários: $notificar_destinatarios");
        }
    }
    
    // Validar dados
    if (empty($nome)) {
        throw new Exception("O nome do fluxo é obrigatório.");
    }
    
    // Processar condições
    $condicoes = [];
    if (isset($_POST['condicoes_json'])) {
        $condicoes = json_decode($_POST['condicoes_json'], true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            error_log("ERRO JSON condições: " . json_last_error_msg());
            throw new Exception("Erro ao processar condições: " . json_last_error_msg());
        }
        error_log("Condições processadas: " . count($condicoes) . " condições");
    }
    
    // Processar ações
    $acoes = [];
    if (isset($_POST['acoes_json'])) {
        $acoes = json_decode($_POST['acoes_json'], true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            error_log("ERRO JSON ações: " . json_last_error_msg());
            throw new Exception("Erro ao processar ações: " . json_last_error_msg());
        }
        error_log("Ações processadas: " . count($acoes) . " ações");
    }
    
    // Processar configuração de agendamento
    $config_agendamento = null;
    $config_agendamento_json = null;
    if (isset($_POST['config_agendamento_json'])) {
        $config_agendamento = json_decode($_POST['config_agendamento_json'], true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            error_log("ERRO JSON agendamento: " . json_last_error_msg());
            throw new Exception("Erro ao processar configuração de agendamento: " . json_last_error_msg());
        }
        $config_agendamento_json = json_encode($config_agendamento);
        error_log("Config agendamento: $config_agendamento_json");
    }
    
    // Configuração de recuperação
    $config_recuperacao = null;
    $config_recuperacao_json = null;
    if (isset($_POST['config_recuperacao_json'])) {
        $config_recuperacao = json_decode($_POST['config_recuperacao_json'], true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            error_log("ERRO JSON recuperação: " . json_last_error_msg());
            throw new Exception("Erro ao processar configuração de recuperação: " . json_last_error_msg());
        }
        $config_recuperacao_json = json_encode($config_recuperacao);
        error_log("Config recuperação: $config_recuperacao_json");
    }
    
    // Validações específicas por tipo de trigger
    if ($tipo_trigger === 'evento') {
        if (empty($condicoes)) {
            throw new Exception("Pelo menos uma condição é necessária para fluxos por evento.");
        }
    }
    
    if (empty($acoes)) {
        throw new Exception("Pelo menos uma ação é necessária.");
    }
    
    // Converter para JSON
    $condicoes_json = json_encode($condicoes, JSON_UNESCAPED_UNICODE);
    $acoes_json = json_encode($acoes, JSON_UNESCAPED_UNICODE);
    
    error_log("Condições JSON: " . strlen($condicoes_json) . " chars");
    error_log("Ações JSON: " . strlen($acoes_json) . " chars");
    
    // VERIFICAR ESTRUTURA DA TABELA
    error_log("=== VERIFICANDO ESTRUTURA DA TABELA ===");
    
    // Listar todas as colunas da tabela
    $result = $conn->query("SHOW COLUMNS FROM fluxos_automatizados");
    $colunas = [];
    while ($row = $result->fetch_assoc()) {
        $colunas[$row['Field']] = $row;
        error_log("Coluna: {$row['Field']} - Tipo: {$row['Type']} - Null: {$row['Null']} - Default: {$row['Default']}");
    }
    
    // Verificar colunas específicas
    $colunas_notificacao_existem = isset($colunas['enviar_notificacao_atividades']);
    $coluna_recuperacao_existe = isset($colunas['config_recuperacao']);
    
    error_log("Coluna enviar_notificacao_atividades existe? " . ($colunas_notificacao_existem ? 'SIM' : 'NÃO'));
    error_log("Coluna config_recuperacao existe? " . ($coluna_recuperacao_existe ? 'SIM' : 'NÃO'));
    
    // Preparar valores NULL para colunas que podem ser NULL
    $notificar_destinatarios_value = !empty($notificar_destinatarios) ? $notificar_destinatarios : null;
    $config_agendamento_json_value = !empty($config_agendamento_json) ? $config_agendamento_json : null;
    $config_recuperacao_json_value = !empty($config_recuperacao_json) ? $config_recuperacao_json : null;
    
    // DEBUG: Verificar se estamos criando ou atualizando
    if ($id) {
        error_log("=== MODO: ATUALIZAR FLUXO EXISTENTE (ID: $id) ===");
        
        // Primeiro, verificar se o fluxo existe e pertence ao tenant
        $check_sql = "SELECT id FROM fluxos_automatizados WHERE id = ? AND tenant_id = ?";
        $check_stmt = $conn->prepare($check_sql);
        $check_stmt->bind_param("ii", $id, $tenant_id);
        $check_stmt->execute();
        $check_result = $check_stmt->get_result();
        
        if ($check_result->num_rows === 0) {
            throw new Exception("Fluxo não encontrado ou você não tem permissão para editá-lo.");
        }
        $check_stmt->close();
        
        // Construir SQL dinamicamente baseado nas colunas existentes
        $sql = "UPDATE fluxos_automatizados SET ";
        $params = [];
        $types = "";
        $values = [];
        
        // Campos sempre presentes
        $sql .= "nome = ?, descricao = ?, condicoes = ?, acoes = ?, ativo = ?, tipo_trigger = ?, ";
        $params = array_merge($params, [$nome, $descricao, $condicoes_json, $acoes_json, $ativo, $tipo_trigger]);
        $types .= "ssssis";
        
        // Campos condicionais
        if ($colunas_notificacao_existem) {
            $sql .= "enviar_notificacao_atividades = ?, notificar_destinatarios = ?, notificacao_sistema = ?, notificar_minutos_antes = ?, ";
            $params = array_merge($params, [$enviar_notificacao_atividades, $notificar_destinatarios_value, $notificacao_sistema, $notificar_minutos_antes]);
            $types .= "isii";
        }
        
        if (isset($colunas['config_agendamento'])) {
            $sql .= "config_agendamento = ?, ";
            $params = array_merge($params, [$config_agendamento_json_value]);
            $types .= "s";
        }
        
        if ($coluna_recuperacao_existe) {
            $sql .= "config_recuperacao = ?, ";
            $params = array_merge($params, [$config_recuperacao_json_value]);
            $types .= "s";
        }
        
        $sql .= "atualizado_em = NOW() WHERE id = ? AND tenant_id = ?";
        $params = array_merge($params, [$id, $tenant_id]);
        $types .= "ii";
        
        error_log("SQL UPDATE: $sql");
        error_log("Tipos: $types");
        error_log("Parâmetros: " . print_r($params, true));
        
        $stmt = $conn->prepare($sql);
        if (!$stmt) {
            error_log("ERRO PREPARE: " . $conn->error);
            throw new Exception("Erro ao preparar consulta: " . $conn->error);
        }
        
        // Vincular parâmetros dinamicamente
        $bind_params = array_merge([$types], $params);
        $refs = [];
        foreach ($bind_params as $key => $value) {
            $refs[$key] = &$bind_params[$key];
        }
        
        call_user_func_array([$stmt, 'bind_param'], $refs);
        
    } else {
        error_log("=== MODO: CRIAR NOVO FLUXO ===");
        
        // Construir SQL de INSERT dinamicamente
        $sql = "INSERT INTO fluxos_automatizados (";
        $placeholders = "";
        $params = [];
        $types = "";
        $values = [];
        
        // Campos sempre presentes
        $sql .= "nome, descricao, condicoes, acoes, ativo, tipo_trigger, ";
        $placeholders .= "?, ?, ?, ?, ?, ?, ";
        $params = array_merge($params, [$nome, $descricao, $condicoes_json, $acoes_json, $ativo, $tipo_trigger]);
        $types .= "ssssis";
        
        // Campos condicionais
        if ($colunas_notificacao_existem) {
            $sql .= "enviar_notificacao_atividades, notificar_destinatarios, notificacao_sistema, notificar_minutos_antes, ";
            $placeholders .= "?, ?, ?, ?, ";
            $params = array_merge($params, [$enviar_notificacao_atividades, $notificar_destinatarios_value, $notificacao_sistema, $notificar_minutos_antes]);
            $types .= "isii";
        }
        
        if (isset($colunas['config_agendamento'])) {
            $sql .= "config_agendamento, ";
            $placeholders .= "?, ";
            $params = array_merge($params, [$config_agendamento_json_value]);
            $types .= "s";
        }
        
        if ($coluna_recuperacao_existe) {
            $sql .= "config_recuperacao, ";
            $placeholders .= "?, ";
            $params = array_merge($params, [$config_recuperacao_json_value]);
            $types .= "s";
        }
        
        // Campos obrigatórios
        $sql .= "tenant_id, criado_por, criado_em) ";
        $placeholders .= "?, ?, NOW())";
        $params = array_merge($params, [$tenant_id, $usuario_id]);
        $types .= "ii";
        
        $sql .= "VALUES ($placeholders";
        
        error_log("SQL INSERT: $sql");
        error_log("Tipos: $types");
        error_log("Parâmetros: " . print_r($params, true));
        
        $stmt = $conn->prepare($sql);
        if (!$stmt) {
            error_log("ERRO PREPARE: " . $conn->error);
            throw new Exception("Erro ao preparar consulta: " . $conn->error);
        }
        
        // Vincular parâmetros dinamicamente
        $bind_params = array_merge([$types], $params);
        $refs = [];
        foreach ($bind_params as $key => $value) {
            $refs[$key] = &$bind_params[$key];
        }
        
        call_user_func_array([$stmt, 'bind_param'], $refs);
    }
    
    // Executar
    if (!$stmt->execute()) {
        error_log("ERRO EXECUTE: " . $stmt->error);
        throw new Exception("Erro ao salvar fluxo: " . $stmt->error);
    }
    
    $affected_rows = $stmt->affected_rows;
    error_log("Sucesso! Linhas afetadas: $affected_rows");
    
    if (isset($stmt)) {
        $stmt->close();
    }
    
    $_SESSION['sucesso'] = $id ? "Fluxo atualizado com sucesso!" : "Fluxo criado com sucesso!";
    
} catch (Exception $e) {
    error_log("EXCEÇÃO CAPTURADA: " . $e->getMessage());
    error_log("TRACE: " . $e->getTraceAsString());
    
    $_SESSION['erro'] = "Erro: " . $e->getMessage();
    
    // Se for erro de JSON, mostrar mais detalhes
    if (strpos($e->getMessage(), 'JSON') !== false) {
        error_log("Dados JSON problemáticos:");
        if (isset($_POST['condicoes_json'])) {
            error_log("Condições JSON raw: " . $_POST['condicoes_json']);
        }
        if (isset($_POST['acoes_json'])) {
            error_log("Ações JSON raw: " . $_POST['acoes_json']);
        }
    }
}

if (isset($conn) && $conn) {
    $conn->close();
}

error_log("=== REDIRECIONANDO PARA FLUXOS_AUTOMATIZADOS ===");
header('Location: fluxos_automatizados.php');
exit;

/**
 * Função para processar configurações específicas de recuperação
 */
function processarConfiguracoesRecuperacao($condicoes, $postData) {
    // Verificar se este é um fluxo de recuperação de clientes perdidos
    foreach ($condicoes as &$condicao) {
        if ($condicao['tipo'] === 'cliente_perdido' || (isset($condicao['campo']) && $condicao['campo'] === 'status' && $condicao['valor'] === 'perdido')) {
            // Processar opções de recuperação se existirem
            if (isset($postData['config_recuperacao_json'])) {
                $config_recuperacao = json_decode($postData['config_recuperacao_json'], true);
                
                // Adicionar informações de recuperação à condição
                if ($config_recuperacao && isset($config_recuperacao['motivos_ativos'])) {
                    $condicao['config_recuperacao'] = $config_recuperacao;
                }
            }
        }
    }
    
    return $condicoes;
}

/**
 * Função para validar configuração de recuperação
 */
function validarConfiguracaoRecuperacao($config) {
    if (!isset($config['motivos_ativos']) || !is_array($config['motivos_ativos'])) {
        throw new Exception("Configuração de recuperação inválida: motivos_ativos não definido.");
    }
    
    // Definir períodos padrão
    $periodos_padrao = [
        'desistencia' => 1,      // 1 dia
        'concorrencia' => 5,     // 5 dias
        'preco_elevado' => 7,    // 7 dias
        'problemas_financeiros' => 14, // 14 dias
        'qualquer_motivo' => 30  // 30 dias
    ];
    
    // Verificar se há pelo menos um motivo ativo
    $tem_motivo_ativo = false;
    foreach ($config['motivos_ativos'] as $motivo => $ativo) {
        if ($ativo) {
            $tem_motivo_ativo = true;
            
            // Validar período para este motivo
            $chave_periodo = "periodo_$motivo";
            if (isset($config[$chave_periodo])) {
                $periodo = intval($config[$chave_periodo]);
                if ($periodo < 1) {
                    throw new Exception("Período para '$motivo' deve ser pelo menos 1 dia.");
                }
            } else {
                // Usar período padrão se não especificado
                if (isset($periodos_padrao[$motivo])) {
                    $config[$chave_periodo] = $periodos_padrao[$motivo];
                }
            }
        }
    }
    
    if (!$tem_motivo_ativo) {
        throw new Exception("É necessário ativar pelo menos um motivo para recuperação.");
    }
    
    // Validar se funil e etapa de destino estão definidos
    if (empty($config['id_funil_destino'])) {
        throw new Exception("Selecione um funil de destino para recuperação.");
    }
    
    if (empty($config['id_etapa_destino'])) {
        throw new Exception("Selecione uma etapa de destino para recuperação.");
    }
    
    return true;
}
?>