// Pruebas de pit.h: el desarrollo, la evaluación y los números de pit_demo.
#include <cassert>
#include <cstdio>

#include "pit.h"

Factored one_to_ten() {
    Factored f;
    for (std::uint64_t root = 1; root <= 10; root++) {
        f.roots.push_back(root);
    }
    return f;
}

void test_expand() {
    const Factored small{{1, 2, 3, 4}};
    const Polynomial expanded = expand(small, kPrime);
    // x^4 - 10x^3 + 35x^2 - 50x + 24
    const std::vector<std::uint64_t> expected = {24, kPrime - 50, 35, kPrime - 10, 1};
    assert(expanded.coefficients == expected);
    assert(evaluate(small, 7, kPrime) == 360);
    assert(evaluate(expanded, 7, kPrime) == 360);
    // Un producto vacío vale 1, y el polinomio sin coeficientes vale 0.
    assert(evaluate(Factored{}, 5, kPrime) == 1);
    assert(evaluate(Polynomial{}, 5, kPrime) == 0);
    assert(expand(Factored{}, kPrime).coefficients == std::vector<std::uint64_t>{1});
}

// Las dos formas del mismo polinomio coinciden en todos los puntos, con cualquier módulo.
void test_same_polynomial() {
    const Factored f = one_to_ten();
    for (std::uint64_t p : {std::uint64_t{101}, std::uint64_t{7}, kPrime}) {
        const Polynomial expanded = expand(f, p);
        assert(expanded.coefficients.size() == 11);
        for (std::uint64_t x = 0; x < 200 && x < p; x++) {
            assert(evaluate(f, x, p) == evaluate(expanded, x, p));
        }
    }
}

// Dos polinomios distintos de grado a lo sumo 10 coinciden en a lo sumo 10 puntos de los 101.
void test_agreement_counts() {
    const std::uint64_t p = 101;
    const Factored f = one_to_ten();
    const Polynomial expanded = expand(f, p);
    assert(count_agreements(f, expanded, p) == 101);
    Polynomial one_wrong = expanded;
    one_wrong.coefficients[3] = (one_wrong.coefficients[3] + 1) % p;
    assert(count_agreements(f, one_wrong, p) == 1);    // la diferencia es x³: solo se anula en 0
    assert(count_agreements(f, Polynomial{{0}}, p) == 10);  // las raíces 1, ..., 10
    // Cualquier cambio en los coeficientes deja a lo sumo 10 coincidencias.
    std::mt19937_64 rng(7);
    for (int trial = 0; trial < 300; trial++) {
        Polynomial g = expanded;
        std::uint64_t& c = g.coefficients[rng() % g.coefficients.size()];
        c = (c + 1 + rng() % (p - 1)) % p;
        assert(count_agreements(f, g, p) <= 10);
    }
}

// Los conteos de pit_demo, con la misma semilla y el mismo orden.
void test_demo_table() {
    std::mt19937_64 rng(2015);
    const Factored f = one_to_ten();
    const int expected[2][3] = {{1000, 10, 102}, {1000, 0, 0}};
    int row = 0;
    for (std::uint64_t p : {std::uint64_t{101}, kPrime}) {
        const Polynomial expanded = expand(f, p);
        Polynomial one_wrong = expanded;
        one_wrong.coefficients[3] = (one_wrong.coefficients[3] + 1) % p;
        assert(count_agree_answers(f, expanded, 1000, rng, p) == expected[row][0]);
        assert(count_agree_answers(f, one_wrong, 1000, rng, p) == expected[row][1]);
        assert(count_agree_answers(f, Polynomial{{0}}, 1000, rng, p) == expected[row][2]);
        row++;
    }
}

int main() {
    test_expand();
    test_same_polynomial();
    test_agreement_counts();
    test_demo_table();
    std::printf("test_pit: correcto\n");
}
