#pragma once

#include "chunk.h"

#include <any>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>

using AsmArgs = std::vector<std::any>;
using FactoryFunction = std::function<std::shared_ptr<Op>(AsmArgs&)>;

// mnemonic: mnemonic including argument types
bool registerOp(const std::string& mnemonic, FactoryFunction f);

// Create Op from a registered mnemonic
// mnemonic: just the mnemonic name
std::shared_ptr<Op> makeOp(const std::string& mnemonic, AsmArgs& args);

// overload for empty list of arguments
std::shared_ptr<Op> makeOp(const std::string& mnemonic);

std::shared_ptr<Label> makeLabel(const std::string& name);
std::shared_ptr<Data> makeData(const std::vector<uint8_t>& data);

template<typename T>
std::string mangleNameOne(const std::string& s)
{
 return s + "_" + typeid(T).name();
}

template<typename T, typename... Targs>
std::string mangleName(const std::string& s)
{
 if constexpr (sizeof...(Targs) == 0)
  return mangleNameOne<T>(s);
 else
  return mangleName<Targs...>(s + "_" + typeid(T).name());
}

std::string mangleName(const std::string& s, AsmArgs& args);

class Immediate8
{
public:
 Immediate8(uint8_t value): m_value(value) {}
 uint8_t value() {return m_value;}

private:
 uint8_t m_value;
};