#pragma once

#include "chunk.h"

#include <boost/endian/conversion.hpp>

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

namespace Asm {

class Args: public std::vector<std::any>
{
public:
 Args(){}
 Args(const std::vector<std::any>& args): std::vector<std::any>(args){}

 class Immediate8
 {
 public:
  Immediate8(uint8_t value): m_value(value) {}
  uint8_t value() {return m_value;}
  std::vector<uint8_t> getCode() {return {m_value};};

 private:
  uint8_t m_value;
 };

 class Immediate32
 {
 public:
  Immediate32(uint32_t value): m_value(value) {}
  uint32_t value() { return m_value; }
  std::vector<uint8_t> getCode() {
   std::vector<uint8_t> result(size_t(4));
   *(reinterpret_cast<uint32_t*>(result.data())) = boost::endian::native_to_little(m_value);
   return result;
  };

 private:
  uint32_t m_value;
 };

 class Register8
 {
 public:
  Register8(const std::string& name): m_name(name) {}
  std::string name() { return m_name; }

 private:
  std::string m_name;
 };

 class Register32
 {
 public:
  Register32(const std::string& name): m_name(name) {}
  std::string name() { return m_name; }

 private:
  std::string m_name;
 };

 class Register64
 {
 public:
  Register64(const std::string& name): m_name(name) {}
  std::string name() { return m_name; }

 private:
  std::string m_name;
 };

 class Label
 {
 public:
  Label(const std::string& name): m_name(name) {}
  std::string name() { return m_name; }

 private:
  std::string m_name;
 };

};

} // namespace Asm

using FactoryFunction = std::function<std::shared_ptr<Op>(Asm::Args&)>;

// 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, Asm::Args& 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, Asm::Args& args);