// El juego del lema de bombeo, jugado completo para un p concreto: pumping_game PARTIDA P
// Nosotros elegimos la cadena s (que depende de p) y el exponente i. El programa recorre
// todas las divisiones que el adversario puede elegir, con |xy| ≤ p y |y| > 0, y dice en cuáles
// x y^i z quedó fuera del lenguaje. Sin argumentos, lista las partidas.
// Jugar con un p no demuestra nada: la demostración tiene que valer para todo p. Sirve para
// encontrar el error en una demostración antes de escribirla.
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

#include "pumping.h"

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

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) {
    std::vector<Game> games = chapter_games();
    if (argc != 3) {
        std::cerr << "uso: pumping_game PARTIDA P\npartidas:";
        for (const Game& game : games) {
            std::cerr << ' ' << game.name;
        }
        std::cerr << '\n';
        return 2;
    }
    try {
        std::string name = argv[1];
        std::size_t p = std::stoul(argv[2]);
        for (const Game& game : games) {
            if (game.name != name) {
                continue;
            }
            std::string s = game.choose_string(p);
            std::vector<Split> splits = legal_splits(s, p);
            std::cout << "L = " << game.language << "\nel adversario elige p = " << p << "\nnosotros elegimos s = "
                      << shown(s) << ", con |s| = " << s.size() << (game.in_language(s) ? " y s ∈ L" : " y s ∉ L")
                      << "\nnuestro exponente: i = " << game.exponent << "\ndivisiones posibles con |xy| ≤ " << p
                      << " y |y| > 0: " << splits.size() << '\n';
            std::size_t wx = 1, wy = 1, wz = 1, wr = 7;
            for (const Split& split : splits) {
                wr = std::max(wr, pumped(split, game.exponent).size());
                wx = std::max(wx, split.x.size());
                wy = std::max(wy, split.y.size());
                wz = std::max(wz, split.z.size());
            }
            std::cout << "  " << padded("x", wx) << "  " << padded("y", wy) << "  " << padded("z", wz)
                      << "  x y^i z\n";
            std::size_t survive = 0;
            for (const Split& split : splits) {
                std::string result = pumped(split, game.exponent);
                bool inside = game.in_language(result);
                survive += inside ? 1 : 0;
                std::cout << "  " << padded(shown(split.x), wx) << "  " << padded(split.y, wy) << "  "
                          << padded(shown(split.z), wz) << "  " << padded(shown(result), wr)
                          << (inside ? "  ∈ L: el adversario resiste" : "  ∉ L") << '\n';
            }
            if (survive == 0) {
                std::cout << "en las " << splits.size() << " divisiones la cadena bombeada sale de L\n";
            } else {
                std::cout << "el adversario tiene " << survive << (survive == 1 ? " división" : " divisiones")
                          << " que resiste" << (survive == 1 ? "" : "n") << ": con esta jugada no se demuestra nada\n";
            }
            return 0;
        }
        std::cerr << "no hay una partida llamada " << name << '\n';
        return 2;
    } catch (const std::exception& error) {
        std::cerr << "error: " << error.what() << '\n';
        return 1;
    }
}
