#pragma once

#include <map>
#include <string>

#include "basic_nodes.hpp"

namespace builtin::types {

// -- containers

const static std::string TUPLE_IDENTIFIER = "Tuple";

const static std::string VARIANT_IDENTIFIER = "Variant";

const static std::string FUNCTION_IDENTIFIER = "Function";

const static std::string ARRAY_IDENTIFIER = "Array";

const static std::string OPTIONAL_IDENTIFIER = "Optional";

const static std::string RESULT_IDENTIFIER = "Result";

// -- basic types

const static std::string FLOAT_IDENTIFIER = "Float";

const static std::string DOUBLE_IDENTIFIER = "Double";

const static std::string INT_IDENTIFIER = "Int";

const static std::string LONG_IDENTIFIER = "Long";

const static std::string INDEX_IDENTIFIER = "Index";

const static std::string CHAR_IDENTIFIER = "Char";

const static std::string UNICODE_IDENTIFIER = "Unicode";

const static std::string BOOL_IDENTIFIER = "Bool";

const static std::string UNIT_IDENTIFIER = "Unit";

const static std::string NULL_OPTION_IDENTIFIER = "Null";

// const static std::string STRING_IDENTIFIER = "String"; // String is
// Array[Char]

//

enum class Type {
  // -- containers
  TUPLE,
  VARIANT,
  FUNCTION,
  ARRAY,
  OPTIONAL,
  RESULT,
  // -- basic types
  FLOAT,
  DOUBLE,
  INT,
  LONG,
  INDEX,
  CHAR,
  UNICODE,
  BOOL,
  UNIT,
  NULL_OPTION,
  // -- none
  NONE,
};

inline std::string to_string(Type type) {
  switch (type) {
    // -- containers
  case Type::TUPLE:
    return TUPLE_IDENTIFIER;
  case Type::VARIANT:
    return VARIANT_IDENTIFIER;
  case Type::FUNCTION:
    return FUNCTION_IDENTIFIER;
  case Type::ARRAY:
    return ARRAY_IDENTIFIER;
  case Type::OPTIONAL:
    return OPTIONAL_IDENTIFIER;
  case Type::RESULT:
    return RESULT_IDENTIFIER;
  // -- basic types
  case Type::FLOAT:
    return FLOAT_IDENTIFIER;
  case Type::DOUBLE:
    return DOUBLE_IDENTIFIER;
  case Type::INT:
    return INT_IDENTIFIER;
  case Type::LONG:
    return LONG_IDENTIFIER;
  case Type::INDEX:
    return INDEX_IDENTIFIER;
  case Type::CHAR:
    return CHAR_IDENTIFIER;
  case Type::UNICODE:
    return UNICODE_IDENTIFIER;
  case Type::BOOL:
    return BOOL_IDENTIFIER;
  case Type::UNIT:
    return UNIT_IDENTIFIER;
  case Type::NULL_OPTION:
    return NULL_OPTION_IDENTIFIER;
  // -- none
  case Type::NONE:
    return TUPLE_IDENTIFIER;
  }

  error_handling::handle_general_error("Unreachable");
  exit(1); // unreachable
}

inline Type to_type(const std::string &str) {
  static std::map<std::string, Type> builtin_types;
  if (!builtin_types.empty()) { // if not initialized, initialize

    // -- containers
    builtin_types[TUPLE_IDENTIFIER] = Type::TUPLE;
    builtin_types[VARIANT_IDENTIFIER] = Type::VARIANT;
    builtin_types[FUNCTION_IDENTIFIER] = Type::FUNCTION;
    builtin_types[ARRAY_IDENTIFIER] = Type::ARRAY;
    builtin_types[OPTIONAL_IDENTIFIER] = Type::OPTIONAL;
    builtin_types[RESULT_IDENTIFIER] = Type::RESULT;

    // -- basic types
    builtin_types[FLOAT_IDENTIFIER] = Type::FLOAT;
    builtin_types[DOUBLE_IDENTIFIER] = Type::DOUBLE;
    builtin_types[INT_IDENTIFIER] = Type::INT;
    builtin_types[LONG_IDENTIFIER] = Type::LONG;
    builtin_types[INDEX_IDENTIFIER] = Type::INDEX;
    builtin_types[CHAR_IDENTIFIER] = Type::CHAR;
    builtin_types[UNICODE_IDENTIFIER] = Type::UNICODE;
    builtin_types[BOOL_IDENTIFIER] = Type::BOOL;
    builtin_types[UNIT_IDENTIFIER] = Type::UNIT;
    builtin_types[NULL_OPTION_IDENTIFIER] = Type::NULL_OPTION;
  }

  auto iter = builtin_types.find(str);

  if (iter == builtin_types.end()) {
    return Type::NONE;
  }

  return iter->second;
}

inline nodes::Modifier get_modifier(Type type) {
  switch (type) {
  case Type::OPTIONAL:
    return nodes::Modifier::OPTIONAL;
  case Type::RESULT:
    return nodes::Modifier::RESULT;
  default:
    return nodes::Modifier::NONE;
  }
}

// std::nullopt for any parameters count
inline std::optional<size_t> get_parameters_count(Type type) {
  switch (type) {
    // -- containers
  case Type::TUPLE:
  case Type::VARIANT:
  case Type::FUNCTION:
    return std::nullopt;
  case Type::ARRAY:
  case Type::OPTIONAL:
  case Type::RESULT:
    return 1;
  // -- basic types
  case Type::FLOAT:
  case Type::DOUBLE:
  case Type::INT:
  case Type::LONG:
  case Type::INDEX:
  case Type::CHAR:
  case Type::UNICODE:
  case Type::BOOL:
  case Type::UNIT:
  case Type::NULL_OPTION:
    return 0;
  // -- none
  case Type::NONE:
    return std::nullopt;
  }

  error_handling::handle_general_error("Unreachable");
  exit(1); // unreachable
}

} // namespace builtin::types