// Pruebas de lo que los apuntes afirman sobre las construcciones de la semana: el literal, el
// programa que imprime un texto, el molde que se completa consigo mismo, la frase que se
// describe a sí misma y los conteos de la complejidad de Kolmogorov.
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <stdexcept>
#include <string>
#include <vector>

#include "self.h"

// Lee un literal común de C++ (el que escribe cpp_literal) y devuelve el texto que denota.
static std::string read_literal(const std::string& lit) {
    assert(lit.size() >= 2 && lit.front() == '"' && lit.back() == '"');
    std::string out;
    for (std::size_t i = 1; i + 1 < lit.size(); i++) {
        if (lit[i] == '\\') {
            i++;
            assert(i + 1 < lit.size());
            out += (lit[i] == 'n') ? '\n' : lit[i];
        } else {
            assert(lit[i] != '"' && lit[i] != '\n');
            out += lit[i];
        }
    }
    return out;
}

static void test_literal() {
    assert(cpp_literal("hola") == "\"hola\"");
    assert(cpp_literal("a\"b") == "\"a\\\"b\"");
    assert(cpp_literal("a\\b\n") == "\"a\\\\b\\n\"");
    // Leer el literal devuelve el texto, también cuando el texto ya es un literal.
    std::string w = "int main() {}\n";
    for (int k = 0; k < 6; k++) {
        assert(read_literal(cpp_literal(w)) == w);
        w = cpp_literal(w) + "\n";
    }
    // El literal siempre es más largo que el texto: al menos las dos comillas.
    for (const std::string& s : {std::string(""), std::string("x"), std::string("\"\\\n")}) {
        assert(cpp_literal(s).size() >= s.size() + 2);
    }
}

static void test_printer() {
    // printer_of(w) contiene el literal de w, así que es más largo que w: ningún texto es
    // igual al programa que lo imprime. Es la razón por la que el intento ingenuo no termina.
    std::string p = "int main() {}\n";
    std::vector<std::size_t> sizes;
    for (int k = 0; k <= 8; k++) {
        sizes.push_back(p.size());
        const std::string next = printer_of(p);
        assert(next.size() > p.size());
        assert(next != p);
        // El programa siguiente contiene el literal del anterior, y ese literal denota al anterior.
        const std::size_t from = next.find('"', next.find("cout"));
        const std::size_t to = next.rfind('"');
        assert(read_literal(next.substr(from, to - from + 1)) == p);
        p = next;
    }
    // Los tamaños de la tabla de los apuntes.
    const std::vector<std::size_t> expected = {14, 67, 124, 188, 266, 372, 534, 808, 1306};
    assert(sizes == expected);
}

static void test_fill_hole() {
    // El programa completo es: antes de la arroba, el molde como literal, después de la arroba.
    const std::string tpl = "AAA @ BBB";
    assert(fill_hole(tpl) == "AAA R\"~(AAA @ BBB)~\" BBB");
    // El molde aparece entero, como datos, dentro del programa.
    assert(fill_hole(tpl).find(tpl) != std::string::npos);
    // El tamaño: dos veces el molde, menos la arroba, más los siete caracteres de R"~( y )~".
    for (const std::string& t : {std::string("@"), std::string("x@y@z"), std::string("uno\n@\ndos\n")}) {
        assert(fill_hole(t).size() == 2 * t.size() - 1 + 7);
    }
    // Solo la primera arroba es el hueco.
    assert(fill_hole("x@y@z") == "xR\"~(x@y@z)~\"y@z");
    // Lo que el programa hace al correr: con el texto del literal vuelve a armarse a sí mismo.
    // Aquí se hace la misma cuenta a mano, sin compilar nada.
    const std::string program = fill_hole(tpl);
    const std::size_t open = program.find("R\"~(") + 4;
    const std::size_t close = program.find(")~\"");
    const std::string text = program.substr(open, close - open);
    assert(text == tpl);
    const std::size_t hole = text.find('@');
    assert(text.substr(0, hole) + "R\"~(" + text + ")~\"" + text.substr(hole + 1) == program);
    // Dos moldes que no sirven.
    bool failed = false;
    try {
        fill_hole("sin hueco");
    } catch (const std::invalid_argument&) {
        failed = true;
    }
    assert(failed);
    failed = false;
    try {
        fill_hole("@ con el cierre )~\" adentro");
    } catch (const std::invalid_argument&) {
        failed = true;
    }
    assert(failed);
}

static void test_sentence() {
    // La frase que se describe a sí misma. La instrucción dice qué hacer con el texto que
    // sigue a los dos puntos: escribirlo dos veces, la segunda vez entre comillas.
    const std::string part = "Escriban dos veces lo que sigue, la segunda vez entre comillas:";
    const std::string sentence = part + " «" + part + "»";
    // Obedecer la instrucción: tomar lo que está entre comillas y escribirlo dos veces.
    const std::size_t open = sentence.find("«") + std::string("«").size();
    const std::size_t close = sentence.find("»");
    const std::string quoted = sentence.substr(open, close - open);
    const std::string result = quoted + " «" + quoted + "»";
    assert(result == sentence);
}

static void test_counting() {
    // Cadenas binarias de longitud menor que n: 2^0 + 2^1 + ... + 2^(n-1) = 2^n - 1.
    for (std::uint64_t n = 0; n <= 60; n++) {
        std::uint64_t shorter = 0;
        for (std::uint64_t len = 0; len < n; len++) {
            shorter += std::uint64_t{1} << len;
        }
        assert(shorter == (std::uint64_t{1} << n) - 1);
        assert(shorter < (std::uint64_t{1} << n));  // menos descripciones que cadenas de longitud n
    }
    // Cadenas de longitud n que se pueden comprimir c bits o más: a lo sumo 2^(n-c+1) - 1.
    // Para n = 1000000 y c = 10, la fracción es menor que 2^(-9) = 1/512.
    for (std::uint64_t n = 10; n <= 60; n++) {
        for (std::uint64_t c = 1; c <= n; c++) {
            const std::uint64_t descriptions = (std::uint64_t{1} << (n - c + 1)) - 1;  // longitud <= n - c
            // descriptions / 2^n < 2^(1-c)
            assert(descriptions < (std::uint64_t{1} << (n - c + 1)));
        }
    }
}

int main() {
    test_literal();
    test_printer();
    test_fill_hole();
    test_sentence();
    test_counting();
    std::puts("test_self: ok");
    return 0;
}
