#include <optional>
#include <variant>

// for clangd
#include "../include/execute_visitor.hpp"
#include "../include/builtin_functions.hpp"


// TODO

namespace interpreter {

// Sources -----------------

void ExecuteVisitor::Visit(SourceFile* node) { // never used ??
  for (auto& statement : node->statements) {
    Visitor::Visit(statement);
  }
}

// Namespaces, partitions -----------------

void ExecuteVisitor::Visit(NamespaceSources* node) { // never used ??
  for (auto& statement : node->statements) {
    Visitor::Visit(statement);
  }
}

void ExecuteVisitor::Visit(Namespace* node) { // never used ??
  // Visit(&node->type);
  Visit(&node->scope);
}

// Definitions -----------------

void ExecuteVisitor::Visit(ImportStatement*) {} // no value
void ExecuteVisitor::Visit(AliasDefinitionStatement*) {} // no value

void ExecuteVisitor::Visit(VariableDefinitionStatement* node) { // visited on function call
  Visitor::Visit(node->value);

  is_const_definition_ = node->modifier;
  Visitor::Visit(node->name); // current_type_ passed from value
  is_const_definition_ = std::nullopt;
}

void ExecuteVisitor::Visit(FunctionDeclaration*) {} // no value

void ExecuteVisitor::Visit(FunctionDefinitionStatement* node) { // visited on function call
  // Visit(node->definition.get());
  context_manager_.EnterContext();

  returned_value_ = std::nullopt;
  Visitor::Visit(node->value);

  if (returned_value_.has_value()) {
    current_value_ = returned_value_.value();
  } // else returned type = current_type_

  returned_value_ = std::nullopt;

  context_manager_.ExitContext();
}

void ExecuteVisitor::Visit(TypeDefinitionStatement*) {} // no value
void ExecuteVisitor::Visit(AbstractTypeDefinitionStatement*) {} // no value

void ExecuteVisitor::Visit(TypeclassDefinitionStatement*) {} // no value

void ExecuteVisitor::Visit(PartitionStatement* node) {
  Visitor::Visit(node->value);
}

// Flow control -----------------

void ExecuteVisitor::Visit(TypeConstructorPatternParameter*) {} // handled in TypeConstructorPattern

// TODO: check
void ExecuteVisitor::Visit(TypeConstructorPattern* node) {
  if (!node->constructor->constructor_id_.has_value()) { // checked in typeckeck visitor ??
    error_handling::HandleRuntimeError("Type constructor pattern constructor name not found", node->base);
  }

  utils::IdType constructor_id = node->constructor->constructor_id_.value();

  // only one has value inside
  auto maybe_variant_value_info = context_manager_.GetValue<info::value::VariantValue>(current_value_);
  auto maybe_tuple_value_info = context_manager_.GetValue<info::value::TupleValue>(current_value_);

  if (maybe_variant_value_info.has_value()) {
    info::value::VariantValue* variant_value_info = maybe_variant_value_info.value();

    if (constructor_id != variant_value_info->current_constructor) {
      case_matched_ = false;
      return;
    }

    // extract named parameters ??
    for (size_t i = 0; i < node->parameters.size(); ++i) { // not visit if case not matched inside ??
      current_value_ = variant_value_info->value.fields[i].second;
      Visitor::Visit(node->parameters[i].value);
    }
  } else if (maybe_tuple_value_info.has_value()) {
    info::value::TupleValue* tuple_value_info = maybe_tuple_value_info.value();

    // extract named parameters ??
    for (size_t i = 0; i < node->parameters.size(); ++i) { // not visit if case not matched inside ??
      current_value_ = tuple_value_info->fields[i].second;
      Visitor::Visit(node->parameters[i].value);
    }
  } else {
    error_handling::HandleRuntimeError("Wrong value type for type constructor pattern (not variant or tuple)", node->base);
  }
}

void ExecuteVisitor::Visit(MatchCase*) {} // handeled in Match

void ExecuteVisitor::Visit(Match* node) {
  context_manager_.EnterContext();

  Visitor::Visit(node->value);

  utils::IdType value = current_value_;

  bool case_choosen = false;
  bool statement_visited = false;
  for (auto& match_case : node->matches) {
    if (case_choosen) {
      if (match_case.statement.has_value()) {
        Visitor::Visit(match_case.statement.value());
        statement_visited = true;
        break;
      }
    } else {
      current_value_ = value;
      case_matched_ = true;

      context_manager_.EnterContext();
      Visitor::Visit(node->value);

      if (case_matched_ && (match_case.condition.has_value() ? HandleCondition(match_case.condition.value(), match_case.base) : true)) {
        case_choosen = true;
        if (match_case.statement.has_value()) {
          Visitor::Visit(match_case.statement.value());
          statement_visited = true;
          break;
        }
      } else {
        context_manager_.ExitContext();
      }
    }
  }

  if (case_choosen) {
    context_manager_.ExitContext();
  }

  // --- instead of optional return value or throw runtime error ---
  // if (statement_visited) {
  //   current_value_ = context_manager_.AddValue(
  //         info::value::OptionalValue(current_value_, context_manager_.GetValueManager()),
  //         utils::ValueType::Tmp);
  // } else {
  //   current_value_ = context_manager_.AddValue(
  //         info::value::OptionalValue(std::nullopt, context_manager_.GetValueManager()),
  //         utils::ValueType::Tmp);
  // }
  if (!statement_visited) {
    error_handling::HandleRuntimeError("Value match option not found", node->base);
  }

  context_manager_.ExitContext();
}

void ExecuteVisitor::Visit(Condition* node) {
  context_manager_.EnterContext();

  for (size_t i = 0; i < node->conditions.size(); ++i) {
    if (HandleCondition(node->conditions[i], node->base)) {
      Visitor::Visit(node->statements[i]);

      if (node->statements.size() == node->conditions.size()) {
        current_value_ = context_manager_.AddValue(
          info::value::OptionalValue(current_value_, context_manager_.GetValueManager()),
          utils::ValueType::Tmp); // take value type from current_value_ ??
      }
      return; // current_value_ passed from statement
    }
  }
  if (node->statements.size() > node->conditions.size()) {
    Visitor::Visit(node->statements[node->conditions.size()]);
  } else {
    current_value_ = context_manager_.AddValue(
      info::value::OptionalValue(std::nullopt, context_manager_.GetValueManager()),
      utils::ValueType::Tmp);
  }

  context_manager_.ExitContext();
}

void ExecuteVisitor::Visit(DoWhileLoop* node) {
  context_manager_.EnterContext();

  std::vector<utils::IdType> result;
  do {
    Visitor::Visit(node->statement);
    if (active_loop_control_expression_.has_value()) {
      if (active_loop_control_expression_.value() == LoopControlExpression::Break) {
        active_loop_control_expression_ = std::nullopt;
        break;
      }
      active_loop_control_expression_ = std::nullopt;
      continue;

    }
    result.push_back(current_value_);
  } while(HandleCondition(node->condition, node->base));

  current_value_ = context_manager_.AddValue(
    info::value::ArrayValue(std::move(result), false, context_manager_.GetValueManager()),
    utils::ValueType::Tmp);

  context_manager_.ExitContext();
}

void ExecuteVisitor::Visit(WhileLoop* node) {
  context_manager_.EnterContext();

  std::vector<utils::IdType> result;
  while(HandleCondition(node->condition, node->base)) {
    Visitor::Visit(node->statement);
    if (active_loop_control_expression_.has_value()) {
      if (active_loop_control_expression_.value() == LoopControlExpression::Break) {
        active_loop_control_expression_ = std::nullopt;
        break;
      }
      active_loop_control_expression_ = std::nullopt;
      continue;

    }
    result.push_back(current_value_);
  }

  current_value_ = context_manager_.AddValue(
    info::value::ArrayValue(std::move(result), false, context_manager_.GetValueManager()),
    utils::ValueType::Tmp);

  context_manager_.ExitContext();
}
void ExecuteVisitor::Visit(ForLoop* node) {
  context_manager_.EnterContext();

  std::vector<utils::IdType> result;

  // TODO: extend to different interval types (not only array)
  Visitor::Visit(node->interval);
  info::value::ArrayValue* interval = ExtractValue<info::value::ArrayValue>(current_value_, node->base);

  for (auto& value : interval->elements) {
    context_manager_.EnterContext(); // TODO

    current_value_ = value;
    is_const_definition_ = node->variable_modifier;
    Visitor::Visit(node->variable); // TODO: assign variable, instead of making new
    is_const_definition_ = std::nullopt;

    Visitor::Visit(node->statement);
    if (active_loop_control_expression_.has_value()) {
      if (active_loop_control_expression_.value() == LoopControlExpression::Break) {
        active_loop_control_expression_ = std::nullopt;
        break;
      }
      active_loop_control_expression_ = std::nullopt;
      continue;

    }
    result.push_back(current_value_);

    context_manager_.ExitContext(); // TODO
  }

  current_value_ = context_manager_.AddValue(
    info::value::ArrayValue(std::move(result), false, context_manager_.GetValueManager()),
    utils::ValueType::Tmp);

  context_manager_.ExitContext();
}

void ExecuteVisitor::Visit(LoopLoop* node) {
  context_manager_.EnterContext();

  std::vector<utils::IdType> result;
  while(true) {
    Visitor::Visit(node->statement);
    if (active_loop_control_expression_.has_value()) {
      if (active_loop_control_expression_.value() == LoopControlExpression::Break) {
        active_loop_control_expression_ = std::nullopt;
        break;
      }
      active_loop_control_expression_ = std::nullopt;
      continue;

    }
    result.push_back(current_value_);
  }

  current_value_ = context_manager_.AddValue(
    info::value::ArrayValue(std::move(result), false, context_manager_.GetValueManager()),
    utils::ValueType::Tmp);

  context_manager_.ExitContext();
}

// Statements, expressions, blocks, etc. -----------------

void ExecuteVisitor::Visit(Block* node) {
  context_manager_.EnterContext();

  for (auto& statement : node->statements) {
    brought_value_ = std::nullopt;
    Visitor::Visit(statement);
    if (returned_value_.has_value()) {
      brought_value_ = std::nullopt;
      break;
    }
    if (brought_value_.has_value()) {
      break;
    }
  }

  context_manager_.ExitContext();

  if (brought_value_.has_value()) {
    current_value_ = brought_value_.value();
    brought_value_ = std::nullopt;
  } else {
    current_value_ = context_manager_.AddValue(
      info::value::InternalValue(info::value::Unit()),
      utils::ValueType::Tmp);
  }
}

void ExecuteVisitor::Visit(ScopedStatement* node) {
  Visitor::Visit(node->statement); // current_value_ passed from statement
}

void ExecuteVisitor::Visit(LoopControlExpression& node) {
  active_loop_control_expression_ = node;

  current_value_ = context_manager_.AddValue(info::value::InternalValue(info::value::Unit()),
                                             utils::ValueType::Tmp);
}

// Operators

void ExecuteVisitor::Visit(ReferenceExpression* node) {
  // TODO: check, that there is no references to "Tmp"??
  Visit(node->expression.get());

  utils::ValueType value_type = context_manager_.GetValueType(current_value_);

  current_value_ = context_manager_.AddValue(
    info::value::ReferenceToValue(node->references, current_value_, context_manager_.GetValueManager()),
    value_type);
}

void ExecuteVisitor::Visit(AccessExpression* node) {
  // TODO: extend to other types
  Visit(node->name.get());
  info::value::ArrayValue* array_value = ExtractValue<info::value::ArrayValue>(current_value_, node->base);
  utils::ValueType value_type = context_manager_.GetValueType(current_value_);

  Visitor::Visit(node->id);
  long long index = *ExtractInternalValue<long long>(current_value_, node->base); // TODO: size_t

  if (index < 0 || index >= (long long)array_value->elements.size()) {
    error_handling::HandleRuntimeError("Access index out of range", node->base);
  }

  current_value_ = context_manager_.ToModifiedValue(array_value->elements[index], value_type); // needed ??
}

// Other Expressions

// TODO: refactor, separate to several functions
// TODO: more builtin functions, better handling (??)
void ExecuteVisitor::Visit(FunctionCallExpression* node) {
  context_manager_.EnterContext();

  if (node->prefix.has_value()) {
    if (std::holds_alternative<std::unique_ptr<SubExpressionToken>>(node->prefix.value())) {
      Visitor::Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node->prefix.value()));

      if (!context_manager_.DefineVariable(utils::ClassInternalVarName, current_value_)) {
        error_handling::HandleRuntimeError("Variable redefinition (mathod caller var)", node->base);
      }
    } else if (std::holds_alternative<std::unique_ptr<TypeExpression>>(node->prefix.value())) {
      TypeExpression& prefix = *std::get<std::unique_ptr<TypeExpression>>(node->prefix.value());

      // TODO: abstract types, local abstract types, abstract types, ... as path entities
      for (auto& path_type : prefix.path) {
        CollectTypeContext(path_type);
      }

      CollectTypeContext(prefix.type);
    } else {
      error_handling::HandleInternalError("Unexpected prefix type",
                                          "ExecuteVisitor.FunctionCallExpression",
                                          &node->base);
    }
  } else {
    if (node->is_method_of_first_argument_) {
      Visitor::Visit(node->arguments[0]);
      if (!context_manager_.DefineVariable(utils::ClassInternalVarName, current_value_)) {
        error_handling::HandleRuntimeError("Variable redefinition (mathod caller var)", node->base);
      }
    }
  }

  FunctionDeclaration* function_declaration = nullptr;
  FunctionDefinitionStatement* function_definition = nullptr;

  if (node->function_id_.has_value()) {
    auto maybe_function_declaration_info = global_info_.GetFunctionInfo(node->function_id_.value()).declaration;

    if (!maybe_function_declaration_info.has_value()) {
      error_handling::HandleRuntimeError("Function declaration not found (for namespace function)", node->base);
      // always namespace function ??
    }

    function_declaration = maybe_function_declaration_info.value().node;

    auto maybe_function_definition_info = global_info_.GetFunctionInfo(node->function_id_.value()).definition;

    if (!maybe_function_definition_info.has_value()) {
      if (HandleBuiltinFunctionCall(node)) {
        return;
      }

      error_handling::HandleRuntimeError("Function definition not found (by graph_id_)", node->base);
    }

    function_definition = maybe_function_definition_info.value().node;

  } else if (node->graph_id_.has_value()) {
    std::optional<FunctionDefinitionStatement*> maybe_function_definition;

    auto maybe_function_graph_info = typeclass_graph_.GetFunctionInfo(node->name,
                                                                      node->graph_id_.value());

    if (!maybe_function_graph_info.has_value()) {
      error_handling::HandleRuntimeError("Function info not found (by graph_id_)", node->base);
    }

    function_declaration = maybe_function_graph_info.value()->declaration;
    maybe_function_definition = maybe_function_graph_info.value()->definition;

    if (!maybe_function_definition.has_value()) {
      if (typeclass_graph_.GetVertex(node->graph_id_.value()).modifier == info::TypeclassGraph::Modifier::Type) {
        error_handling::HandleRuntimeError("Type function definition not found (by graph_id_)", node->base);
      }

      if (!node->abstract_type_name_.has_value()) {
        error_handling::HandleInternalError("Typeclass function's abstract_type_name_ has no value",
                                            "ExecuteVisitor.FunctionCallExpression",
                                            &node->base);
      }

      auto maybe_type_id = context_manager_.FindLocalType(node->abstract_type_name_.value());
      if (!maybe_type_id.has_value()) {
        error_handling::HandleRuntimeError("Function's abstract type not found (by abstract_type_name_)", node->base);
      }

      auto maybe_type_info = global_info_.GetTypeInfo<info::definition::AnyType>(maybe_type_id.value());

      if (!maybe_type_info.has_value()) {
        error_handling::HandleRuntimeError("Function's abstract type replacement defined type is not AnyType", node->base);
      }

      maybe_function_graph_info = typeclass_graph_.GetFunctionInfo(node->name, maybe_type_info.value()->type.node->graph_id_);

      if (!maybe_function_graph_info.has_value()) {
      error_handling::HandleRuntimeError("Function info not found (by abstract type graph_id_)", node->base);
    }

      maybe_function_definition = maybe_function_graph_info.value()->definition;
    }

    if (!maybe_function_definition.has_value()) {
      if (HandleBuiltinTypeclassFunctionCall(node)) {
        return;
      }

      error_handling::HandleRuntimeError("Function definition not found (by graph_id_)", node->base);
    }

    function_definition = maybe_function_definition.value();
  }

  for (size_t i = 0; i < node->parameters.size(); ++i) {
    utils::IdType type_id = 0;

    if (node->parameters[i]->type_id_.has_value()) {
      type_id = node->parameters[i]->type_id_.value();
    } else {
      auto maybe_parameter_type_id = context_manager_.FindLocalType(node->parameters[i]->type.type);

      if (!maybe_parameter_type_id.has_value()) {
        error_handling::HandleInternalError("Parameter type not found",
                                           "ExecuteVisitor.FunctionCallExpression",
                                            &node->base);
      }

      type_id = maybe_parameter_type_id.value();
    }

    if (!context_manager_.DefineLocalType(function_declaration->parameters[i]->type,
                                            type_id)) {
      error_handling::HandleRuntimeError("Type redefinition (function argument)", node->base);
    }
  }

  for (size_t i = (node->is_method_of_first_argument_ ? 1 : 0); i < node->arguments.size(); ++i) {
    Visitor::Visit(node->arguments[i]);

    current_value_ = context_manager_.ToModifiedValue(current_value_, utils::ValueType::Const);
    if (!context_manager_.DefineVariable(function_definition->definition->arguments[i],
                                         current_value_)) {
      error_handling::HandleRuntimeError("Variable redefinition (function argument)", node->base);
    }
  }

  context_manager_.ChangeHidingOfCurrentContextTo(true);
  Visit(function_definition);

  context_manager_.ExitContext();
}

void ExecuteVisitor::Visit(TupleExpression* node) {
  std::vector<std::pair<std::optional<std::string>, utils::IdType>> fields;
  fields.reserve(node->expressions.size());
  for (auto& expression : node->expressions) {
    Visitor::Visit(expression);
    fields.push_back({std::nullopt, current_value_});
  }

  current_value_ = context_manager_.AddValue(
    info::value::TupleValue(std::move(fields), context_manager_.GetValueManager()),
    utils::ValueType::Tmp);
}

void ExecuteVisitor::Visit(VariantExpression* node) {
  // TODO: decide about return type (variant)
  for (size_t i = 0; i < node->expressions.size(); ++i) {
    Visitor::Visit(node->expressions[i]);
    info::value::OptionalValue* expression_value = ExtractValue<info::value::OptionalValue>(current_value_, node->base);
    if (expression_value->value.has_value()) {
      std::vector<std::pair<std::optional<std::string>, utils::IdType>> fields
        {{std::nullopt, expression_value->value.value()}};

      info::value::TupleValue variant_tuple =
        info::value::TupleValue(std::move(fields), context_manager_.GetValueManager());

      current_value_ = context_manager_.AddValue(
        info::value::VariantValue(std::move(variant_tuple), i),
        utils::ValueType::Tmp);

      current_value_ = context_manager_.AddValue(
        info::value::OptionalValue(current_value_, context_manager_.GetValueManager()),
        utils::ValueType::Tmp);
      return;
    }
  }

  current_value_ = context_manager_.AddValue(
    info::value::OptionalValue(std::nullopt, context_manager_.GetValueManager()),
    utils::ValueType::Tmp);
}

void ExecuteVisitor::Visit(ReturnExpression* node) {
  Visitor::Visit(node->expression);
  if (node->is_from_definition) {
    returned_value_ = current_value_;
  } else {
    brought_value_ = current_value_;
  }

  current_value_ = context_manager_.AddValue(
    info::value::InternalValue(info::value::Unit()),
    utils::ValueType::Tmp);
}


void ExecuteVisitor::Visit(TypeConstructorParameter*) {} // handled in TypeConstructor

// TODO: check
void ExecuteVisitor::Visit(TypeConstructor* node) {
  std::vector<std::pair<std::optional<std::string>, utils::IdType>> fields;

  if (!node->constructor->constructor_id_.has_value()) {
    error_handling::HandleRuntimeError("Type constructor name not found", node->base);
  }

  utils::IdType constructor_id = node->constructor->constructor_id_.value();
  info::definition::Constructor constructor_info = global_info_.GetConstructorInfo(constructor_id);

  // Visit(node->constructor.get()); // use parameters from type expression ??
  fields.reserve(node->parameters.size());
  for (auto& parameter : node->parameters) {
    Visitor::Visit(parameter.value);
    // TODO: copy/move parameters
    fields.push_back(
      { parameter.name.has_value() ? std::optional<std::string>(parameter.name.value()) : std::nullopt,
        current_value_ });
  }

  if (constructor_info.order.has_value()) { // => variant
    current_value_ = context_manager_.AddValue(
      info::value::VariantValue(
        info::value::TupleValue(std::move(fields), context_manager_.GetValueManager()),
        constructor_info.order.value()),
      utils::ValueType::Tmp);
  } else { // => tuple
    current_value_ = context_manager_.AddValue(
      info::value::TupleValue(std::move(fields), context_manager_.GetValueManager()),
      utils::ValueType::Tmp);
  }
}

// TODO
void ExecuteVisitor::Visit(LambdaFunction* node) {
  error_handling::HandleInternalError("Lambda function are not implemented yet",
                                      "ExecuteVisitor.LambdaFunction",
                                      &node->base);
}

void ExecuteVisitor::Visit(ArrayExpression* node) {
  std::vector<utils::IdType> elements;

  elements.reserve(node->elements.size());
  for (auto& element : node->elements) {
    Visitor::Visit(element);
    elements.push_back(current_value_);
  }

  current_value_ = context_manager_.AddValue(
    info::value::ArrayValue(std::move(elements), true, context_manager_.GetValueManager()), // maybe size not fixed??
    utils::ValueType::Tmp);
}

// Name

void ExecuteVisitor::Visit(NameExpression* node) { // TODO: check
  if (node->names.empty()) {
    error_handling::HandleInternalError("Names array is empty",
                                        "ExecuteVisitor.NameExpression",
                                        &node->base);
  }

  std::optional<utils::IdType> maybe_variable_value =
    context_manager_.FindVariable(node->names[0]);

  if (!maybe_variable_value.has_value()) {
    error_handling::HandleRuntimeError("Variable not found", node->base);
  }

  current_value_ = maybe_variable_value.value();

  if (node->names.size() > 1) {
    utils::ValueType variable_value_type = context_manager_.GetValueType(current_value_);

    for (size_t i = 1; i < node->names.size(); ++i) {
      std::optional<utils::IdType> maybe_field_value = context_manager_.GetAnyValue(current_value_)->GetFieldValue(node->names[i]); // TODO
      if (!maybe_field_value.has_value()) {
        error_handling::HandleRuntimeError("Variable field not found", node->base);
      }

      current_value_ = maybe_field_value.value();
    }

    current_value_ = context_manager_.ToModifiedValue(current_value_, variable_value_type);
  }
}

void ExecuteVisitor::Visit(TupleName* node) { // TODO: check
  utils::IdType value = current_value_;

  std::optional<info::value::TupleValue*> maybe_tuple_value = context_manager_.GetValue<info::value::TupleValue>(value);

  if (maybe_tuple_value.has_value()) {
    error_handling::HandleRuntimeError("Mismatched value types in tuple variable definition", node->base);
  }

  if (maybe_tuple_value.value()->fields.size() != node->names.size()) {
    error_handling::HandleRuntimeError("Mismatched field count in tuple variable definition", node->base);
  }

  if (!is_const_definition_.has_value()) {
    error_handling::HandleInternalError("No value in is_const_definition_",
                                        "TypeCheckVisitor.TupleName",
                                        &node->base);
  }

  utils::ValueType value_type = context_manager_.GetValueType(value);
  if (value_type == utils::ValueType::Const
      && is_const_definition_.value() == utils::IsConstModifier::Var) {
    error_handling::HandleRuntimeError("TupleName: value type expression not match variable definition modifier", node->base);
  }

  for (size_t i = 0; i < node->names.size(); ++i) {
    current_value_ = maybe_tuple_value.value()->fields[i].second;

    if (value_type == utils::ValueType::Tmp) { // TODO: ??
      current_value_ = context_manager_.ToModifiedValue(current_value_, utils::ValueType::Tmp);
    }

    Visitor::Visit(node->names[i]);
  }

  current_value_ = value;
}

// TODO
// TODO: make variant of TupleValue
void ExecuteVisitor::Visit(VariantName* node) {
  utils::IdType value = current_value_;

  std::optional<info::value::VariantValue*> maybe_variant_value = context_manager_.GetValue<info::value::VariantValue>(value);

  if (!maybe_variant_value.has_value()) {
    error_handling::HandleRuntimeError("Mismatched value types in variant variable definition", node->base);
  }

  for (size_t i = 0; i < node->names.size(); ++i) {
    if (i == maybe_variant_value.value()->current_constructor) {
      if (maybe_variant_value.value()->value.fields.empty()) {
        current_value_ = context_manager_.AddValue(
          info::value::InternalValue(info::value::Unit()),
          utils::IsConstModifierToValueType(is_const_definition_.value()));
        // TODO: check, that same with typecheck
      } else {
        current_value_ = context_manager_.AddValue(
          maybe_variant_value.value()->value,
          utils::IsConstModifierToValueType(is_const_definition_.value()));
      }

      current_value_ = context_manager_.AddValue(
          info::value::OptionalValue(current_value_, context_manager_.GetValueManager()),
          utils::IsConstModifierToValueType(is_const_definition_.value()));
    } else {
      current_value_ = context_manager_.AddValue(
        info::value::OptionalValue(std::nullopt, context_manager_.GetValueManager()),
        utils::IsConstModifierToValueType(is_const_definition_.value()));
    }

    Visitor::Visit(node->names[i]);
  }
  // TODO: find out, which constructor used
  // set value to that constructor and None (empty OptionalValue) to others

  current_value_ = value;
}

void ExecuteVisitor::Visit(AnnotatedName* node) { // TODO: check
  utils::IdType value = current_value_;

  if (!is_const_definition_.has_value()) {
    error_handling::HandleInternalError("No value in is_const_definition_",
                                        "TypeCheckVisitor.AnnotatedName",
                                        &node->base);
  }

  utils::ValueType value_type = context_manager_.GetValueType(current_value_);
  if (value_type == utils::ValueType::Const
      && is_const_definition_.value() == utils::IsConstModifier::Var) {
    error_handling::HandleRuntimeError("AnnotatedName: value type expression not match variable definition modifier", node->base);
  }

  current_value_ = context_manager_.ToModifiedValue(value, utils::IsConstModifierToValueType(is_const_definition_.value()));
  if (!context_manager_.DefineVariable(node->name, current_value_)) {
    error_handling::HandleRuntimeError("Variable name already present in context", node->base);
  }
}

// Type, typeclass, etc. -----------------

// Type

void ExecuteVisitor::Visit(FunctionType*) {} // no value
void ExecuteVisitor::Visit(TupleType*) {} // no value
void ExecuteVisitor::Visit(VariantType*) {} // no value
void ExecuteVisitor::Visit(TypeExpression*) {} // no value
void ExecuteVisitor::Visit(ExtendedScopedAnyType*) {} // no value

// Typeclass

void ExecuteVisitor::Visit(ParametrizedTypeclass*) {} // no value

// Typeclass & Type -----------------

void ExecuteVisitor::Visit(ParametrizedType*) {} // no value

// Identifiers, constants, etc. -----------------

// void ExecuteVisitor::Visit(ExtendedName* node) {}

// void ExecuteVisitor::Visit(std::string* node) {} // std::string

void ExecuteVisitor::Visit(FloatNumberLiteral* node) {
  current_value_ = context_manager_.AddValue(
    info::value::InternalValue(node->value),
    utils::ValueType::Tmp);
}

void ExecuteVisitor::Visit(NumberLiteral* node) {
  current_value_ = context_manager_.AddValue(
    info::value::InternalValue(node->value),
    utils::ValueType::Tmp);
}

void ExecuteVisitor::Visit(StringLiteral* node) {
  current_value_ = context_manager_.AddValue(
    info::value::InternalValue(node->value),
    utils::ValueType::Tmp);
}

void ExecuteVisitor::Visit(CharLiteral* node) {
  current_value_ = context_manager_.AddValue(
    info::value::InternalValue(node->value),
    utils::ValueType::Tmp);
}

void ExecuteVisitor::Visit(UnitLiteral*) {
  current_value_ = context_manager_.AddValue(
    info::value::InternalValue(info::value::Unit()),
    utils::ValueType::Tmp);
}

void ExecuteVisitor::Visit(BoolLiteral* node) {
  current_value_ = context_manager_.AddValue(
    info::value::InternalValue(node->value),
    utils::ValueType::Tmp);
}

//

bool ExecuteVisitor::HandleCondition(Expression& node, const BaseNode& base_node) {
  Visitor::Visit(node);
  return *ExtractInternalValue<bool>(current_value_, base_node);
}

// TODO: handle abstract types, handle local abstract types, etc. // partially done (check needed)
void ExecuteVisitor::CollectTypeContext(const ParametrizedType& type) {
  utils::IdType type_id = 0;

  if (!type.type_id_.has_value()) {
    auto maybe_local_type_id = context_manager_.FindLocalType(type.type);
    if (!maybe_local_type_id.has_value()) {
      return;
    }
    type_id = maybe_local_type_id.value(); // TODO: check
  } else {
    type_id = type.type_id_.has_value();
  }

  auto maybe_type_info = global_info_.GetTypeInfo<info::definition::AnyType>(type_id);

  if (!maybe_type_info.has_value()) {
    error_handling::HandleInternalError("CollectTypeContext implemented only for AnyType",
                                        "ExecuteVisitor.CollectTYpeContext",
                                        std::nullopt);
  }

  info::definition::AnyType& type_info = *maybe_type_info.value(); // check, that has value ??

  for (size_t i = 0; i < type.parameters.size(); ++i) {
    if (type.parameters[i]->type_id_.has_value()) {
      context_manager_.DefineLocalType(type_info.parameters[i].type,
                                       type.parameters[i]->type_id_.value());
    }
  }
}

void ExecuteVisitor::CheckPattern(Pattern& node, const BaseNode& base_node) {
  utils::IdType value = current_value_;

  switch (node.index()) {
    case 0:
      value = context_manager_.ToModifiedValue(value, utils::ValueType::Const); // ??
      if (!context_manager_.DefineVariable(*std::get<std::unique_ptr<NameIdentifier>>(node),
                                           value)) {
        error_handling::HandleRuntimeError("Can't redifine variable", base_node);
      }
      break;
    case 1:
      Visitor::Visit(*std::get<std::unique_ptr<Literal>>(node));
      if (!context_manager_.EqualValues(current_value_, value)) {
         case_matched_ = false;
      }
      break;
    case 2:
      Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
      break;
    default:
      // error
      break;
  }
}

//

bool ExecuteVisitor::HandleBuiltinFunctionCall(FunctionCallExpression* node) {
  if (node->name == "print") {
    if (node->arguments.size() < 1) {
      error_handling::HandleInternalError("Builtin function \"print\" has 0 arguments",
                                          "ExecuteVisitor.HandleBuiltinFunctionCall",
                                          &node->base);
    }

    Visitor::Visit(node->arguments[0]);
    info::builtin::Print(*ExtractInternalValue<std::string>(current_value_, node->base));

    current_value_ = context_manager_.AddValue(info::value::InternalValue(info::value::Unit()),
                                               utils::ValueType::Tmp);
    return true;
  } else if (node->name == "read") {
    current_value_ = context_manager_.AddValue(info::value::InternalValue(info::builtin::Read<std::string>()),
                                               utils::ValueType::Tmp);
    return true;
  }

  return false;
}

bool ExecuteVisitor::HandleBuiltinTypeclassFunctionCall(FunctionCallExpression*) {
  return false;
}

} // namespace interpreter