#include <initializer_list>
#include <iostream>
#include <map>
#include <optional>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include "aisa/aisa.h"
#include "aisa/eval.h"
#include "git-tag.h"

int main(int argc, const char *argv[])
{
    std::cout << "Version " << GIT_TAG << "\n";

    struct CopyStep : public aisa::Step {
        CopyStep(std::pair<aisa::regnum_t, aisa::regval_t> pred, const std::initializer_list<std::pair<aisa::regnum_t, aisa::regnum_t>> &regs)
        {
            predicate = std::move(pred);
            source_regs.reserve(regs.size());
            destination_regs.reserve(regs.size());
            for (const auto &rp : regs) {
                source_regs.emplace_back(rp.first);
                destination_regs.emplace_back(rp.second);
            }
        }

        std::vector<aisa::regval_t> compute_destinations(const std::vector<aisa::regval_t> &source_vals) const override
        {
            return source_vals;
        }
    } step{{123, 456}, {{1, 2}, {3, 4}, {5, 6}}};

    struct State : public aisa::EvalState<State> {
        std::map<aisa::regnum_t, aisa::regval_t> regs;

        std::optional<aisa::regval_t> load_reg(aisa::regnum_t rn)
        {
            std::cout << "state.load_reg(" << rn << ") = ";
            if (auto x = regs.find(rn); x != regs.end()) {
                std::cout << x->second << "\n";
                return x->second;
            }
            std::cout << "(not available)\n";
            return {};
        }

        bool store_reg(aisa::regnum_t rn, aisa::regval_t rv)
        {
            std::cout << "state.store_reg(" << rn << " <- " << rv << ")\n";
            regs[rn] = rv;
            return true;
        }
    } state;

    auto t = state.async_load_reg(999);
    std::cout << "run\n"; t();
    std::cout << "run\n"; t();
    std::cout << "run\n"; t();
    std::cout << "set regs[999] = 54321\n"; state.store_reg(999, 54321);
    std::optional<aisa::regval_t> result;
    while (!result.has_value()) {
        std::cout << "run\n";
        result = t();
    }
    std::cout << "result = " << *result << "\n";

    std::cout << "\n\n\n";

    auto w = state.eval(step);
    std::cout << "run\n"; w();
    std::cout << "run\n"; w();
    std::cout << "run\n"; w();
    std::cout << "set predicate (valid)\n"; state.store_reg(step.predicate->first, step.predicate->second);
    std::cout << "run\n"; w();
    std::cout << "run\n"; w();
    std::cout << "run\n"; w();
    std::cout << "set regs (all)\n";
    for (int i = 0; i < 10; ++i)
        state.store_reg(i, 1000 + i);
    for (bool done = false; !done; done = w())
        std::cout << "run\n";
    std::cout << "huzzah!\n";

    return 0;
}