// Muestra un NFA como quíntupla y como tabla de transiciones: show_nfa ARCHIVO.nfa
// Cada casilla de la tabla es un conjunto de estados, y hay una columna más para ε.
// En la tabla, -> marca el estado inicial y * los estados de aceptación.
// Si hay transiciones ε, al final imprime la clausura ε de cada estado.
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

#include "nfa.h"
#include "print.h"

int main(int argc, char** argv) {
    if (argc != 2) {
        std::cerr << "uso: show_nfa ARCHIVO.nfa\n";
        return 2;
    }
    try {
        Nfa n = load_nfa(argv[1]);
        std::cout << "Q  = {";
        for (std::size_t i = 0; i < n.states.size(); i++) {
            std::cout << (i > 0 ? ", " : "") << n.states[i];
        }
        std::cout << "}\nΣ  = {";
        for (std::size_t i = 0; i < n.alphabet.size(); i++) {
            std::cout << (i > 0 ? ", " : "") << n.alphabet[i];
        }
        std::cout << "}\nq0 = " << n.start << "\nF  = {";
        bool first = true;
        for (const std::string& state : n.states) {
            if (n.accept.count(state) > 0) {
                std::cout << (first ? "" : ", ") << state;
                first = false;
            }
        }
        std::cout << "}\n\n";

        // Las columnas: los símbolos y, al final, ε.
        std::vector<char> symbols = n.alphabet;
        symbols.push_back(EPS);
        std::vector<std::string> heads;
        for (char a : symbols) {
            heads.push_back(a == EPS ? "ε" : std::string(1, a));
        }
        std::size_t name_width = 1;
        for (const std::string& state : n.states) {
            name_width = std::max(name_width, state.size());
        }
        std::vector<std::size_t> width(symbols.size(), 1);
        bool has_eps = false;
        for (const std::string& state : n.states) {
            for (std::size_t j = 0; j < symbols.size(); j++) {
                width[j] = std::max(width[j], set_name(n, delta_of(n, state, symbols[j])).size());
            }
            has_eps = has_eps || !delta_of(n, state, EPS).empty();
        }
        // La última columna va sin relleno, para no dejar espacios al final de la línea.
        std::cout << "     " << padded("δ", name_width);
        for (std::size_t j = 0; j < symbols.size(); j++) {
            std::cout << "  " << (j + 1 < symbols.size() ? padded(heads[j], width[j]) : heads[j]);
        }
        std::cout << '\n';
        for (const std::string& state : n.states) {
            std::cout << (state == n.start ? "-> " : "   ") << (n.accept.count(state) > 0 ? "* " : "  ")
                      << padded(state, name_width);
            for (std::size_t j = 0; j < symbols.size(); j++) {
                std::string cell = set_name(n, delta_of(n, state, symbols[j]));
                std::cout << "  " << (j + 1 < symbols.size() ? padded(cell, width[j]) : cell);
            }
            std::cout << '\n';
        }
        if (has_eps) {
            std::cout << "\nclausura ε de cada estado:\n";
            for (const std::string& state : n.states) {
                std::cout << "  E({" << state << "}) = " << set_name(n, eps_closure(n, {state})) << '\n';
            }
        } else {
            std::cout << "\nno tiene transiciones ε: E(S) = S para todo conjunto S\n";
        }
    } catch (const std::runtime_error& error) {
        std::cerr << "error: " << error.what() << '\n';
        return 1;
    }
}
