// El árbol de ejecuciones de una máquina no determinista, nivel por nivel:
//
//     ntm_demo ARCHIVO.tm CADENA [NIVELES]
//
// Imprime las configuraciones de cada nivel hasta que alguna acepta, todas las ramas se
// detienen o se llega a NIVELES (por omisión, 8). Después muestra qué pasa si se sigue
// siempre la primera opción, como haría un recorrido en profundidad.
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

#include "ntm.h"

int main(int argc, char** argv) {
    if (argc < 3 || argc > 4) {
        std::cerr << "uso: ntm_demo ARCHIVO.tm CADENA [NIVELES]\n";
        return 2;
    }
    try {
        Ntm m = load_ntm(argv[1]);
        std::string w = argv[2];
        long long max_depth = argc == 4 ? std::stoll(argv[3]) : 8;
        std::cout << "w = " << (w.empty() ? "ε" : w) << '\n';

        std::vector<Config> level = {{m.start, w, 0}};
        bool accepted = false;
        for (long long depth = 0; depth <= max_depth && !level.empty() && !accepted; depth++) {
            std::cout << "nivel " << depth << ":";
            std::vector<Config> next_level;
            for (const Config& c : level) {
                std::cout << "   " << to_string(c);
                accepted = accepted || c.state == m.accept;
                for (const Config& child : successors(m, c)) {
                    next_level.push_back(child);
                }
            }
            std::cout << '\n';
            level = next_level;
        }

        Search search = breadth_first(m, w, max_depth);
        if (search.outcome == Outcome::Accept) {
            std::cout << "por niveles: acepta en el nivel " << search.depth << ", después de revisar " << search.visited
                      << " configuraciones\n";
        } else if (search.outcome == Outcome::Reject) {
            std::cout << "por niveles: rechaza, todas las ramas se detuvieron antes del nivel " << search.depth + 1
                      << '\n';
        } else {
            std::cout << "por niveles: ninguna rama aceptó hasta el nivel " << max_depth << '\n';
        }

        const long long limit = 1000000;
        Run first = first_branch(m, w, limit);
        if (first.outcome == Outcome::Limit) {
            std::cout << "siempre la primera opción: no se detuvo en " << limit << " pasos\n";
        } else {
            std::cout << "siempre la primera opción: " << (first.outcome == Outcome::Accept ? "acepta" : "rechaza")
                      << " en " << first.steps << " pasos\n";
        }
    } catch (const std::exception& error) {
        std::cerr << "error: " << error.what() << '\n';
        return 1;
    }
}
