#pragma once

#include <string>
#include <variant>
#include <optional>
#include <unordered_map>

// for clangd
#include "interpreter_tree.hpp"
#include "utils.hpp"

namespace info::value {

struct Unit {};

struct InternalValue {
public:
  InternalValue() = default;

  template<typename T>
  explicit InternalValue(const T& value) : value(value) {} // move ??

  template<typename T>
  std::optional<T*> GetValue() {
    if (!std::holds_alternative<T>(value)) {
      return std::nullopt;
    }
    return &std::get<T>(value);
  }
public:
  std::variant<double,
               long long,
               std::string,
               char,
               bool,
               Unit> value;
};

struct TupleValue {
public:
  TupleValue() = default;
  explicit TupleValue(std::vector<std::pair<std::optional<std::string>, utils::IdType>>&& fields) : fields(std::move(fields)) {}

public:
  std::vector<std::pair<std::optional<std::string>, utils::IdType>> fields;
};

struct VariantValue {
public:
  VariantValue() = default;
  VariantValue(utils::IdType value) // TupleValue ?? // TODO: add type & constructor??
    : value(value) {}

public:
  utils::IdType value;
};

struct ReferenceToValue {
public:
  ReferenceToValue() = default;
  ReferenceToValue(const std::vector<utils::ReferenceModifier>& references,
                   utils::IdType value)
    : references(references), value(value) {}

public:
  std::vector<utils::ReferenceModifier> references;
  utils::IdType value;
};

struct FunctionValue {
public:
  FunctionValue() = default;
  FunctionValue(std::variant<interpreter::tokens::FunctionDeclaration*,
                interpreter::tokens::LambdaFunction*> function)
    : function(function) {}

public:
  std::variant<interpreter::tokens::FunctionDeclaration*,
               interpreter::tokens::LambdaFunction*> function;
};


struct ArrayValue {
public:
  ArrayValue() = default;
  explicit ArrayValue(std::vector<utils::IdType>&& elements,
                      bool is_constant_size)
    : elements(std::move(elements)), is_constant_size(is_constant_size) {}

public:
  std::vector<utils::IdType> elements;
  bool is_constant_size = false;
};

struct OptionalValue {
public:
  OptionalValue() = default;
  explicit OptionalValue(utils::IdType value) : value(value) {}

public:
  std::optional<utils::IdType> value;
};

struct Value { // DefinedValue ??
public:
  Value() = default;

  template<typename T>
  explicit Value(const T& value) : value(value) {} // move ??

public:
  std::variant<InternalValue,
               TupleValue,
               VariantValue,
               ReferenceToValue,
               FunctionValue, // ??
               ArrayValue,
               OptionalValue> value;
};

class ValueManager {
public:
  template<typename T>
  utils::IdType AddValue(const T& value, utils::ValueType value_type) {
    values_.push_back(std::pair<Value, utils::ValueType> {Value(value), value_type});
    return values_.size() - 1;
  }

  utils::IdType AddAnyValue(Value&& value, utils::ValueType value_type) {
    values_.push_back(std::pair<Value, utils::ValueType> {std::move(value), value_type});
    return values_.size() - 1;
  }

  template<typename T>
  std::optional<T*> GetValue(utils::IdType value_id) {
    if (!std::holds_alternative<T>(values_.at(value_id).first.value)) {
      return std::nullopt;
    }
    return &std::get<T>(values_.at(value_id).first.value);
  }

  Value* GetAnyValue(utils::IdType value_id) {
    return &values_.at(value_id).first;
  }

  utils::ValueType GetValueType(utils::IdType value_id) {
    return values_.at(value_id).second;
  }

  bool EqualTypes(utils::IdType first_type, utils::IdType second_type) = delete; // TODO

  bool AddTypeRequirement(utils::IdType type, utils::IdType requrement) = delete;

private:
  std::vector<std::pair<Value, utils::ValueType>> values_;
};

} // namespace info::value