// Helper Functions for assembling

#pragma once

#include "chunk.h"

#include "../minicc.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 Immediate64
 {
 public:
  Immediate64(uint64_t value): m_value(value) {}
  uint64_t value() { return m_value; }
  std::vector<uint8_t> getCode() {
   std::vector<uint8_t> result(size_t(8));
   *(reinterpret_cast<uint64_t*>(result.data())) = boost::endian::native_to_little(m_value);
   return result;
  };

 private:
  uint64_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;
 };

 // 64 bit Ptr to 32 bit Memory
 class Mem32Ptr64
 {
 public:
  Mem32Ptr64(const std::string& reg, int32_t offs = 0): m_reg(reg), m_offs(offs) {}
  Mem32Ptr64(const std::string& reg, const std::string& reg2 = ""s, int32_t offs = 0): m_reg(reg), m_reg2(reg2), m_offs(offs) {}
  std::string reg() { return m_reg; }
  std::string reg2() { return m_reg2; }
  int32_t offs() { return m_offs; }

 private:
  std::string m_reg;
  std::string m_reg2;
  int32_t m_offs;
 };

 // 64 bit Ptr to 64 bit Memory
 class Mem64Ptr64
 {
 public:
  Mem64Ptr64(const std::string& reg, int32_t offs = 0): m_reg(reg), m_offs(offs) {}
  Mem64Ptr64(const std::string& reg, const std::string& reg2 = ""s, int32_t offs = 0): m_reg(reg), m_reg2(reg2), m_offs(offs) {}
  std::string reg() { return m_reg; }
  std::string reg2() { return m_reg2; }
  int32_t offs() { return m_offs; }

 private:
  std::string m_reg;
  std::string m_reg2;
  int32_t m_offs;
 };

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

 private:
  std::string m_name;
 };

}; // class Args

} // namespace Asm

using FactoryFunction = std::function<std::shared_ptr<Op>(const 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, const 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, const Asm::Args& args);