#include <ratio>
#include <string_view>
#include <random>
#include <tuple>

Describe(fixed_tests)
{
    It(addition_tests)
    {
        do_add_test<Polynomial<std::ratio<7>, std::ratio<5>>,
                    Polynomial<std::ratio<3>, std::ratio<1>>,
                    Polynomial<std::ratio<10>, std::ratio<6>>>();
      
        do_add_test<Polynomial<std::ratio<7>, std::ratio<5>>,
                    Polynomial<std::ratio<3>, std::ratio<1>>,
                    Polynomial<std::ratio<10>, std::ratio<6>>>();
      
        do_add_test<Polynomial<std::ratio<10>, std::ratio<20>>,
                    Polynomial<std::ratio<30>>,
                    Polynomial<std::ratio<10>, std::ratio<50>>>();
      
        do_add_test<Polynomial<std::ratio<25>, std::ratio<3>>,
                    Polynomial<std::ratio<-25>, std::ratio<10>>,
                    Polynomial<std::ratio<13>>>();
      
        do_add_test<Polynomial<std::ratio<7>>,
                    Polynomial<std::ratio<-7>>,
                    Polynomial<std::ratio<0>>>();
      
        do_add_test<Polynomial<std::ratio<7>, std::ratio<6>, std::ratio<5>>,
                    Polynomial<std::ratio<0>>,
                    Polynomial<std::ratio<7>, std::ratio<6>, std::ratio<5>>>();
      
        do_add_test<Polynomial<std::ratio<7>, std::ratio<6>, std::ratio<5>>,
                    Polynomial<std::ratio<-7>, std::ratio<-6>, std::ratio<-5>>,
                    Polynomial<std::ratio<0>>>();
    }
  
    It(differentiation_tests)
    {
        do_diff_test<Polynomial<std::ratio<30>, std::ratio<20>, std::ratio<10>>,
                     Polynomial<std::ratio<60>, std::ratio<20>>>();
      
        do_diff_test<Polynomial<std::ratio<60>, std::ratio<20>>,
                    Polynomial<std::ratio<60>>>();
      
        do_diff_test<Polynomial<std::ratio<60>>,
                     Polynomial<std::ratio<0>>>();
      
        do_diff_test<Polynomial<std::ratio<5, 3>, std::ratio<98, 5>, std::ratio<3>, std::ratio<98>>,
                     Polynomial<std::ratio<5>, std::ratio<196, 5>, std::ratio<3>>>();
      
        do_diff_test<Polynomial<std::ratio<0>>,
                     Polynomial<std::ratio<0>>>();
    }
  
    It(integration_tests)
    {
        do_integ_test<Polynomial<std::ratio<0>>,
                      std::ratio<-1, 5>,
                      Polynomial<std::ratio<-1, 5>>>();
      
        do_integ_test<Polynomial<std::ratio<10>>,
                      std::ratio<20>,
                      Polynomial<std::ratio<10>, std::ratio<20>>>();
      
        do_integ_test<Polynomial<std::ratio<10>, std::ratio<20>>,
                      std::ratio<5, 2>,
                      Polynomial<std::ratio<5>, std::ratio<20>, std::ratio<5, 2>>>();
      
        do_integ_test<Polynomial<std::ratio<-5>, std::ratio<2>, std::ratio<10>>,
                      std::ratio<0>,
                      Polynomial<std::ratio<-5, 3>, std::ratio<1>, std::ratio<10>, std::ratio<0>>>();
    }
};

#include <string>
#include <utility>

Describe(fixed_test_cases)
{
    It(basic_thunk_tests)
    {
        // Currently stores 3.
        Thunk num1 = MakeThunk::now(3);
        // Currently stores 3 * 2 ==> 6.
        Thunk num2 = num1.chain([](auto n) { return n * 2; });
        // Delayed computation of the number formed by concatenating num1 and num2 as strings.
        const Thunk num3 = MakeThunk::delay([&]() { return std::stoi(std::to_string(num1.get()) + std::to_string(num2.get())); });
      
        Assert::That(num2.get(), Equals(6));
        Assert::That(num1.get(), Equals(3));
      
        // Change num2 to 0.
        num2 = MakeThunk::delay([]() { return 0; });
      
        // Since Thunks delay computation, it actually computes 30 (up to date) and not 36 (outdated).
        Assert::That(num3.get(), Equals(30));
      
        // Change num1 to 4.
        num1 = MakeThunk::now(4);
      
        // Thunk only computed once - unaffected by change. Remains 30 instead of 40.
        Assert::That(num3.get(), Equals(30));
    }
  
    It(can_chain_different_types)
    {
        // First chain returns int, second returns std::pair<int, int>, third returns string.
        const Thunk birthday_msg = MakeThunk::now(24)
                                              .chain([](auto n) { return std::pair{ n, n + 1 }; })
                                              .chain([](auto ages) { return "Do you know what is funnier than " + std::to_string(ages.first) + "? " + std::to_string(ages.second) + "!"; });
        
        Assert::That(birthday_msg.get(),
                     Equals("Do you know what is funnier than 24? 25!"));                                    
    }
  
    It(allows_cyclic_ref)
    {
        using LazyPair = std::pair<int, Thunk<int>>;
        // Second item of pair is 5 times the first (i.e., 10 * 5 == 50).
        LazyPair lazy_pair{ 10, MakeThunk::delay([&]() { return lazy_pair.first * 5; })};
        
        Assert::That(lazy_pair.second.get(), Equals(50));                                    
    }
  
    It(successfully_extends_lifetime)
    {
        Thunk<int> remaining_thunk{};
        
        // Scope to restrict the lifetime of `expiring_thunk`. `remaining_thunk` depends on its data.
        {
            Thunk expiring_thunk = MakeThunk::now(3);
            remaining_thunk = expiring_thunk.chain([](auto n) { return n * 2; });
        }
      
        // Thunk class should successfully extend the lifetime of the data of other Thunks it depends on.
        Assert::That(remaining_thunk.get(), Equals(6));
    }
};

// Look through the test output logs and expand to reveal commentary. No need to check the test code.

#include <random>
#include <functional>
#include <fmt/ranges.h>

Describe(pitfalls_of_using_bind_without_ref)
{
    It(context)
    {
        std::cout << R"(std::bind(distrib, engine) makes a copy of the engine at the time of its invocation.
Therefore, if you create different random-generation functions that
use std::bind, each time you call them, it’s as if you’re
generating the first number from the same initial
engine state. This can result in a very non-random output at times.)";
    }

    It(using_multiple_functions)
    {
        std::mt19937 engine{ std::random_device{}() };
        std::function<int()> gen_a = std::bind(std::uniform_int_distribution{-1000, 1000}, engine);
        std::function<int()> gen_b = std::bind(std::uniform_int_distribution{-1000, 1000}, engine);
        std::cout << "std::function<int()> gen_a\n   = std::bind(std::uniform_int_distribution{-1000, 1000}, engine);\n";
        std::cout << "std::function<int()> gen_b\n   = std::bind(std::uniform_int_distribution{-1000, 1000}, engine);\n\n";
      
        std::cout << "gen_a and gen_b seem like they would return different results (or so we think!).\nLet's call them in a loop\n\n";
        for (int i = 0; i < 10; ++i) {
            std::cout << "Next Iteration:\n"
                      << "gen_a(): " << gen_a() << '\n'
                      << "gen_b(): " << gen_b() << "\n\n";
        }
    }
  
    It(using_with_stl_algorithms)
    {
        std::mt19937 engine{ std::random_device{}() };
        std::function<int()> gen_int = std::bind(std::uniform_int_distribution{-1000, 1000}, engine);

        std::cout << "std::function<int()> gen_int\n   = std::bind(std::uniform_int_distribution{-1000, 1000}, engine);\n\n"
                  << "Let's make a loop where we create and fill up a\nvector with random ints each time.\n\n"
                  << "std::vector<int> vec(10);\n"
                  << "std::generate(vec.begin(), vec.end(), gen_int);\n\n";
  
        for (int i = 0; i < 3; ++i) {
            std::vector<int> vec(10);
            std::generate(vec.begin(), vec.end(), gen_int);

            std::cout << fmt::format("Iteration #{} using std::generate:\n{}\n\n", i, vec);
        }
      
        std::cout << "Same sequence every time :/.\n\nAfter all that, manually calling gen_int() a bunch of times\nalso returns the same sequence:\n";
        for (int _ = 0; _ < 10; ++_) std::cout << gen_int() << " ";
    }
};

Describe(solution1__bind_with_std_ref)
{
    It(context)
    {
        std::cout << R"(An easy solution is still using std::bind
but providing a reference-wrapper to the engine
via std::ref (from the <functional> header).

std::bind(std::uniform_int_distribution{-1000, 1000}, engine);
becomes...
std::bind(std::uniform_int_distribution{-1000, 1000}, std::ref(engine));
)";
    }

    It(using_multiple_functions)
    {
        std::mt19937 engine{ std::random_device{}() };
        std::function<int()> gen_a = std::bind(std::uniform_int_distribution{-1000, 1000}, std::ref(engine));
        std::function<int()> gen_b = std::bind(std::uniform_int_distribution{-1000, 1000}, std::ref(engine));
        std::cout << "std::function<int()> gen_a\n   = std::bind(std::uniform_int_distribution{-1000, 1000}, std::ref(engine));\n";
        std::cout << "std::function<int()> gen_b\n   = std::bind(std::uniform_int_distribution{-1000, 1000}, std::ref(engine));\n\n";
      
        std::cout << "gen_a and gen_b are no more identical.\nLet's call them in a loop\n\n";
        for (int i = 0; i < 10; ++i) {
            std::cout << "Next Iteration:\n"
                      << "gen_a(): " << gen_a() << '\n'
                      << "gen_b(): " << gen_b() << "\n\n";
        }
    }
  
    It(using_with_stl_algorithms)
    {
        std::mt19937 engine{ std::random_device{}() };
        std::function<int()> gen_int = std::bind(std::uniform_int_distribution{-1000, 1000}, std::ref(engine));

        std::cout << "std::function<int()> gen_int\n   = std::bind(std::uniform_int_distribution{-1000, 1000}, std::ref(engine));\n\n"
                  << "Let's make a loop where we create and fill up a\nvector with random ints each time.\n\n"
                  << "std::vector<int> vec(10);\n"
                  << "std::generate(vec.begin(), vec.end(), gen_int);\n\n";
  
        for (int i = 0; i < 3; ++i) {
            std::vector<int> vec(10);
            std::generate(vec.begin(), vec.end(), gen_int);

            std::cout << fmt::format("Iteration #{} using std::generate:\n{}\n\n", i, vec);
        }
      
        std::cout << "After all that, manually calling gen_int() a bunch of times:\n";
        for (int _ = 0; _ < 10; ++_) std::cout << gen_int() << " ";
      
        std::cout << "\n\nAs evident, we don't have the same identical-number issue.";
    }
};

Describe(solution2__using_lambdas_with_reference_capture)
{
    It(context)
    {
        std::cout << R"(Using a lambda that captures the engine
by reference can also negate these issues.)

std::bind(std::uniform_int_distribution{-1000, 1000}, engine);
becomes...
[&, dis=std::uniform_int_distribution{-1000, 1000}]() mutable { return dis(engine); };

It's ugly but elides the issue.)";
    }

    It(using_multiple_functions)
    {
        std::mt19937 engine{ std::random_device{}() };
        std::function<int()> gen_a = [&, dis=std::uniform_int_distribution{-1000, 1000}]() mutable { return dis(engine); };
        std::function<int()> gen_b = [&, dis=std::uniform_int_distribution{-1000, 1000}]() mutable { return dis(engine); };
        std::cout << "std::function<int()> gen_a\n   = [&, dis=std::uniform_int_distribution{-1000, 1000}]() mutable { return dis(engine); };\n";
        std::cout << "std::function<int()> gen_b\n   = [&, dis=std::uniform_int_distribution{-1000, 1000}]() mutable { return dis(engine); };\n\n";
      
        std::cout << "gen_a and gen_b are no more identical.\nLet's call them in a loop\n\n";
        for (int i = 0; i < 10; ++i) {
            std::cout << "Next Iteration:\n"
                      << "gen_a(): " << gen_a() << '\n'
                      << "gen_b(): " << gen_b() << "\n\n";
        }
    }
  
    It(using_with_stl_algorithms)
    {
        std::mt19937 engine{ std::random_device{}() };
        std::function<int()> gen_int = [&, dis=std::uniform_int_distribution{-1000, 1000}]() mutable { return dis(engine); };

        std::cout << "std::function<int()> gen_int\n   = [&, dis=std::uniform_int_distribution{-1000, 1000}]() mutable { return dis(engine); };\n\n"
                  << "Let's make a loop where we create and fill up a\nvector with random ints each time!\n\n"
                  << "std::vector<int> vec(10);\n"
                  << "std::generate(vec.begin(), vec.end(), gen_int);\n\n";
  
        for (int i = 0; i < 3; ++i) {
            std::vector<int> vec(10);
            std::generate(vec.begin(), vec.end(), gen_int);

            std::cout << fmt::format("Iteration #{} using std::generate:\n{}\n\n", i, vec);
        }
      
        std::cout << "After all that, manually calling gen_int() a bunch of times:\n";
        for (int _ = 0; _ < 10; ++_) std::cout << gen_int() << " ";
      
        std::cout << "\n\nAs evident, we don't have the same identical-number issue.";
    }
};