// Pruebas de lo que los apuntes afirman sobre las fórmulas cuantificadas.
#include <cassert>
#include <cstdio>
#include <random>
#include <sstream>
#include <stdexcept>
#include <string>

#include "qbf.h"

static bool fails_to_load(const std::string& path, const std::string& piece) {
    try {
        load_qbf(path);
    } catch (const std::runtime_error& e) {
        return std::string(e.what()).find(piece) != std::string::npos;
    }
    return false;
}

// Una fórmula al azar con m variables y a lo sumo max_clauses cláusulas de 1 a 3 literales.
static Qbf random_qbf(std::mt19937& rng, int m, int max_clauses) {
    Qbf f;
    for (int i = 0; i < m; i++) {
        f.variables.push_back("x" + std::to_string(i + 1));
        f.quantifiers.push_back(rng() % 2 == 0 ? 'E' : 'A');
    }
    int clauses = static_cast<int>(rng() % (max_clauses + 1));
    for (int j = 0; j < clauses; j++) {
        std::vector<int> clause;
        int size = 1 + static_cast<int>(rng() % 3);
        for (int l = 0; l < size; l++) {
            int variable = 1 + static_cast<int>(rng() % m);
            clause.push_back(rng() % 2 == 0 ? variable : -variable);
        }
        f.clauses.push_back(clause);
    }
    return f;
}

int main() {
    // Las dos fórmulas de la clase: el orden de los cuantificadores cambia el valor.
    Qbf forall_exists = load_qbf("machines/forall_exists.qbf");
    Qbf exists_forall = load_qbf("machines/exists_forall.qbf");
    assert(to_text(forall_exists) == "∀x ∃y ((x ∨ y) ∧ (¬x ∨ ¬y))");
    assert(to_text(exists_forall) == "∃y ∀x ((x ∨ y) ∧ (¬x ∨ ¬y))");
    assert(is_true(forall_exists));
    assert(!is_true(exists_forall));
    assert(forall_exists.clauses.size() == exists_forall.clauses.size());  // la misma ψ

    // Con solo ∃, la fórmula es verdadera exactamente cuando ψ es satisfacible.
    Qbf sat = load_qbf("machines/sat_example.qbf");
    assert(is_true(sat));
    std::vector<bool> witness = {true, false, true};  // x = 1, y = 0, z = 1
    assert(matrix_value(sat, witness));
    assert(!is_true(load_qbf("machines/unsat_example.qbf")));

    // El juego de tres jugadas.
    assert(is_true(load_qbf("machines/three_moves.qbf")));

    // Lo que se mide: con m variables hay a lo sumo m + 1 llamadas activas a la vez.
    EvalStats stats;
    is_true(forall_exists, stats);
    assert(stats.max_depth == 3);
    assert(stats.calls == 6);
    EvalStats unsat_stats;
    is_true(load_qbf("machines/unsat_example.qbf"), unsat_stats);
    assert(unsat_stats.calls == 7);  // el árbol completo: 1 + 2 + 4
    assert(unsat_stats.max_depth == 3);

    // Una fórmula sin cláusulas es verdadera; una con variables sin cuantificador no es una entrada.
    Qbf empty;
    assert(is_true(empty));
    assert(fails_to_load("errors/free_variable.qbf", "no está totalmente cuantificada"));
    assert(fails_to_load("errors/bad_quantifier.qbf", "el cuantificador es A o E"));

    // Escribir y volver a leer da la misma fórmula.
    std::ostringstream out;
    write_qbf(out, sat);
    std::istringstream in(out.str());
    Qbf again = read_qbf(in);
    assert(again.variables == sat.variables && again.quantifiers == sat.quantifiers && again.clauses == sat.clauses);

    // La recursión y la tabla de 2^m filas dan el mismo valor en fórmulas al azar.
    std::mt19937 rng(14);
    int trues = 0;
    const int total = 3000;
    for (int k = 0; k < total; k++) {
        int m = 1 + static_cast<int>(rng() % 7);
        Qbf f = random_qbf(rng, m, 8);
        EvalStats s;
        bool value = is_true(f, s);
        assert(value == is_true_by_table(f));
        assert(s.max_depth <= m + 1);
        assert(s.calls <= (2LL << m) - 1);
        trues += value;
    }
    assert(trues > total / 10 && trues < total - total / 10);

    std::printf("test_qbf: las fórmulas de la clase y %d fórmulas al azar (%d verdaderas)\n", total, trues);
    return 0;
}
