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

namespace interpreter {

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

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

void FindSymbolsVisitor::Visit(Partition* node) {
  // TODO: separate partitions
  Visitor::Visit(&node->scope);
}

void FindSymbolsVisitor::Visit(Namespace* node) {
  std::optional<info::definition::Namespace::Modifier> modifier;
  if (node->modifier.has_value()) {
    switch (node->modifier.value()) {
      case interpreter::Namespace::Var:
        modifier = info::definition::Namespace::Var;
        break;
      case interpreter::Namespace::Const:
        modifier = info::definition::Namespace::Const;
        break;
    }
  }

  namespace_visitor_.AddEnterNamespace(node->type, modifier);
  Visitor::Visit(&node->scope);
  namespace_visitor_.ExitNamespace();
}

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

// TODO: add imported symbols to symbol table (global info)
void FindSymbolsVisitor::Visit(ImportStatement* node) {
  is_in_statement_ = true;

  info::definition::Import info;
  info.module_name = node->module_name;
  info.symbols = node->symbols;
  namespace_visitor_.AddImport(std::move(info), node->name);

  is_in_statement_ = false;
}

void FindSymbolsVisitor::Visit(AliasDefinitionStatement* node) {
  is_in_statement_ = true;

  info::definition::Type info;

  info::definition::AliasType alias_info;

  switch (node->modifier) {
    case interpreter::AliasDefinitionStatement::Alias:
      alias_info.modifier = info::definition::AliasType::Alias;
      break;
    case interpreter::AliasDefinitionStatement::Type:
      alias_info.modifier = info::definition::AliasType::Type;
      break;
    case interpreter::AliasDefinitionStatement::Let:
      alias_info.modifier = info::definition::AliasType::Let;
      break;
  }

  // TODO: deduce parameter requirements

  alias_info.parameters = node->parameters;
  alias_info.value.node = node->value.get();
  alias_info.node = node;

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

  node->type_id_ = namespace_visitor_.AddType(node->type, std::move(info));

  is_in_statement_ = false;
}

void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
  bool was_in_statement = is_in_statement_;
  is_in_statement_ = true;

  info::definition::FunctionDeclaration info;

  info.parameters.resize(node->parameters.size());
  for (size_t i = 0; i < node->parameters.size(); ++i) {
    Visit(node->parameters[i].get());
    info.parameters[i] = std::move(std::any_cast<info::definition::Parameter>(current_info_));
    current_info_.reset();
  }

  info.argument_types.resize(node->type->types.size());
  for (size_t i = 0; i < node->type->types.size(); ++i) {
    info.argument_types[i] = &node->type->types[i];
  }

  info.node = node;

  if (was_in_statement) {
    current_info_ = std::move(info);
  } else {
    node->function_id_ = namespace_visitor_.AddFunctionDeclaration(node->name.name, std::move(info));
    is_in_statement_ = false;
  }
}

void FindSymbolsVisitor::Visit(FunctionDefinitionStatement* node) {
  is_in_statement_ = true;

  info::definition::FunctionDefinition info;

  auto definition = node->definition.get();

  info.argument_names.resize(definition->arguments.size());
  for (size_t i = 0; i < definition->arguments.size(); ++i) {
    info.argument_names[i] = definition->arguments[i].name;
  }

  info.node = node;

  node->function_id_ = namespace_visitor_.AddFunctionDefinition(definition->name.name, std::move(info));

  is_in_statement_ = false;
}

void FindSymbolsVisitor::Visit(TypeDefinitionStatement* node) {
  is_in_statement_ = true;

  info::definition::Type info;

  auto definition = node->definition.get();

  info::definition::AnyType any_type_info;

  Visit(definition->type.get());
  any_type_info.type = std::move(std::any_cast<info::definition::Parameter>(current_info_));
  current_info_.reset();

  any_type_info.parameters.resize(definition->parameters.size());
  for (size_t i = 0; i < definition->parameters.size(); ++i) {
    Visit(definition->parameters[i].get());
    any_type_info.parameters[i] = std::move(std::any_cast<info::definition::Parameter>(current_info_));
    current_info_.reset();
  }

  any_type_info.value = &node->value;

  std::string type = any_type_info.type.type;

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

  node->type_id_ = namespace_visitor_.AddType(type, std::move(info));

  is_in_statement_ = false;
}

void FindSymbolsVisitor::Visit(AbstractTypeDefinitionStatement* node) {
  is_in_statement_ = true;

  info::definition::AbstractType info;

  Visit(node->type.get());
  info.type = std::move(std::any_cast<info::definition::Parameter>(current_info_));
  current_info_.reset();

  switch (node->modifier) {
    case interpreter::AbstractTypeDefinitionStatement::Basic:
      info.modifier = info::definition::AbstractType::Basic;
      break;
    case interpreter::AbstractTypeDefinitionStatement::Abstract:
      info.modifier = info::definition::AbstractType::Abstract;
      break;
  }

  std::string type = info.type.type;

  node->type_id_ = namespace_visitor_.AddAbstractType(type, std::move(info));

  is_in_statement_ = false;
}

void FindSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
  is_in_statement_ = true;

  info::definition::Typeclass info;

  auto definition = node->definition.get();

  info.parameters.resize(definition->parameters.size());
  for (size_t i = 0; i < definition->parameters.size(); ++i) {
    Visit(definition->parameters[i].get());
    info.parameters[i] = std::move(std::any_cast<info::definition::Parameter>(current_info_));
    current_info_.reset();
  }

  info.requirements.reserve(node->requirements.size());
  for (size_t i = 0; i < node->requirements.size(); ++i) {
    Visit(node->requirements[i].get());
    info.requirements[i] = std::move(std::any_cast<info::definition::FunctionDeclaration>(current_info_));
    current_info_.reset();
  }

  node->typeclass_id_ = namespace_visitor_.AddTypeclass(definition->type.get()->type, std::move(info));

  is_in_statement_ = false;
}

// Definition parts

void FindSymbolsVisitor::Visit(AnyAnnotatedType* node) {
  info::definition::Parameter info;

  info.type = node->type;

  info.typeclass_nodes.resize(node->typeclasses.size());
  for (size_t i = 0; i < node->typeclasses.size(); ++i) {
    info.typeclass_nodes[i] = node->typeclasses[i].get();
  }

  current_info_ = std::move(info);
}

} // namespace interpreter