// Minimiza un DFA y muestra la partición después de cada ronda: minimize ARCHIVO.dfa [opciones]
//   --dfa     escribe solo el DFA mínimo, en formato .dfa
//   --todos   no quita los estados inalcanzables antes de refinar (para ver qué pasa)
// Con - en lugar del archivo, lee la descripción de la entrada estándar.
// El detalle de cada ronda se imprime si el autómata tiene a lo sumo 26 estados.
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>

#include "dfa.h"
#include "minimize.h"

// Los bloques se muestran con letras: A, B, C, ...
static std::string letter(int block) {
    return std::string(1, static_cast<char>('A' + block));
}

static std::string padded(const std::string& text, std::size_t width) {
    return text + std::string(width > text.size() ? width - text.size() : 0, ' ');
}

static void print_partition(const Dfa& m, const Partition& p, std::size_t number, bool detail) {
    std::cout << "P" << number << ": " << p.count << (p.count == 1 ? " bloque" : " bloques") << '\n';
    if (!detail) {
        return;
    }
    std::vector<std::vector<std::string>> blocks = blocks_of(m, p);
    for (std::size_t i = 0; i < blocks.size(); i++) {
        std::cout << "  " << letter(static_cast<int>(i)) << " = {";
        for (std::size_t k = 0; k < blocks[i].size(); k++) {
            std::cout << (k > 0 ? ", " : "") << blocks[i][k];
        }
        std::cout << "}\n";
    }
}

// La tabla de una ronda: a qué bloque de p va cada estado con cada símbolo. Dentro de un
// bloque, los estados cuya fila es distinta de la del primero se separan de él.
static void print_round(const Dfa& m, const Partition& p, std::size_t number) {
    std::size_t width = 6;
    for (const std::string& state : m.states) {
        width = std::max(width, state.size());
    }
    std::cout << "ronda " << number << ": a qué bloque de P" << number - 1 << " va cada estado\n";
    std::cout << "  " << padded("estado", width) << "  está en";
    for (char a : m.alphabet) {
        std::cout << "  con " << a;
    }
    std::cout << '\n';
    for (const std::vector<std::string>& block : blocks_of(m, p)) {
        for (const std::string& state : block) {
            bool differs = false;
            std::string row = "  " + padded(state, width) + "  " + padded(letter(p.block.at(state)), 7);
            for (char a : m.alphabet) {
                int target = p.block.at(step(m, state, a));
                differs = differs || target != p.block.at(step(m, block[0], a));
                row += "  " + padded(letter(target), 5);
            }
            if (differs) {
                row += "  <- se separa";
            }
            while (row.back() == ' ') {
                row.pop_back();
            }
            std::cout << row << '\n';
        }
    }
}

int main(int argc, char** argv) {
    std::string path;
    bool only_dfa = false;
    bool keep_all = false;
    for (int i = 1; i < argc; i++) {
        std::string arg = argv[i];
        if (arg == "--dfa") {
            only_dfa = true;
        } else if (arg == "--todos") {
            keep_all = true;
        } else if (path.empty()) {
            path = arg;
        } else {
            path.clear();
            break;
        }
    }
    if (path.empty()) {
        std::cerr << "uso: minimize ARCHIVO.dfa [--dfa] [--todos]\n";
        return 2;
    }
    try {
        Dfa original = (path == "-") ? read_dfa(std::cin) : load_dfa(path);
        Dfa m = keep_all ? original : remove_unreachable(original);
        std::vector<Partition> rounds = moore_rounds(m);
        Dfa minimal = quotient(m, rounds.back());
        if (only_dfa) {
            std::cout << "# DFA mínimo de " << path << ": " << minimal.states.size() << " estados.\n";
            write_dfa(std::cout, minimal);
            return 0;
        }

        std::cout << "estados: " << original.states.size() << ", alcanzables: " << reachable(original).size();
        if (keep_all) {
            std::cout << ". No se quita ninguno (--todos)\n";
        } else if (m.states.size() == original.states.size()) {
            std::cout << ". No hay nada que quitar\n";
        } else {
            std::cout << ". Se quitan:";
            std::set<std::string> kept(m.states.begin(), m.states.end());
            for (const std::string& state : original.states) {
                if (kept.count(state) == 0) {
                    std::cout << ' ' << state;
                }
            }
            std::cout << '\n';
        }
        bool detail = m.states.size() <= 26;
        std::cout << '\n';
        print_partition(m, rounds[0], 0, detail);
        for (std::size_t k = 1; k <= rounds.size(); k++) {
            if (detail) {
                std::cout << '\n';
                print_round(m, rounds[k - 1], k);
            }
            if (k < rounds.size()) {
                print_partition(m, rounds[k], k, detail);
            }
        }
        std::cout << "P" << rounds.size() << " = P" << rounds.size() - 1 << ": la partición ya no cambia\n";
        std::cout << "\nDFA mínimo: " << minimal.states.size()
                  << (minimal.states.size() == 1 ? " estado" : " estados") << '\n';
        if (detail) {
            write_dfa(std::cout, minimal);
        }
    } catch (const std::runtime_error& error) {
        std::cerr << "error: " << error.what() << '\n';
        return 1;
    }
}
