// Pruebas de la sesión B: los análisis por casos de los apuntes, comprobados división por
// división con p pequeños. Cada demostración dice qué exponente usar en cada caso; aquí se
// revisa que ese exponente saca la cadena del lenguaje en todas las divisiones del caso.
#include <cassert>
#include <cstddef>
#include <iostream>
#include <set>
#include <string>

#include "pumping.h"

namespace {

std::string repeat(char c, std::size_t n) {
    return std::string(n, c);
}

// v o y tienen dos símbolos distintos: abarcan el borde entre dos bloques.
bool straddles(const std::string& part) {
    return std::set<char>(part.begin(), part.end()).size() >= 2;
}

std::string v_of(const std::string& s, const Division& d) {
    return s.substr(d.u, d.v);
}

std::string y_of(const std::string& s, const Division& d) {
    return s.substr(d.u + d.v + d.x, d.y);
}

}  // namespace

int main() {
    // pump y divisions hacen lo que dicen.
    Division d = {1, 1, 2, 1};  // a | b | cd | e | f
    assert(pump("abcdef", d, 0) == "acdf");
    assert(pump("abcdef", d, 1) == "abcdef");
    assert(pump("abcdef", d, 3) == "abbbcdeeef");
    for (const Division& each : divisions("abcdef", 3)) {
        assert(each.v + each.y > 0 && each.v + each.x + each.y <= 3);
        assert(pump("abcdef", each, 1) == "abcdef");
    }
    assert(divisions("abc", 1).size() == 6);

    std::size_t checked = 0;
    for (std::size_t p = 1; p <= 7; p++) {
        // { a^n b^n c^n } con s = a^p b^p c^p: en los dos casos sirve i = 2.
        std::string s = repeat('a', p) + repeat('b', p) + repeat('c', p);
        for (const Division& each : divisions(s, p)) {
            assert(!is_anbncn(pump(s, each, 2)));
            checked++;
        }

        // { a^i b^j c^k : i ≤ j ≤ k } con la misma s.
        for (const Division& each : divisions(s, p)) {
            std::string v = v_of(s, each);
            std::string y = y_of(s, each);
            std::string vy = v + y;
            if (straddles(v) || straddles(y)) {
                assert(!is_ordered_abc(pump(s, each, 2)));  // caso 1: queda desordenada
            } else if (vy.find('a') == std::string::npos) {
                assert(!is_ordered_abc(pump(s, each, 0)));  // caso 2a: sin a, hacia abajo
            } else {
                assert(!is_ordered_abc(pump(s, each, 2)));  // caso 2b: con a, hacia arriba
            }
            checked++;
        }
        // Bombear solo hacia arriba no alcanza: hay divisiones que con i = 2 siguen en el lenguaje.
        PumpReport ordered = pump_report(is_ordered_abc, s, p);
        assert(ordered.out_with_0 > 0 && ordered.survive == 0);
        assert(ordered.out_with_2 + ordered.out_with_0 == ordered.total);

        // { ww } con s = 0^p 1^p 0^p 1^p.
        std::string t = repeat('0', p) + repeat('1', p) + repeat('0', p) + repeat('1', p);
        for (const Division& each : divisions(t, p)) {
            if (straddles(v_of(t, each)) || straddles(y_of(t, each))) {
                assert(!is_ww(pump(t, each, 0)));  // caso 2: v o y abarca dos bloques, hacia abajo
            } else {
                assert(!is_ww(pump(t, each, 2)));  // caso 1: cada una dentro de un bloque, hacia arriba
            }
            checked++;
        }

        // { ww } con la mala elección s = 0^p 1 0^p 1: desde p = 3 el adversario tiene una
        // división que sobrevive, la de los apuntes.
        if (p >= 3) {
            std::string bad = repeat('0', p) + "1" + repeat('0', p) + "1";
            Division escape = {p - 1, 1, 1, 1};  // u = 0^(p-1), v = 0, x = 1, y = 0
            assert(v_of(bad, escape) == "0" && y_of(bad, escape) == "0");
            for (std::size_t i = 0; i <= 8; i++) {
                assert(is_ww(pump(bad, escape, i)));
            }
            assert(pump_report(is_ww, bad, p).survive > 0);
        }

        // { 0^n 1^n } sí es libre de contexto: para p ≥ 2 alguna división sobrevive.
        if (p >= 2) {
            std::string zeros_ones = repeat('0', p) + repeat('1', p);
            Division middle = {p - 1, 1, 0, 1};  // v = 0, y = 1, pegados al medio
            for (std::size_t i = 0; i <= 8; i++) {
                assert(is_zeros_ones(pump(zeros_ones, middle, i)));
            }
        }
    }
    // Los números de la tabla de los apuntes, con p = 6.
    PumpReport report = pump_report(is_anbncn, repeat('a', 6) + repeat('b', 6) + repeat('c', 6), 6);
    assert(report.total == 1106 && report.out_with_2 == 1106);
    report = pump_report(is_ordered_abc, repeat('a', 6) + repeat('b', 6) + repeat('c', 6), 6);
    assert(report.out_with_2 == 843 && report.out_with_0 == 263);
    report = pump_report(is_ww, repeat('0', 6) + repeat('1', 6) + repeat('0', 6) + repeat('1', 6), 6);
    assert(report.total == 1568 && report.survive == 0);

    // El lema de los cuatro bloques: si 0^a 1^b 0^c 1^d = ww con a, b, c, d ≥ 1, entonces a = c y b = d.
    for (std::size_t a = 1; a <= 6; a++) {
        for (std::size_t b = 1; b <= 6; b++) {
            for (std::size_t c = 1; c <= 6; c++) {
                for (std::size_t e = 1; e <= 6; e++) {
                    std::string w = repeat('0', a) + repeat('1', b) + repeat('0', c) + repeat('1', e);
                    assert(is_ww(w) == (a == c && b == e));
                }
            }
        }
    }

    std::cout << "test_pumping: ok (" << checked << " divisiones revisadas caso por caso)\n";
}
