// Intel specific conversion: Abstract Graph -> Machine specific segment
#include "encode.h"

#include "asm/assembler.h"
#include "asm/parse.h"
#include "byteorder.h"
#include "minicc.h"

#include <algorithm>
#include <exception>

namespace {

std::shared_ptr<Op> makeLoadValue(const FlowGraph::Data& data, const FlowGraph::Graph& graph)
{
 if (data.type() != FlowGraph::DataType::Int) {
  throw std::runtime_error("Bad type for operand: "s + std::to_string(int(data.type())));
 }

 if (!data.storage())
  throw std::runtime_error("ICE: Operand storage is 0");

 auto& data_storage{*data.storage()};
 if (typeid(data_storage) == typeid(FlowGraph::Constant)) {
  FlowGraph::Constant& value {dynamic_cast<FlowGraph::Constant&>(data_storage)};
  if (value.value().size() < sizeof(uint32_t))
   throw std::runtime_error("ICE: Int data from operand needs at least 4 bytes, got "s + std::to_string(value.value().size()));

  uint32_t immediate = endian::from_little32(value.value());

  return makeOp("mov", Asm::Args{{Asm::Args::Register32("eax"), Asm::Args::Immediate32(immediate)}});
 } else if (typeid(data_storage) == typeid(FlowGraph::TemporaryStorage)) {
  //FlowGraph::TemporaryStorage& storage {dynamic_cast<FlowGraph::TemporaryStorage&>(data_storage)};

  index_t index { graph.scope()->indexOfData(data)};
  return makeOp("mov", Asm::Args{{Asm::Args::Register32("eax"), Asm::Args::Mem32Ptr64("rbp", int32_t(index + 1) * -4)}});
 } else
  throw std::runtime_error("ICE: Unsupported type for operand data at load: "s + demangle(typeid(data_storage)));
}

std::shared_ptr<Op> makeStoreValue(const FlowGraph::Data& data, const FlowGraph::Graph& graph)
{
 if (data.type() != FlowGraph::DataType::Int) {
  throw std::runtime_error("Bad type for operand: "s + std::to_string(int(data.type())));
 }

 if (!data.storage())
  throw std::runtime_error("ICE: Operand storage is 0");

 auto& data_storage{*data.storage()};
 if (typeid(data_storage) == typeid(FlowGraph::TemporaryStorage)) {
  //FlowGraph::TemporaryStorage& storage {dynamic_cast<FlowGraph::TemporaryStorage&>(data_storage)};

  index_t index { graph.scope()->indexOfData(data)};
  return makeOp("mov", Asm::Args{{Asm::Args::Mem32Ptr64("rbp", int32_t(index + 1) * -4), Asm::Args::Register32("eax")}});
 } else
  throw std::runtime_error("ICE: Unsupported type for operand data at store: "s  + demangle(typeid(data_storage)));
}

std::shared_ptr<Op> makeAddValue(const FlowGraph::Data& data, const FlowGraph::Graph& graph)
{
 if (data.type() != FlowGraph::DataType::Int) {
  throw std::runtime_error("Bad type for operand: "s + std::to_string(int(data.type())));
 }

 if (!data.storage())
  throw std::runtime_error("ICE: Operand storage is 0");

 auto& data_storage{*data.storage()};
 if (typeid(data_storage) == typeid(FlowGraph::Constant)) {
  FlowGraph::Constant& value {dynamic_cast<FlowGraph::Constant&>(data_storage)};
  if (value.value().size() < sizeof(uint32_t))
   throw std::runtime_error("ICE: Int data from operand needs at least 4 bytes, got "s + std::to_string(value.value().size()));

  uint32_t immediate = endian::from_little32(value.value());

  return makeOp("add", Asm::Args{{Asm::Args::Register32("eax"), Asm::Args::Immediate32(immediate)}});
 } else if (typeid(data_storage) == typeid(FlowGraph::TemporaryStorage)) {
  //FlowGraph::TemporaryStorage& storage {dynamic_cast<FlowGraph::TemporaryStorage&>(data_storage)};

  index_t index { graph.scope()->indexOfData(data)};
  return makeOp("add", Asm::Args{{Asm::Args::Register32("eax"), Asm::Args::Mem32Ptr64("rbp", int32_t(index + 1) * -4)}});
 } else
  throw std::runtime_error("ICE: Unsupported type for operand data at add: "s + demangle(typeid(data_storage)));
}

std::shared_ptr<Op> makeSubValue(const FlowGraph::Data& data, const FlowGraph::Graph& graph)
{
 if (data.type() != FlowGraph::DataType::Int) {
  throw std::runtime_error("Bad type for operand: "s + std::to_string(int(data.type())));
 }

 if (!data.storage())
  throw std::runtime_error("ICE: Operand storage is 0");

 auto& data_storage{*data.storage()};
 if (typeid(data_storage) == typeid(FlowGraph::Constant)) {
  FlowGraph::Constant& value {dynamic_cast<FlowGraph::Constant&>(data_storage)};
  if (value.value().size() < sizeof(uint32_t))
   throw std::runtime_error("ICE: Int data from operand needs at least 4 bytes, got "s + std::to_string(value.value().size()));

  uint32_t immediate = endian::from_little32(value.value());

  return makeOp("sub", Asm::Args{{Asm::Args::Register32("eax"), Asm::Args::Immediate32(immediate)}});
 } else if (typeid(data_storage) == typeid(FlowGraph::TemporaryStorage)) {
  //FlowGraph::TemporaryStorage& storage {dynamic_cast<FlowGraph::TemporaryStorage&>(data_storage)};

  index_t index { graph.scope()->indexOfData(data)};
  return makeOp("sub", Asm::Args{{Asm::Args::Register32("eax"), Asm::Args::Mem32Ptr64("rbp", int32_t(index + 1) * -4)}});
 } else
  throw std::runtime_error("ICE: Unsupported type for operand data at sub: "s + demangle(typeid(data_storage)));
}

std::vector<std::shared_ptr<Chunk>> makeMulValue(const FlowGraph::Data& data, const FlowGraph::Graph& graph)
{
 if (data.type() != FlowGraph::DataType::Int) {
  throw std::runtime_error("Bad type for operand: "s + std::to_string(int(data.type())));
 }

 if (!data.storage())
  throw std::runtime_error("ICE: Operand storage is 0");

 auto& data_storage{*data.storage()};
 if (typeid(data_storage) == typeid(FlowGraph::Constant)) {
  FlowGraph::Constant& value {dynamic_cast<FlowGraph::Constant&>(data_storage)};
  if (value.value().size() < sizeof(uint32_t))
   throw std::runtime_error("ICE: Int data from operand needs at least 4 bytes, got "s + std::to_string(value.value().size()));

  uint32_t immediate = endian::from_little32(value.value());

  return {{
   makeOp("mov", Asm::Args{{Asm::Args::Register32("ebx"), Asm::Args::Immediate32(immediate)}}),
   makeOp("mul", Asm::Args{{Asm::Args::Register32("ebx")}})
  }};
 } else if (typeid(data_storage) == typeid(FlowGraph::TemporaryStorage)) {
  //FlowGraph::TemporaryStorage& storage {dynamic_cast<FlowGraph::TemporaryStorage&>(data_storage)};

  index_t index { graph.scope()->indexOfData(data)};
  return {{makeOp("mul", Asm::Args{{Asm::Args::Mem32Ptr64("rbp", int32_t(index + 1) * -4)}})}};
 } else
  throw std::runtime_error("ICE: Unsupported type for operand data at mul: "s + demangle(typeid(data_storage)));
}

std::vector<std::shared_ptr<Chunk>> makeDivValue(const FlowGraph::Data& data, const FlowGraph::Graph& graph)
{
 if (data.type() != FlowGraph::DataType::Int) {
  throw std::runtime_error("Bad type for operand: "s + std::to_string(int(data.type())));
 }

 if (!data.storage())
  throw std::runtime_error("ICE: Operand storage is 0");

 auto& data_storage{*data.storage()};
 if (typeid(data_storage) == typeid(FlowGraph::Constant)) {
  FlowGraph::Constant& value {dynamic_cast<FlowGraph::Constant&>(data_storage)};
  if (value.value().size() < sizeof(uint32_t))
   throw std::runtime_error("ICE: Int data from operand needs at least 4 bytes, got "s + std::to_string(value.value().size()));

  uint32_t immediate = endian::from_little32(value.value());

  return {{
   makeOp("mov", Asm::Args{{Asm::Args::Register32("ebx"), Asm::Args::Immediate32(immediate)}}),
   makeOp("div", Asm::Args{{Asm::Args::Register32("ebx")}})
  }};
 } else if (typeid(data_storage) == typeid(FlowGraph::TemporaryStorage)) {
  //FlowGraph::TemporaryStorage& storage {dynamic_cast<FlowGraph::TemporaryStorage&>(data_storage)};

  index_t index { graph.scope()->indexOfData(data)};
  return {{makeOp("div", Asm::Args{{Asm::Args::Mem32Ptr64("rbp", int32_t(index + 1) * -4)}})}};
 } else
  throw std::runtime_error("ICE: Unsupported type for operand data at div: "s + demangle(typeid(data_storage)));
}

std::vector<std::shared_ptr<Chunk>> makeShiftLeftValue(const FlowGraph::Data& data, const FlowGraph::Graph& graph)
{
 if (data.type() != FlowGraph::DataType::Int) {
  throw std::runtime_error("Bad type for operand: "s + std::to_string(int(data.type())));
 }

 if (!data.storage())
  throw std::runtime_error("ICE: Operand storage is 0");

 auto& data_storage{*data.storage()};
 if (typeid(data_storage) == typeid(FlowGraph::Constant)) {
  FlowGraph::Constant& value {dynamic_cast<FlowGraph::Constant&>(data_storage)};
  if (value.value().size() < sizeof(uint32_t))
   throw std::runtime_error("ICE: Int data from operand needs at least 4 bytes, got "s + std::to_string(value.value().size()));

  uint32_t immediate = endian::from_little32(value.value());
  immediate = std::min(immediate, uint32_t(0xFF));

  return {makeOp("shl", Asm::Args{{Asm::Args::Register32("eax"), Asm::Args::Immediate8(static_cast<uint8_t>(immediate))}})};
 } else if (typeid(data_storage) == typeid(FlowGraph::TemporaryStorage)) {
  //FlowGraph::TemporaryStorage& storage {dynamic_cast<FlowGraph::TemporaryStorage&>(data_storage)};

  index_t index { graph.scope()->indexOfData(data)};
  std::vector<std::shared_ptr<Chunk>> result;
  result.push_back(makeOp("mov", Asm::Args{{Asm::Args::Register32("ecx"), Asm::Args::Mem32Ptr64("rbp", int32_t(index + 1) * -4)}})); // TODO: limit ecx to 0xff
  result.push_back(makeOp("shl", Asm::Args{{Asm::Args::Register32("eax"), Asm::Args::Register8("cl")}}));
  return result;
 } else
  throw std::runtime_error("ICE: Unsupported type for operand data at shift left: "s + demangle(typeid(data_storage)));
}

} // namespace

void Asm::toMachineCode(const FlowGraph::Graph& graph, Segment& segment)
{
 segment.clear();

 for (const std::shared_ptr<FlowGraph::Node>& node: graph) {
  if (node.get()) {
   auto& node_deref = *node.get();
   if (typeid(node_deref) == typeid(FlowGraph::UnaryOperation)) {
    FlowGraph::UnaryOperation& op {dynamic_cast<FlowGraph::UnaryOperation&>(*node)};

    auto operands {op.operands()};

    if (operands.size() != 2)
     throw std::runtime_error("ICE: Bad number of operands for UnaryOperation: "s + std::to_string(operands.size()));

    if (op.type() == FlowGraph::UnaryOperationType::BitwiseNot) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.append(parseAsm("not eax"));
     segment.push_back(makeStoreValue(operands[0], graph));
    } else if (op.type() == FlowGraph::UnaryOperationType::LogicalNot) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.append(parseAsm("bsr eax")); // ZF=1 iff eax=0
     segment.append(parseAsm("lahf")); // ZF in AH bit 6
     segment.append(parseAsm("shr eax, 14")); // ZF in eax bit 0
     segment.append(parseAsm("and eax, 1")); // now, 0 or 1 is in eax, negated because of zero flag
     segment.push_back(makeStoreValue(operands[0], graph));
    } else if (op.type() == FlowGraph::UnaryOperationType::Minus) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.append(parseAsm("neg eax"));
     segment.push_back(makeStoreValue(operands[0], graph));
    } else if (op.type() == FlowGraph::UnaryOperationType::Resize) {
     throw std::runtime_error("ICE: Asm: Unsupported unary operation type: Resize"s);
    } else
     throw std::runtime_error("ICE: Asm: Unsupported unary operation type: "s + std::to_string(static_cast<int>(op.type())));
    
   } else if (typeid(node_deref) == typeid(FlowGraph::BinaryOperation)) {
    FlowGraph::BinaryOperation& op {dynamic_cast<FlowGraph::BinaryOperation&>(*node)};

    auto operands {op.operands()};

    if (operands.size() != 3)
     throw std::runtime_error("ICE: Bad number of operands for BinaryOperation: "s + std::to_string(operands.size()));

    if (op.type() == FlowGraph::BinaryOperationType::Add) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.push_back(makeAddValue(operands[2], graph));
     segment.push_back(makeStoreValue(operands[0], graph));
    } else if (op.type() == FlowGraph::BinaryOperationType::Subtract) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.push_back(makeSubValue(operands[2], graph));
     segment.push_back(makeStoreValue(operands[0], graph));
    } else if (op.type() == FlowGraph::BinaryOperationType::Multiply) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.append(makeMulValue(operands[2], graph));
     segment.push_back(makeStoreValue(operands[0], graph));
    } else if (op.type() == FlowGraph::BinaryOperationType::Divide) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.append(parseAsm("xor edx, edx"));
     segment.append(makeDivValue(operands[2], graph));
     segment.push_back(makeStoreValue(operands[0], graph));
    } else if (op.type() == FlowGraph::BinaryOperationType::Modulo) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.append(parseAsm("xor edx, edx"));
     segment.append(makeDivValue(operands[2], graph));
     segment.append(parseAsm("mov eax, edx")); // remainder is in edx
     segment.push_back(makeStoreValue(operands[0], graph));
    } else if (op.type() == FlowGraph::BinaryOperationType::ShiftLeft) {
     segment.push_back(makeLoadValue(operands[1], graph));
     segment.append(makeShiftLeftValue(operands[2], graph));
     segment.push_back(makeStoreValue(operands[0], graph));
    } else
     throw std::runtime_error("ICE: Asm: Unsupported binary operation type: "s + std::to_string(static_cast<int>(op.type())));

   } else if (typeid(node_deref) == typeid(FlowGraph::CreateScopeOp)) {
    //FlowGraph::CreateScopeOp& op {dynamic_cast<FlowGraph::CreateScopeOp&>(*node)}; // TODO: Create stack frame
    segment.push_back(makeOp("push", Asm::Args{{Asm::Args::Register64("rbp")}}));
    segment.push_back(makeOp("mov", Asm::Args{{Asm::Args::Register64("rbp"), Asm::Args::Register64("rsp")}}));
    
   } else if (typeid(node_deref) == typeid(FlowGraph::DestroyScopeOp)) {

    segment.push_back(makeLoadValue(graph.lastOp()->destination(), graph)); // TODO: Just get last operation result to eax for now
    segment.push_back(makeOp("xor", Asm::Args{{Asm::Args::Register64("rdi"), Asm::Args::Register64("rdi")}}));
    segment.push_back(makeOp("mov", Asm::Args{{Asm::Args::Register32("edi"), Asm::Args::Register32("eax")}}));

    segment.push_back(makeOp("mov", Asm::Args{{Asm::Args::Register64("rax"), Asm::Args::Immediate32(60)}})); // syscall 60: exit()
    
    //FlowGraph::DestroyScopeOp& op {dynamic_cast<FlowGraph::DestroyScopeOp&>(*node)}; // TODO: Destroy stack frame
    segment.push_back(makeOp("pop", Asm::Args{{Asm::Args::Register64("rbp")}}));
    
    segment.push_back(makeOp("syscall")); // rax: #syscall, rdi: exit code value
   } else if (typeid(node_deref) == typeid(FlowGraph::DataNode)) {
    // ignore: Immediate data is used in subsequent nodes
   } else {
    throw std::runtime_error("ICE: Encoding: Unsupported node: "s + demangle(typeid(node_deref)));
   }
  } else {
   throw std::runtime_error("ICE: encode: flowgraph node is null");
  }
 }
}