// Nodes in flow graph: Abstract Operations

#pragma once

#include "data.h"
#include "storage.h"

namespace FlowGraph {

 // Node in Graph: Building block of the graph
 // Abstracts actions of program flow, yet machine independent,
 // to be converted later into machine code
 // Basic elements:
 // - Subroutine calls
 // - Arithmetic/logical operations
 // Arguments (Data instances) will be provided explicitly from outside
 class Node
 {
 public:
  Node(){}
  Node(std::vector<Data> operands): mOperands(operands) {}
  std::vector<Data>& operands() { return mOperands; }
  virtual ~Node() {}; // force class to be polymorphic (e.g. in a container)
 private:
  std::vector<Data> mOperands;
 };
 
 // Memory on Heap: new and delete
 class AllocateDynamic: public Node
 {
 public:
  AllocateDynamic(Data& location, Data& size):
   Node(std::vector<Data>({location, size})) // in/out: Pointer; in: Size
  {}
 };

 class DeallocateDynamic: public Node
 {
 public:
  DeallocateDynamic(Data& location):
   Node(std::vector<Data>({location})) // in: Pointer
  {}
 };

 Data MakeConstantInt(int i);
 Data MakeLocalPointer(const std::string& name);
 Data MakeLocalSize(const std::string& name);
 Data MakeTemporaryInt(LocalScope& scope);

 class MemCopy: public Node
 {
 public:
  MemCopy(Data& destination, Data& source, Data& size): // Pointer, Pointer, size in bytes
   Node(std::vector<Data>({destination, source, size}))
  {}
 };

 class Move: public Node
 {
 public:
  Move(Data& destination, Data& source):
   Node(std::vector<Data>({destination, source}))
  {}
 };

 enum class JumpVariant
 {
  Unconditional,
  GT,
  LT,
  GE,
  LE,
  EQ,
  NE
 };

 // Unconditional Jump, conditional Jump
 class Jump: public Node
 {
 public:
  Jump(JumpVariant variant, Data& source0, Data& source1, std::shared_ptr<Node> destination):
   Node(std::vector<Data>({source0, source1})),
   m_variant(variant),
   m_destination(destination)
  {}
  JumpVariant variant() { return m_variant; }
 private:
  JumpVariant m_variant;
  std::shared_ptr<Node> m_destination; // successor on branch
 };
 
 // Call Subroutine
 class Call: public Node
 {
 public:
  Call(std::shared_ptr<Node> destination, std::vector<Data> arguments):
   Node(arguments),
   m_destination(destination)
  {}
 private:
  std::shared_ptr<Node> m_destination;
 };
 
 // Return from Subroutine
 class Return: public Node
 {
 public:
  Return(std::vector<Data> returnValues):
   Node(returnValues)
  {}
 };
 
 enum class UnaryOperationType {
  Increment,
  Decrement,
  Negate
 };

 class UnaryOperation: public Node
 {
 public:
  UnaryOperation(UnaryOperationType type, Data& destination, Data& source):
   Node(std::vector<Data>({destination, source})),
   m_type(type)
   {}
  UnaryOperationType type() { return m_type; }
 private:
  UnaryOperationType m_type;
 };

 enum class BinaryOperationType {
  Add,
  Subtract,
  Multiply,
  Divide,
  Modulo,
  ShiftRight,
  ShiftLeft,
  BitwiseAnd,
  BitwiseOr,
  BitwiseXor,
  BitwiseNot,
  LogicalAnd,
  LogicalOr,
  LogicalNot
 };

 class BinaryOperation: public Node
 {
 public:
  BinaryOperation(BinaryOperationType type, Data& destination, Data& source0, Data& source1):
   Node(std::vector<Data>({destination, source0, source1})),
   m_type(type)
 {}
  BinaryOperationType type() {return m_type;}
 private:
  BinaryOperationType m_type;
 };

} // namespace FlowGraph