// Evalúa fórmulas booleanas cuantificadas con la recursión de la clase.
//
//     eval_qbf [--tree] archivo.qbf...
//
// Por cada archivo imprime la fórmula, su valor, cuántas llamadas hizo la recursión y cuántas
// estuvieron activas a la vez. Con --tree imprime además el árbol de la recursión.
#include <cstddef>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

#include "qbf.h"

// La misma recursión que evaluate, de qbf.h, pero imprime lo que va probando.
static bool evaluate_and_print(const Qbf& f, std::vector<bool>& values, std::size_t i) {
    std::string indent(2 * i, ' ');
    if (i == f.variables.size()) {
        return matrix_value(f, values);
    }
    bool is_last = i + 1 == f.variables.size();
    bool exists = f.quantifiers[i] == 'E';
    bool result = !exists;
    for (int value = 0; value <= 1; value++) {
        values[i] = value == 1;
        std::cout << indent << f.variables[i] << " = " << value;
        if (!is_last) {
            std::cout << '\n';
        }
        bool sub = evaluate_and_print(f, values, i + 1);
        if (is_last) {
            std::cout << "   ψ = " << (sub ? "verdadero" : "falso") << '\n';
        }
        if (sub == exists) {
            result = exists;  // ∃ encontró un valor que sirve, o ∀ uno que falla
            break;
        }
    }
    std::cout << indent << (exists ? "∃" : "∀") << f.variables[i] << ": " << (result ? "verdadero" : "falso") << '\n';
    return result;
}

int main(int argc, char** argv) {
    bool tree = false;
    std::vector<std::string> paths;
    for (int i = 1; i < argc; i++) {
        std::string arg = argv[i];
        if (arg == "--tree") {
            tree = true;
        } else {
            paths.push_back(arg);
        }
    }
    if (paths.empty()) {
        std::cerr << "uso: eval_qbf [--tree] archivo.qbf...\n";
        return 2;
    }
    try {
        for (std::size_t k = 0; k < paths.size(); k++) {
            Qbf f = load_qbf(paths[k]);
            if (k > 0) {
                std::cout << '\n';
            }
            std::cout << paths[k] << ": " << to_text(f) << '\n';
            if (tree) {
                std::vector<bool> values(f.variables.size(), false);
                evaluate_and_print(f, values, 0);
            }
            EvalStats stats;
            bool value = is_true(f, stats);
            std::cout << "valor: " << (value ? "verdadero" : "falso") << "   llamadas: " << stats.calls
                      << "   llamadas activas a la vez: " << stats.max_depth << '\n';
        }
    } catch (const std::runtime_error& e) {
        std::cerr << "error: " << e.what() << '\n';
        return 1;
    }
    return 0;
}
