lang/include/nodes/basic_nodes.hpp

#pragma once

#include <optional>
#include <string>
#include <utility>
#include <variant>

namespace nodes {

// replace enum with structure ??
enum class Modifier {
  IN,    // <- x
  REF,   // <> x
  CONST, // -- x (or nothing sometimes)
  OUT,   // -> x
  //
  IN_OR_REF,    // <-|<> x
  IN_OR_CONST,  // <-|-- x
  REF_OR_OUT,   // <>|-> x
  CONST_OR_OUT, // --|-> x
  REF_OR_CONST, // <>|-- x
  IN_OR_OUT,    // <-|-> x
  //
  IN_OR_REF_OR_OUT,    // <-|<>|-> x
  IN_OR_CONST_OR_OUT,  // <-|--|-> x
  IN_OR_REF_OR_CONST,  // <-|<>|-- x
  REF_OR_CONST_OR_OUT, //<>|--|-> x
  //
  IN_OR_REF_OR_CONST_OR_OUT, //<-|<>|--|-> x
  OPTIONAL,                  // x?
  RESULT,                    // x!
  NONE,
};

class Node {
public:
  Node(std::pair<size_t, size_t> start_position,
       std::pair<size_t, size_t> end_position)
      : start_position_(start_position), end_position_(end_position) {}

  std::pair<size_t, size_t> get_start_position() const {
    return start_position_;
  }

  std::pair<size_t, size_t> get_end_position() const { return end_position_; }

protected:
  std::pair<size_t, size_t> start_position_;
  std::pair<size_t, size_t> end_position_;
};

struct unit {};
struct null {};

class Literal : public Node {
public:
  template <typename T>
  Literal(Node node, T &&value) : Node(node), value_(std::forward<T>(value)) {}

  template <typename T> std::optional<T *> get() {
    if (std::holds_alternative<T>(value_)) {
      return &std::get<T>(value_);
    }
    return std::nullopt;
  }

  template <typename T> std::optional<const T *> get() const {
    if (std::holds_alternative<T>(value_)) {
      return &std::get<T>(value_);
    }
    return std::nullopt;
  }

  auto get_any() { return &value_; }

  auto get_any() const { return &value_; }

private:
  std::variant<double, long long, std::string, char, bool, unit, null> value_;
};

class Identifier : public Node {
public:
  enum IdentifierType {
    SIMPLE_NAME,
    SIMPLE_TYPE,
    TYPECLASS,
    ARGUMENT_NAME,
    ARGUMENT_TYPE,
    // ANNOTATION, used as std::string
    OPERATOR,
    PLACEHOLDER,
  };

  Identifier(Node node, IdentifierType type, std::string &&value)
      : Node(node), type_(type), value_(std::move(value)) {}

  Identifier(Node node, IdentifierType type, const std::string &value)
      : Node(node), type_(type), value_(value) {}

  IdentifierType get_type() const { return type_; }

  //

  std::string *get() { return &value_; }

  const std::string *get() const { return &value_; }

  //

  void append_before(const std::string &name) { value_ = name + "." + value_; }

  void append_after(const std::string &name) {
    value_ += ".";
    value_ += name;
  }

  //

  bool operator==(const Identifier &other_identifier) const {
    return type_ == other_identifier.type_ && value_ == other_identifier.value_;
  }

  bool operator!=(const Identifier &other_identifier) const {
    return !(*this == other_identifier);
  }

private:
  IdentifierType type_;
  std::string value_;
};

class Extra : public Node {
public:
  Extra(Node node, std::string &&content)
      : Node(node), content_(std::move(content)) {}

  Extra(Node node, const std::string &content)
      : Node(node), content_(content) {}

  std::string *content() { return &content_; }

  const std::string *content() const { return &content_; }

private:
  std::string content_;
};

class EmptyLines : public Node {
public:
  EmptyLines(Node node, size_t line_count)
      : Node(node), line_count_(line_count) {}

  size_t line_count() const { return line_count_; }

private:
  size_t line_count_;
};

} // namespace nodes