// Verificador del laboratorio: una instancia de PCP puede tener muchas soluciones, así que no
// se compara el texto. Se llama como `verificador caso.in caso.out salida` y termina con 0 si
// la salida es correcta.
//   - Si la salida es una secuencia de fichas, se comprueba que tiene entre 1 y N fichas, que
//     todas existen y que arriba y abajo se lee la misma cadena.
//   - Si la salida es `sin solución hasta N`, solo se acepta cuando la referencia tampoco
//     encontró una. La referencia busca en anchura: si hay una solución de a lo sumo N fichas,
//     la encuentra.
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

struct Domino {
    std::string top;
    std::string bottom;
};

static int fail(const std::string& reason) {
    std::cout << reason << "\n";
    return 1;
}

int main(int argc, char** argv) {
    if (argc != 4) return fail("uso: verificador caso.in caso.out salida");
    std::ifstream input(argv[1]);
    std::ifstream expected(argv[2]);
    std::ifstream output(argv[3]);
    if (!input || !expected || !output) return fail("no se pudo abrir un archivo");

    std::string word;
    int count = 0;
    input >> word >> count;
    std::vector<Domino> dominoes(count);
    for (Domino& d : dominoes) input >> d.top >> d.bottom;
    int bound = 0;
    input >> word >> bound;

    std::string first_expected;
    expected >> first_expected;
    const bool reference_found = first_expected != "sin";

    std::vector<std::string> words;
    while (output >> word) words.push_back(word);
    if (words.empty()) return fail("la salida está vacía");

    if (words[0] == "sin") {
        const std::vector<std::string> wanted{"sin", "solución", "hasta", std::to_string(bound)};
        if (words != wanted) return fail("se esperaba exactamente: sin solución hasta " + std::to_string(bound));
        if (reference_found) return fail("sí hay una solución de a lo sumo " + std::to_string(bound) + " fichas");
        return 0;
    }

    if (static_cast<int>(words.size()) > bound) {
        return fail("la secuencia tiene " + std::to_string(words.size()) + " fichas y la cota es " + std::to_string(bound));
    }
    std::string top;
    std::string bottom;
    for (const std::string& text : words) {
        // Un número de ficha: solo dígitos, entre 1 y k.
        if (text.empty() || text.size() > 6 || text.find_first_not_of("0123456789") != std::string::npos) {
            return fail("no es un número de ficha: " + text);
        }
        const int index = std::stoi(text);
        if (index < 1 || index > count) return fail("no existe la ficha " + text);
        top += dominoes[index - 1].top;
        bottom += dominoes[index - 1].bottom;
    }
    if (top != bottom) return fail("la secuencia no es una solución: arriba y abajo se leen cadenas distintas");
    return 0;
}
