#include <random>
#include<bit>
#include "bit14/bit14.h"

template <typename T>
void test_popcount(const T a)
{
    const int result1 = std::popcount(a);
    const int result2 = bit14::popcount(a);

    if (result1 != result2)
    {
        std::cout << "error test_popcount!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }

}

template <typename T>
void test_countl_zero(const T a)
{
    const int result1 = std::countl_zero(a);
    const int result2 = bit14::countl_zero(a);

    if (result1 != result2)
    {
        std::cout << "error test_countl_zero!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_countl_one(const T a)
{
    const int result1 = std::countl_one(a);
    const int result2 = bit14::countl_one(a);

    if (result1 != result2)
    {
        std::cout << "error test_countl_one!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_countr_zero(const T a)
{
    const int result1 = std::countr_zero(a);
    const int result2 = bit14::countr_zero(a);

    if (result1 != result2)
    {
        std::cout << "error test_countr_zero!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_countr_one(const T a)
{
    const int result1 = std::countr_one(a);
    const int result2 = bit14::countr_one(a);

    if (result1 != result2)
    {
        std::cout << "error test_countr_one!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_rotl(const T a, const int rot)
{
    const T result1 = std::rotl(a, rot);
    const T result2 = bit14::rotl(a, rot);

    if (result1 != result2)
    {
        std::cout << "error test_rotl!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_rotr(const T a, const int rot)
{
    const T result1 = std::rotr(a, rot);
    const T result2 = bit14::rotr(a, rot);

    if (result1 != result2)
    {
        std::cout << "error test_rotr!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_bit_width(const T a)
{
    const int result1 = std::bit_width(a);
    const int result2 = bit14::bit_width(a);

    if (result1 != result2)
    {
        std::cout << "error test_bit_width!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_bit_floor(const T a)
{
    const T result1 = std::bit_floor(a);
    const T result2 = bit14::bit_floor(a);

    if (result1 != result2)
    {
        std::cout << "error test_bit_floor!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_bit_ceil(T a)
{
    a = a >> 1;
    const T result1 = std::bit_ceil(a);
    const T result2 = bit14::bit_ceil(a);

    if (result1 != result2)
    {
        std::cout << "error test_bit_ceil!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

template <typename T>
void test_single_bit(const T a)
{
    const bool result1 = std::has_single_bit(a);
    const bool result2 = bit14::has_single_bit(a);

    if (result1 != result2)
    {
        std::cout << "error test_single_bit!\n";
        std::cout << a << ", " << result1 << ", " << result2 << "\n";
    }
}

void test()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<unsigned long long> distrib(0, std::numeric_limits<unsigned long long>::max());
    std::uniform_int_distribution<int> rotate(std::numeric_limits<int>::lowest(), std::numeric_limits<int>::max());

    for (std::size_t i = 0; i < 1000000; ++i)
    {
        const int rot = rotate(gen);
        const unsigned long long ull = distrib(gen);
        const unsigned char uc = static_cast<unsigned char>(ull);
        const unsigned short us = static_cast<unsigned short>(ull);
        const unsigned int ui = static_cast<unsigned int>(ull);
        const unsigned long ul = static_cast<unsigned long>(ull);

        test_popcount(uc);
        test_popcount(us);
        test_popcount(ui);
        test_popcount(ul);
        test_popcount(ull);

        test_countl_zero(uc);
        test_countl_zero(us);
        test_countl_zero(ui);
        test_countl_zero(ul);
        test_countl_zero(ull);

        test_countl_one(uc);
        test_countl_one(us);
        test_countl_one(ui);
        test_countl_one(ul);
        test_countl_one(ull);

        test_countr_zero(uc);
        test_countr_zero(uc);
        test_countr_zero(uc);
        test_countr_zero(uc);
        test_countr_zero(uc);

        test_countr_one(uc);
        test_countr_one(uc);
        test_countr_one(uc);
        test_countr_one(uc);
        test_countr_one(uc);

        test_rotl(uc, rot);
        test_rotl(uc, rot);
        test_rotl(uc, rot);
        test_rotl(uc, rot);
        test_rotl(uc, rot);

        test_rotr(uc, rot);
        test_rotr(uc, rot);
        test_rotr(uc, rot);
        test_rotr(uc, rot);
        test_rotr(uc, rot);

        test_bit_width(uc);
        test_bit_width(uc);
        test_bit_width(uc);
        test_bit_width(uc);
        test_bit_width(uc);

        test_bit_floor(uc);
        test_bit_floor(uc);
        test_bit_floor(uc);
        test_bit_floor(uc);
        test_bit_floor(uc);

        test_bit_ceil(uc);
        test_bit_ceil(uc);
        test_bit_ceil(uc);
        test_bit_ceil(uc);
        test_bit_ceil(uc);

        test_single_bit(uc);
        test_single_bit(uc);
        test_single_bit(uc);
        test_single_bit(uc);
        test_single_bit(uc);
    }
}

int main()
{
    test();
    return 0;
}