// La diagonal sobre una lista finita y explícita: a partir de una tabla de respuestas se arma
// una fila que difiere de cada fila de la tabla en la casilla de la diagonal.
#pragma once

#include <cstddef>
#include <string>
#include <vector>

// Un decididor de juguete: un nombre y una función que acepta o rechaza cada cadena.
struct Decider {
    std::string name;
    bool (*accepts)(const std::string&);
};

// Las primeras n cadenas binarias en el orden de la semana 1: por longitud y, a igual longitud,
// en el orden del alfabeto. La cadena vacía es "".
inline std::vector<std::string> first_strings(std::size_t n) {
    std::vector<std::string> result;
    for (std::size_t length = 0; result.size() < n; length++) {
        for (std::size_t value = 0; value < (std::size_t{1} << length) && result.size() < n; value++) {
            std::string w(length, '0');
            for (std::size_t i = 0; i < length; i++) {
                if ((value >> (length - 1 - i)) & 1u) {
                    w[i] = '1';
                }
            }
            result.push_back(w);
        }
    }
    return result;
}

// table[i][j] dice si la máquina i acepta la cadena j.
inline std::vector<std::vector<bool>> answer_table(const std::vector<Decider>& machines,
                                                   const std::vector<std::string>& strings) {
    std::vector<std::vector<bool>> table;
    for (const Decider& m : machines) {
        std::vector<bool> row;
        for (const std::string& w : strings) {
            row.push_back(m.accepts(w));
        }
        table.push_back(row);
    }
    return table;
}

// La fila de D: con la cadena i hace lo contrario de lo que la máquina i hace con la cadena i.
inline std::vector<bool> diagonal_row(const std::vector<std::vector<bool>>& table) {
    std::vector<bool> row;
    for (std::size_t i = 0; i < table.size(); i++) {
        row.push_back(!table[i][i]);
    }
    return row;
}

// Seis decididores sencillos, para tener una lista concreta.
inline std::vector<Decider> sample_machines() {
    return {
        {"M1: acepta todo", [](const std::string&) { return true; }},
        {"M2: no acepta nada", [](const std::string&) { return false; }},
        {"M3: longitud par", [](const std::string& w) { return w.size() % 2 == 0; }},
        {"M4: termina en 1", [](const std::string& w) { return !w.empty() && w.back() == '1'; }},
        {"M5: contiene un 0", [](const std::string& w) { return w.find('0') != std::string::npos; }},
        {"M6: empieza con 1", [](const std::string& w) { return !w.empty() && w.front() == '1'; }},
    };
}
