<?php
// Configurações de sessão
ini_set('session.cookie_secure', 1);
ini_set('session.cookie_httponly', 1);
ini_set('session.use_strict_mode', 1);
session_start();

// === CSRF helper ===
if (!isset($_SESSION['csrf_tokens']) || !is_array($_SESSION['csrf_tokens'])) {
    $_SESSION['csrf_tokens'] = [];
}

function csrf_gc($ttl = 7200) {
    $now = time();
    foreach ($_SESSION['csrf_tokens'] as $t => $ts) {
        if ($now - (int)$ts > $ttl) {
            unset($_SESSION['csrf_tokens'][$t]);
        }
    }
}

function csrf_validate($token, $ttl = 7200, $consume = true) {
    csrf_gc($ttl);
    if (!$token) return false;
    if (!isset($_SESSION['csrf_tokens'][$token])) return false;
    $age = time() - (int)$_SESSION['csrf_tokens'][$token];
    $ok = $age <= $ttl;
    if ($consume) {
        unset($_SESSION['csrf_tokens'][$token]);
    }
    return $ok && $age >= 0;
}

// Definir cabeçalho JSON primeiro
header('Content-Type: application/json');

// Verificar se o usuário está logado
if (!isset($_SESSION['logado'])) {
    http_response_code(401);
    echo json_encode(['status' => 'erro', 'mensagem' => 'Não autorizado. Faça login novamente.']);
    exit;
}

// Verificar tenant_id
$tenant_id = $_SESSION['tenant_id'] ?? null;
if (!$tenant_id || !is_numeric($tenant_id)) {
    http_response_code(400);
    echo json_encode(['status' => 'erro', 'mensagem' => 'Tenant não identificado.']);
    exit;
}

// Ler dados JSON da requisição
$input = file_get_contents('php://input');
if (empty($input)) {
    http_response_code(400);
    echo json_encode(['status' => 'erro', 'mensagem' => 'Nenhum dado recebido.']);
    exit;
}

$dados = json_decode($input, true);
if (json_last_error() !== JSON_ERROR_NONE) {
    http_response_code(400);
    echo json_encode(['status' => 'erro', 'mensagem' => 'JSON inválido: ' . json_last_error_msg()]);
    exit;
}

// Validar CSRF token
if (!isset($dados['csrf_token']) || !csrf_validate($dados['csrf_token'])) {
    http_response_code(403);
    echo json_encode(['status' => 'erro', 'mensagem' => 'Token CSRF inválido ou expirado.']);
    exit;
}

// Validar dados obrigatórios
if (!isset($dados['nome']) || empty(trim($dados['nome']))) {
    http_response_code(400);
    echo json_encode(['status' => 'erro', 'mensagem' => 'Nome do formulário é obrigatório.']);
    exit;
}

if (!isset($dados['tipo']) || !in_array($dados['tipo'], ['E-mail', 'questionario'])) {
    http_response_code(400);
    echo json_encode(['status' => 'erro', 'mensagem' => 'Tipo de formulário inválido.']);
    exit;
}
// PADRONIZAR O TIPO DO FORMULÁRIO - CORREÇÃO ADICIONADA
$dados['tipo'] = ($dados['tipo'] === 'questionario') ? 'questionario' : 'E-mail';

// Conexão com o banco de dados
require_once 'conexao.php';

// Verificar se a conexão foi estabelecida
if ($conn->connect_error) {
    http_response_code(500);
    echo json_encode(['status' => 'erro', 'mensagem' => 'Erro de conexão com o banco de dados.']);
    exit;
}

try {
    $conn->begin_transaction();

    // Preparar estrutura para salvar
    $estrutura = [
        'tipo' => $dados['tipo'],
        'perguntas' => $dados['perguntas'] ?? []
    ];

    // CORREÇÃO: Se for questionário, adicionar temperaturas à estrutura
    $nota_minima = 0;
    $temperatura = null;
    
    if ($dados['tipo'] === 'questionario' && isset($dados['temperaturas'])) {
        $estrutura['temperaturas'] = $dados['temperaturas'];
        $estrutura['temperatura_minima'] = $dados['temperatura_minima'] ?? null;
        
        // CORREÇÃO: Calcular a nota mínima baseada na temperatura mínima
        foreach ($dados['temperaturas'] as $temp) {
            if ($temp['nome'] === $dados['temperatura_minima']) {
                $nota_minima = (float)$temp['nota'];
                break;
            }
        }
        
        $temperatura = $dados['temperatura_minima'] ?? null;
    }

    $estrutura_json = json_encode($estrutura, JSON_UNESCAPED_UNICODE);
    if ($estrutura_json === false) {
        throw new Exception("Erro ao codificar JSON da estrutura: " . json_last_error_msg());
    }

    // Verificar se é atualização ou inserção
    if (isset($dados['id']) && !empty($dados['id']) && is_numeric($dados['id'])) {
        // ATUALIZAR formulário existente
        $sql = "UPDATE formularios 
                SET nome = ?, estrutura = ?, tipo = ?, nota_minima = ?, temperatura = ?
                WHERE id = ? AND tenant_id = ?";
        $stmt = $conn->prepare($sql);
        if (!$stmt) {
            throw new Exception("Erro ao preparar UPDATE: " . $conn->error);
        }
        
        $stmt->bind_param(
            "sssdiii", 
            $dados['nome'], 
            $estrutura_json,
            $dados['tipo'],
            $nota_minima,
            $temperatura,
            $dados['id'],
            $tenant_id
        );
        
        if (!$stmt->execute()) {
            throw new Exception("Erro ao atualizar formulário: " . $stmt->error);
        }
        
        $formulario_id = $dados['id'];
        $stmt->close();

        // CORREÇÃO: Limpar perguntas e respostas antigas ANTES de salvar as novas
        limparPerguntasAntigas($conn, $formulario_id);
        
    } else {
        // INSERIR novo formulário
        $sql = "INSERT INTO formularios (nome, estrutura, criado_em, tenant_id, tipo, nota_minima, temperatura) 
                VALUES (?, ?, NOW(), ?, ?, ?, ?)";
        $stmt = $conn->prepare($sql);
        if (!$stmt) {
            throw new Exception("Erro ao preparar INSERT: " . $conn->error);
        }
        
        $stmt->bind_param(
            "ssisds", 
            $dados['nome'], 
            $estrutura_json,
            $tenant_id,
            $dados['tipo'],
            $nota_minima,
            $temperatura
        );
        
        if (!$stmt->execute()) {
            throw new Exception("Erro ao inserir formulário: " . $stmt->error);
        }
        
        $formulario_id = $conn->insert_id;
        $stmt->close();
    }

    // Salvar perguntas e respostas (apenas se houver perguntas)
    if (isset($dados['perguntas']) && is_array($dados['perguntas']) && count($dados['perguntas']) > 0) {
        salvarPerguntasERespostas($conn, $formulario_id, $dados['perguntas']);
    }

    $conn->commit();
    
    echo json_encode([
        'status' => 'sucesso', 
        'mensagem' => 'Formulário salvo com sucesso!',
        'formulario_id' => $formulario_id
    ]);

} catch (Exception $e) {
    $conn->rollback();
    error_log("Erro ao salvar formulário: " . $e->getMessage());
    http_response_code(500);
    echo json_encode([
        'status' => 'erro', 
        'mensagem' => 'Erro interno do servidor: ' . $e->getMessage()
    ]);
}

$conn->close();

// CORREÇÃO: Função para limpar perguntas e respostas antigas de forma eficiente
function limparPerguntasAntigas($conn, $formulario_id) {
    // Buscar todos os IDs de perguntas do formulário
    $perguntas_ids = [];
    $result = $conn->query("SELECT id FROM perguntas WHERE formulario_id = $formulario_id");
    while ($row = $result->fetch_assoc()) {
        $perguntas_ids[] = $row['id'];
    }
    
    if (empty($perguntas_ids)) {
        return; // Não há perguntas para limpar
    }
    
    $ids_str = implode(',', $perguntas_ids);
    
    // CORREÇÃO: Primeiro deletar as opções de resposta das perguntas condicionais de segundo nível
    $conn->query("DELETE op2 FROM opcoes_resposta op2 
                 INNER JOIN perguntas p2 ON op2.pergunta_id = p2.id 
                 WHERE p2.parent_resposta_id IN (
                     SELECT op1.id FROM opcoes_resposta op1 
                     INNER JOIN perguntas p1 ON op1.pergunta_id = p1.id 
                     WHERE p1.formulario_id = $formulario_id
                 )");
    
    // CORREÇÃO: Deletar perguntas condicionais de segundo nível
    $conn->query("DELETE FROM perguntas 
                 WHERE parent_resposta_id IN (
                     SELECT op1.id FROM opcoes_resposta op1 
                     INNER JOIN perguntas p1 ON op1.pergunta_id = p1.id 
                     WHERE p1.formulario_id = $formulario_id
                 )");
    
    // CORREÇÃO: Deletar opções de resposta das perguntas condicionais de primeiro nível
    $conn->query("DELETE op1 FROM opcoes_resposta op1 
                 INNER JOIN perguntas p1 ON op1.pergunta_id = p1.id 
                 WHERE p1.formulario_id = $formulario_id AND p1.parent_resposta_id IS NOT NULL");
    
    // CORREÇÃO: Deletar perguntas condicionais de primeiro nível
    $conn->query("DELETE FROM perguntas 
                 WHERE formulario_id = $formulario_id AND parent_resposta_id IS NOT NULL");
    
    // CORREÇÃO: Deletar opções de resposta das perguntas principais
    $conn->query("DELETE FROM opcoes_resposta 
                 WHERE pergunta_id IN ($ids_str)");
    
    // CORREÇÃO: Finalmente deletar as perguntas principais
    $conn->query("DELETE FROM perguntas 
                 WHERE formulario_id = $formulario_id");
}

// Função para salvar perguntas e respostas (incluindo condicionais)
function salvarPerguntasERespostas($conn, $formulario_id, $perguntas, $parent_resposta_id = null) {
    foreach ($perguntas as $ordem => $pergunta) {
        // Validar pergunta
        if (!isset($pergunta['texto']) || empty(trim($pergunta['texto']))) {
            continue; // Pular perguntas sem texto
        }
        
        // Inserir pergunta
        $sqlPergunta = "INSERT INTO perguntas (formulario_id, texto, tipo, obrigatoria, ordem, parent_resposta_id) 
                       VALUES (?, ?, ?, ?, ?, ?)";
        $stmtPergunta = $conn->prepare($sqlPergunta);
        if (!$stmtPergunta) {
            throw new Exception("Erro ao preparar inserção de pergunta: " . $conn->error);
        }
        
        $tipo = $pergunta['tipo'] ?? 'unica';
        $obrigatoria = isset($pergunta['obrigatoria']) ? (int)$pergunta['obrigatoria'] : 1;
        
        $stmtPergunta->bind_param(
            "issiii", 
            $formulario_id, 
            trim($pergunta['texto']),
            $tipo,
            $obrigatoria,
            $ordem,
            $parent_resposta_id
        );
        
        if (!$stmtPergunta->execute()) {
            throw new Exception("Erro ao inserir pergunta: " . $stmtPergunta->error);
        }
        
        $pergunta_id = $conn->insert_id;
        $stmtPergunta->close();

        // Salvar respostas (se não for pergunta de texto)
        if ($tipo !== 'texto' && isset($pergunta['respostas']) && is_array($pergunta['respostas'])) {
            foreach ($pergunta['respostas'] as $resposta_ordem => $resposta) {
                // Validar resposta
                if (!isset($resposta['texto']) || empty(trim($resposta['texto']))) {
                    continue; // Pular respostas sem texto
                }
                
                $sqlResposta = "INSERT INTO opcoes_resposta (pergunta_id, texto, pontuacao, ordem) 
                               VALUES (?, ?, ?, ?)";
                $stmtResposta = $conn->prepare($sqlResposta);
                if (!$stmtResposta) {
                    throw new Exception("Erro ao preparar inserção de resposta: " . $conn->error);
                }
                
                $pontuacao = isset($resposta['pontuacao']) ? (float)$resposta['pontuacao'] : 0;
                $stmtResposta->bind_param(
                    "isdi", 
                    $pergunta_id, 
                    trim($resposta['texto']),
                    $pontuacao,
                    $resposta_ordem
                );
                
                if (!$stmtResposta->execute()) {
                    throw new Exception("Erro ao inserir resposta: " . $stmtResposta->error);
                }
                
                $resposta_id = $conn->insert_id;
                $stmtResposta->close();

                // Salvar perguntas condicionais (recursivamente)
                if (isset($resposta['condicionais']) && is_array($resposta['condicionais'])) {
                    salvarPerguntasERespostas($conn, $formulario_id, $resposta['condicionais'], $resposta_id);
                }
            }
        }
    }
}