#ifndef INSTRUCTIONS_HPP
#define INSTRUCTIONS_HPP

#include <array>
#include <cstdint>
#include <unordered_map>

#include <execution>

#include "kblib/convert.h"
#include "kblib/simple.h"

#include "ints.h"

struct memory_store {
	constexpr static u64 segment_count = 1u << 16u, segment_size = 1u << 16u,
	                     word_size = 8;
	constexpr static u64 mem_size = segment_count * segment_size * word_size;

	using address = u64;
	using byte = unsigned char;
	using word = std::array<byte, 8>;

	static_assert(CHAR_BIT == 8, "The host must have byte-addressible memory");

	byte& operator[](address addr);
	byte& operator()(u16 segment, u32 word, unsigned char byte);
	word& operator()(u16 segment, u32 word);

	std::array<word, segment_count * segment_size> main_memory;
	std::array<word, 16> registers;
};

inline memory_store memory;

namespace detail {

using str_type = std::array<char, 15>;

template <std::size_t N, std::size_t... I>
constexpr str_type str_impl(const char (&arr)[N],
                            std::integer_sequence<std::size_t, I...>) {
	return {arr[I]...};
}

template <std::size_t N,
          typename Indices = std::make_integer_sequence<std::size_t, N>>
constexpr str_type str(const char (&arr)[N]) {
	return str_impl(arr, Indices{});
}
} // namespace detail

using segment = std::array<u64, (1u << 20u)>;

enum class stack_dir : char { up, down };
template <stack_dir dir = stack_dir::up>
class stack_cache {
	std::array<std::unique_ptr<segment>, (1u << 12u)>* memory;
	u32 top;
};

struct computer_state {
	std::array<std::unique_ptr<segment>, (1u << 12u)> memory;
	u64 registers[16];
	u64 internal[4];

	stack_cache<stack_dir::up> stack;
	stack_cache<stack_dir::down> hstack;
	stack_cache<stack_dir::up> cstack;
};

inline u64 saturating_add(u64 a, u64 b) {
	u64 result;
	return __builtin_add_overflow(a, b, &result) ? -1_u64 : result;
}
inline u64 saturating_sub(u64 a, u64 b) {
	u64 result;
	return __builtin_sub_overflow(a, b, &result) ? -1_u64 : result;
}

#endif // INSTRUCTIONS_HPP