// Comprueba que un conjunto de cadenas es distinguible dos a dos respecto del lenguaje de un DFA:
//   fooling_set ARCHIVO.dfa CADENA CADENA...
// Imprime, para cada par, el sufijo más corto que lo distingue. Si todos los pares tienen
// uno, ningún DFA del mismo lenguaje tiene menos estados que cadenas hay en el conjunto.
// La cadena vacía se pasa como '' en la terminal.
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>

#include "dfa.h"
#include "distinguish.h"

static std::string shown(const std::string& w) {
    return w.empty() ? "ε" : w;
}

// ε ocupa dos bytes y una columna.
static std::string padded(const std::string& text, std::size_t width) {
    std::size_t columns = (text == "ε") ? 1 : text.size();
    return text + std::string(width > columns ? width - columns : 0, ' ');
}

int main(int argc, char** argv) {
    if (argc < 4) {
        std::cerr << "uso: fooling_set ARCHIVO.dfa CADENA CADENA...\n";
        return 2;
    }
    try {
        Dfa m = load_dfa(argv[1]);
        std::vector<std::string> strings(argv + 2, argv + argc);
        std::size_t n = strings.size();
        std::vector<std::vector<std::string>> cell(n, std::vector<std::string>(n, "."));
        std::size_t width = 1;
        std::size_t failures = 0;
        for (std::size_t i = 0; i < n; i++) {
            width = std::max(width, strings[i].size());
            for (std::size_t j = i + 1; j < n; j++) {
                std::optional<std::string> z = distinguishing_suffix(m, strings[i], strings[j]);
                cell[i][j] = z ? shown(*z) : "NO";
                width = std::max(width, z ? z->size() : 2);
                if (!z) {
                    failures++;
                    std::cout << shown(strings[i]) << " y " << shown(strings[j]) << " no son distinguibles: las dos llegan a "
                              << "estados que ningún sufijo separa\n";
                }
            }
        }
        std::cout << "sufijo más corto que distingue a cada par (fila, columna):\n";
        std::cout << "  " << padded("", width);
        for (std::size_t j = 1; j < n; j++) {
            std::cout << "  " << (j + 1 < n ? padded(shown(strings[j]), width) : shown(strings[j]));
        }
        std::cout << '\n';
        for (std::size_t i = 0; i + 1 < n; i++) {
            std::cout << "  " << padded(shown(strings[i]), width);
            for (std::size_t j = 1; j < n; j++) {
                std::cout << "  " << (j + 1 < n ? padded(cell[i][j], width) : cell[i][j]);
            }
            std::cout << '\n';
        }
        if (failures > 0) {
            std::cout << failures << (failures == 1 ? " par" : " pares") << " sin sufijo: el conjunto no sirve\n";
            return 1;
        }
        std::cout << n << " cadenas distinguibles dos a dos: todo DFA de este lenguaje tiene al menos " << n
                  << " estados (este tiene " << m.states.size() << ")\n";
    } catch (const std::runtime_error& error) {
        std::cerr << "error: " << error.what() << '\n';
        return 1;
    }
}
