// for clangd
#include "../include/find_symbols_visitor.hpp"

namespace interpreter {

// Sources -----------------
void FindSymbolsVisitor::Visit(SourceFile* node) {
  for (auto& statement : node->statements) {
    if (std::holds_alternative<Partition>(statement)) {
      Visit(&std::get<Partition>(statement));
    } else if (std::holds_alternative<SourceStatement>(statement)) {
      Visitor::Visit(std::get<SourceStatement>(statement));
    } else {
      // error
    }
  }
}

void FindSymbolsVisitor::Visit(Sources* node) {
  for (auto& statement : node->statements) {
    Visitor::Visit(statement);
  }
}

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

void FindSymbolsVisitor::Visit(Partition* node) {
  // TODO
  Visit(node->scope.get());
}

void FindSymbolsVisitor::Visit(Namespace* node) {
  if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
    Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
    auto info = std::move(std::any_cast<std::pair<std::string, std::string>>(current_info_));
    global_info_.AddEnterNamespace(info.first, info.second);
    current_info_.reset();
  } else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
    Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
    auto info = std::move(std::any_cast<std::string>(current_info_));
    global_info_.AddEnterNamespace(std::nullopt, info);
    current_info_.reset();
  } else {
    // error
  }
  Visit(node->scope.get());
  global_info_.ExitNamespace();
}

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

void FindSymbolsVisitor::Visit(ImportStatement* node) {
  info::ImportInfo info;
  info.module_name = node->module_name;
  for (auto& symbol : node->symbols) {
    Visitor::Visit(symbol);
    info.symbols.push_back(std::move(std::any_cast<std::string>(current_info_))); // TODO: expressions
  }
  global_info_.AddImport(std::move(info));
  // TODO: what if inside usage definition, global_info_.AddImport(std::move(info));
}

void FindSymbolsVisitor::Visit(UsageDefinition* node) {
  global_info_.AddUsageForNextImport(node->name);
  Visit(node->import_statement.get());
}

// <-- current position

void FindSymbolsVisitor::Visit(AliasDefinition* node) {
  info::TypeInfo info;

  Visit(node->type.get());
  auto type_info = std::move(
    std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_));
  current_info_.reset();

  Visit(node->value.get());
  auto value_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
  current_info_.reset();

  info::AliasTypeInfo alias_info;
  alias_info.isAnotherType = false;
  alias_info.params = std::move(type_info.second);
  alias_info.value = std::move(value_info);
  info.type = std::move(alias_info);

  global_info_.AddType(type_info.first, info);
}

// void FindSymbolsVisitor::Visit(VariableDefinition* node) { // TODO: decide
//   out_ << "(Variable " << (node->is_const ? "const" : "var") << ' ';
//   Visit(&node->name);
//   out_ << " = ";
//   Visitor::Visit(node->value);
//   out_ << ")\n";
// }

void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
  info::FunctionDeclarationInfo info;
  for (auto& parameter : node->parameters) {
    Visit(parameter.get());
    auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
    current_info_.reset();
    info.params.push_back(std::move(param_info));
  }
  for (auto& argument_type : node->argument_types) {
    Visitor::Visit(argument_type);
    auto type_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
    current_info_.reset();
    info.arg_types.push_back(std::move(type_info));
  }
  global_info_.AddFunctionDeclaration(node->name, std::move(info));
}

void FindSymbolsVisitor::Visit(FunctionDefinition* node) {
  info::FunctionDefinitionInfo info;

  Visit(node->name.get());
  auto name_info = std::move(
    std::any_cast<info::SymbolDefinitionInfo>(current_info_));
  current_info_.reset();

  info.params = std::move(name_info.params);
  info.arg_names = std::move(name_info.arg_names);
  info.expression = &node->value;

  global_info_.AddFunctionDefinition(name_info.name, std::move(info));
}

void FindSymbolsVisitor::Visit(AliasTypeDefinition* node) { // TODO: unite with AliasDefinition
  info::TypeInfo info;

  Visit(node->type.get());
  auto type_info = std::move(
    std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_));
  current_info_.reset();

  Visit(node->value.get());
  auto value_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
  current_info_.reset();

  info::AliasTypeInfo alias_info;
  alias_info.isAnotherType = true;
  alias_info.params = std::move(type_info.second);
  alias_info.value = std::move(value_info);

  info.type = std::move(alias_info);

  global_info_.AddType(type_info.first, std::move(info));
}

void FindSymbolsVisitor::Visit(TypeDefinition* node) {
  info::TypeInfo info;

  Visit(node->type.get());
  auto type_info = std::move(
    std::any_cast<info::SymbolDefinitionInfo>(current_info_));
  current_info_.reset();

  Visitor::Visit(node->value);
  auto value_info = std::move(std::any_cast<info::AnyTypeVariant>(current_info_));
  current_info_.reset();

  info::AnyTypeInfo any_type_info;
  any_type_info.params = std::move(type_info.params);
  any_type_info.arg_names = std::move(type_info.arg_names);

  switch (value_info.index()) {
    case 0:
      any_type_info.info =
        std::make_unique<info::VariantTypeInfo>(
          std::move(std::get<info::VariantTypeInfo>(value_info)));
      break;
    case 1:
      any_type_info.info =
        std::make_unique<info::TupleTypeInfo>(
          std::move(std::get<info::TupleTypeInfo>(value_info)));
      break;
    case 2:
      any_type_info.info =
        std::make_unique<info::BuiltInTypeInfo>(
          std::move(std::get<info::BuiltInTypeInfo>(value_info)));
      break;
    default:
      // error
      break;
  }

  info.type = std::move(any_type_info);

  global_info_.AddType(type_info.name, std::move(info));
}

void FindSymbolsVisitor::Visit(TypeclassDefinition* node) {
  info::TypeclassInfo info;

  Visit(node->typeclass.get());
  auto typeclass_info = std::move(
    std::any_cast<info::SymbolDefinitionInfo>(current_info_));
  current_info_.reset();
  info.params = std::move(typeclass_info.params);
  info.arg_names = std::move(typeclass_info.arg_names);

  for (auto& requirement : node->requirements) {
    Visit(requirement.get());
    auto requrement_info = std::move(std::any_cast<info::FunctionDeclarationInfo>(current_info_));
    current_info_.reset();
    info.requirements.push_back(std::move(requrement_info));
  }

  global_info_.AddTypeclass(typeclass_info.name, std::move(info));
}

// Definition parts

void FindSymbolsVisitor::Visit(DefinedName* node) {
  info::SymbolDefinitionInfo info;

  info.name = node->name;
  for (auto& parameter : node->parameters) {
    Visit(parameter.get());
    auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
    current_info_.reset();
    info.params.push_back(std::move(param_info));
  }
  for (auto& argument : node->arguments) {
    Visit(argument.get());
    auto argument_info = std::move(std::any_cast<std::string>(current_info_));
    current_info_.reset();
    info.arg_names.push_back(std::move(argument_info));
  }

  current_info_ = std::move(info);
}

void FindSymbolsVisitor::Visit(DefinedAnnotatedName* node) { // TODO: remove
  // Visit(&node->name);
  if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
    Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
  } else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) {
    Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
  } else {
    // no annotation
  }
}

void FindSymbolsVisitor::Visit(DefinedType* node) {
  info::SymbolDefinitionInfo info;

  Visit(node->type.get());
  info.name = /*...*/; // TODO
  for (auto& parameter : node->parameters) {
    Visit(parameter.get());
    auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
    current_info_.reset();
    info.params.push_back(std::move(param_info));
  }
  for (auto& argument : node->arguments) {
    Visit(argument.get());
    auto argument_info = std::move(std::any_cast<std::string>(current_info_));
    current_info_.reset();
    info.arg_names.push_back(std::move(argument_info));
  }

  current_info_ = std::move(info);
}

void FindSymbolsVisitor::Visit(DefinedTypeclass* node) {
  info::SymbolDefinitionInfo info;

  Visit(node->typeclass.get());
  info.name = /*...*/; // TODO
  for (auto& parameter : node->parameters) {
    Visit(parameter.get());
    auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
    current_info_.reset();
    info.params.push_back(std::move(param_info));
  }
  for (auto& argument : node->arguments) {
    Visit(argument.get());
    auto argument_info = std::move(std::any_cast<std::string>(current_info_));
    current_info_.reset();
    info.arg_names.push_back(std::move(argument_info));
  }

  current_info_ = std::move(info);
}

void FindSymbolsVisitor::Visit(DefinitionParameter* node) {
  info::ParameterInfo info;

  info.name = node->type;
  for (auto& typeclass : node->typeclasses) {
    Visit(typeclass.get());
    auto typeclass_info = std::move(std::any_cast</*...*/>(current_info_));
    current_info_.reset();
    info.param_names.push_back(std::move(typeclass_info));
  }

  current_info_ = std::move(info);
}

void FindSymbolsVisitor::Visit(DefinitionArgument* node) {
  std::string info; // TODO: add type

  info = node->name;

  // for (auto& type : node->types) {
  //   Visit(type.get());
  //   auto argument_info = std::move(std::any_cast<std::string>(current_info_));
  //   current_info_.reset();
  //   info.types.push_back(std::move(argument_info));
  // }

  current_info_ = std::move(info);
}

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

// Name

// void FindSymbolsVisitor::Visit(NameSuperExpression* node) {
//   for (auto& variable_namespace : node->namespaces) {
//     Visitor::Visit(variable_namespace);
//   }
//   for (size_t i = 0; i < node->expressions.size(); ++i) {
//     Visitor::Visit(node->expressions[i]);
//     if (i + 1 < node->expressions.size()) {
//     }
//   }
// }
//
// void FindSymbolsVisitor::Visit(NameExpression* node) {
//   for (auto& variable_namespace : node->namespaces) {
//     Visitor::Visit(variable_namespace);
//   }
//   for (size_t i = 0; i < node->names.size(); ++i) {
//     Visit(&node->names[i]);
//     if (i + 1 < node->names.size()) {
//     }
//   }
// }
//
// void FindSymbolsVisitor::Visit(TupleName* node) {
//   for (auto& name : node->names) {
//     Visit(name.get());
//   }
// }
//
// void FindSymbolsVisitor::Visit(VariantName* node) {
//   for (auto& name : node->names) {
//     Visit(name.get());
//   }
// }
//
// void FindSymbolsVisitor::Visit(AnnotatedName* node) {
//   Visit(&node->name);
//   if (node->type.has_value()) {
//     Visit(node->type.value().get());
//   }
// }

// Type

void FindSymbolsVisitor::Visit(TupleType* node) {
  info::TupleTypeInfo info;

  if (node->type.has_value()) {
    info.name = node->type.value();
  }
  for (auto& entity : node->entities) {
    info.fields.emplace_back();
    if (entity.first.has_value()) {
      info.fields.back().first = entity.first.value();
    }
    Visitor::Visit(entity.second);
    auto entity_type_info = std::move(std::any_cast<info::AnyTypeInfo>(current_info_));
    current_info_.reset();
    info.fields.back().second = std::move(entity_type_info);

  }

  current_info_ = info::AnyTypeVariant(std::move(info));
}

void FindSymbolsVisitor::Visit(VariantType* node) {
  info::VariantTypeInfo info;

  if (node->type.has_value()) {
    info.name = node->type.value();ParametrizedType
  }
  for (auto& constructor : node->constructors) {
    if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
      info.constructors.push_back(std::get<TypeIdentifierDefinition>(constructor));
    } else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
      Visit(std::get<std::unique_ptr<TupleType>>(constructor).get());
      auto constructor_tuple_info = std::move(std::any_cast<info::TupleTypeInfo>(current_info_));
      current_info_.reset();
      info.constructors.push_back(std::move(constructor_tuple_info));
    } else {
      // error
    }
  }

  current_info_ = info::AnyTypeVariant(std::move(info));
}

void FindSymbolsVisitor::Visit(AnnotatedType* node) {
  Visit(node->type_expression.get());
  if (!node->annotations.empty()) {
  }
  for (auto& annotation : node->annotations) {
    Visit(annotation.get());
  }
}

void FindSymbolsVisitor::Visit(ParametrizedType* node) {
  Visit(node->type_expression.get());
  for (auto& parameter : node->parameters) {
    Visitor::Visit(parameter);
  }
}

void FindSymbolsVisitor::Visit(TypeExpression* node) {
  for (auto& type_namespace : node->namespaces) {
    Visitor::Visit(type_namespace);
  }
  Visit(&node->type);
}

// Typeclass

void FindSymbolsVisitor::Visit(AnnotatedTypeclass* node) {
  Visit(node->typeclass_expression.get());
  if (!node->annotations.empty()) {
  }
  for (auto& annotation : node->annotations) {
    Visit(annotation.get());
  }
}

void FindSymbolsVisitor::Visit(ParametrizedTypeclass* node) {
  Visit(node->typeclass_expression.get());
  for (auto& paramater : node->parameters) {
    Visitor::Visit(paramater);
  }
}

void FindSymbolsVisitor::Visit(TypeclassExpression* node) {
  for (auto& typeclass_namespace : node->namespaces) {
    Visitor::Visit(typeclass_namespace);
  }
  Visit(&node->typeclass);
}

} // namespace interpreter