#pragma once

#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

namespace aisa {

    using addr_t = std::uint64_t;
    using byte_t = std::uint8_t;
    using regnum_t = std::uint_fast64_t;
    using regval_t = std::uint64_t;

    struct Task;

    struct ISA {
        virtual ~ISA() { }

        virtual std::pair<std::unique_ptr<const Task>, regval_t> initial_task() const = 0;
    };

    struct Step;

    struct Task {
        regnum_t environment;

        virtual ~Task() { }

        virtual std::string disasm() const = 0;

        virtual std::optional<std::pair<std::unique_ptr<const Step>, regval_t>> step(regval_t environment_val) const { return {}; }
    };

    struct MemInfo {
        addr_t physical_addr;
        addr_t size;
    };

    struct Wires {
        std::vector<regval_t> source_vals;
        std::vector<byte_t> memory_val;
        bool aborted = false;
        std::vector<regval_t> destination_vals;
        std::optional<std::pair<std::unique_ptr<const Task>, regval_t>> new_task;
    };

    enum class MOp {
        NONE,
        LOAD,
        STORE,
    };

    struct Step {
        std::optional<std::pair<regnum_t, regval_t>> predicate;
        std::vector<regnum_t> source_regs;
        std::vector<regnum_t> destination_regs;

        virtual ~Step() { }

        virtual std::string disasm(const Wires *w = nullptr) const = 0;

        std::optional<regnum_t> predicate_reg() const
        {
            if (predicate.has_value())
                return predicate->first;
            return {};
        }

        std::optional<regnum_t> expected_predicate_val() const
        {
            if (predicate.has_value())
                return predicate->second;
            return {};
        }

        MOp mop = MOp::NONE;

        virtual MemInfo meminfo(const Wires &wires) const { return {}; }
        virtual void evaluate(Wires &wires) const { };
    };

}