#pragma once

#include <string>
#include <vector>
#include <variant>
#include <memory>

// for clangd
#include "node.hpp"


namespace interpreter {

namespace  tokens {

// ----------------- Declarations -----------------

using AnyIdentifier = std::string;
using NameOrOperatorIdentifier = std::string;
using NameIdentifier = std::string;
using AnyTypeIdentifier = std::string;
using TypeIdentifier = std::string;
using AbstractTypeIdentifier = std::string;
using OperatorIdentifier = std::string;
using TypeclassIdentifier = std::string;

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

struct SourceFile; // TODO partitions
struct Sources;

// Namespaces, partittions -----------------

struct Partition;
struct Namespace;

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

struct ImportStatement;
struct UsageDefinition;
struct AliasDefinition;
struct VariableDefinition;
struct FunctionDeclaration;
struct FunctionDefinition;
struct AliasTypeDefinition; // | Parts of type definition
struct TypeDefinition;      // |
struct TypeclassDefinition;

using SourceStatement = std::variant<
  ImportStatement,
  UsageDefinition,
  AliasDefinition,
  VariableDefinition, // ??
  FunctionDeclaration,
  FunctionDefinition,
  AliasTypeDefinition,
  TypeDefinition,
  TypeclassDefinition,
  Namespace>;

// Definition parts

struct ParametrizedType;
struct TupleType;
struct VariantType;
struct ParametrizedTypeclass;
using FunctionDeclarationType = std::variant<
  ParametrizedType,
  TupleType,
  VariantType,
  ParametrizedTypeclass>;

struct DefinedName;
struct DefinedAnnotatedName;
struct DefinedType;
struct DefinedTypeclass;
struct DefinitionParameter;
struct DefinitionArgument;

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

struct Match;
struct Condition;
struct WhileLoop; // WhileLoop <-> DoWhileLoop
struct ForLoop;
struct LoopLoop;

using FlowControl = std::variant<
  Match,
  Condition,
  WhileLoop,
  ForLoop,
  LoopLoop>;

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

struct Block;

//

struct NameExpression;
struct ScopedStatement;

using SubExpressionToken = std::variant<
  NameExpression,
  ScopedStatement>;

//

struct FunctionCallExpression;
struct BinaryOperatorExpression;

using SubExpression = std::variant<
  FunctionCallExpression,
  BinaryOperatorExpression,
  SubExpressionToken>;

//

struct ReturnExpression;

enum class LoopControlExpression {
    Break,
    Continue,
};

using PrefixedExpression = std::variant<
  ReturnExpression,
  LoopControlExpression,
  Block>;

//

struct LambdaFunction;
struct TypeConstructor;
struct UnaryOperatorExpression;

using Expression = std::variant<
  LambdaFunction,
  TypeConstructor,
  PrefixedExpression,
  UnaryOperatorExpression,
  SubExpression>;

//

struct TupleExpression;
struct VariantExpression;

using SuperExpression = std::variant<
  FlowControl,
  TupleExpression,
  VariantExpression,
  Expression>;

//

struct ScopedStatement; // ?? scoped statement is _superexpression ??

// Operators

struct BinaryOperatorExpression;
struct UnaryOperatorExpression;

// Simple Expressions

struct FunctionCallExpression;
struct TupleExpression;
struct VariantExpression;
struct ReturnExpression;

// Lambda

struct LambdaFunction;

// Name

struct NameSuperExpression;
struct NameExpression;
struct TupleName;
struct VariantName;
struct AnnotatedName;

using AnyName = std::variant<
  AnnotatedName,
  TupleName,
  VariantName>;

// Type

struct TypeConstructor;

// // TypeOrAnyType <-> AnyType

struct TupleType;
struct VariantType;
struct VariantType;

using AnyType = std::variant<
  ParametrizedType,
  TupleType,
  VariantType>;

// // TypeIdentifierDefinition <-> some '.' + TypeIdentifier
using TypeIdentifierDefinition = std::string;

struct AnnotatedType;
// // TypeAnnotations - inplace ??
struct ParametrizedType;
struct TypeExpression;

using TypeSubExpression = std::variant<
  AnyTypeIdentifier,
  ParametrizedType>;

// Typeclass

struct AnnotatedTypeclass;
struct ParametrizedTypeclass;
struct TypeclassExpression;

// Comments [IGNORE] -----------------
// Identifiers, constants, etc. -----------------

struct FloatNumberLiteral;
struct NumberLiteral;
struct StringLiteral;
struct CharLiteral;

using Literal = std::variant<
  FloatNumberLiteral,
  NumberLiteral,
  StringLiteral,
  CharLiteral>;

//

using NameSubSuperExpression = std::variant<
  NameIdentifier,
  Literal,
  SuperExpression>;

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

struct SourceFile : public Node {
  std::vector<std::variant<SourceStatement, Partition>> statements;
};

struct Sources : public Node {
  std::vector<SourceStatement> statemets;
};

// ----------------- Namespaces, partittions -----------------

struct Partition : public Node {
  enum class PartitionType {
    Test,
    Interface,
    Core,
    Lib,
    Module, // rename ??
    Exe,
  };

  PartitionType type;
  std::unique_ptr<Sources> scope;
};

struct Namespace : public Node {
  std::unique_ptr<std::variant<DefinedAnnotatedName, DefinedType>> name;
  // TODO add const / var specification
  std::unique_ptr<Sources> scope;
};

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

struct ImportStatement : public Node {
  std::string module_name;
  std::vector<AnyIdentifier> symbols; // TODO parametric import support
};

struct UsageDefinition : public Node {
  TypeIdentifier module_identifier;
  std::unique_ptr<ImportStatement> import_statement;
};

struct AliasDefinition : public Node {
  std::unique_ptr<DefinedType> name;
  std::unique_ptr<ParametrizedType> value;
};

struct VariableDefinition : public Node {
  NameIdentifier name;
  std::unique_ptr<SuperExpression> value;
};

struct FunctionDeclaration : public Node {
  NameIdentifier name;
  std::vector<std::unique_ptr<FunctionDeclarationType>> argument_types;
};

struct FunctionDefintion : public Node {
  std::unique_ptr<DefinedName> name;
  std::unique_ptr<SuperExpression> value;
};

struct AliasTypeDefinition : public Node {
  std::unique_ptr<DefinedType> name;
  std::unique_ptr<ParametrizedType> value;
};

struct TypeDefinition : public Node {
  std::unique_ptr<DefinedType> name;
  std::unique_ptr<AnyType> value;
};

struct TypeclassDefinition : public Node {
  std::unique_ptr<DefinedTypeclass> name;
  std::vector<std::unique_ptr<FunctionDeclaration>> requirements;
};

// Definition parts -----------------

struct DefinedName : public Node {
  bool is_operator = false; // other format ??
  NameOrOperatorIdentifier name; // function name or operator
  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
  std::vector<std::unique_ptr<DefinitionArgument>> arguments;
};

struct DefinedAnnotatedName : public Node {
  NameIdentifier name;
  std::unique_ptr<std::variant<DefinedType, DefinedTypeclass>> type;
};

struct DefinedType : public Node {
  std::unique_ptr<AnnotatedType> type;
  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
  std::vector<std::unique_ptr<DefinitionArgument>> arguments;
};

struct DefinedTypeclass : public Node {
  std::unique_ptr<AnnotatedTypeclass> typeclass;
  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
  std::vector<std::unique_ptr<DefinitionArgument>> arguments;
};

struct DefinitionParameter : public Node {
  AbstractTypeIdentifier abstract_type;
  std::vector<std::unique_ptr<ParametrizedTypeclass>> typeclasses;
};

struct DefinitionArgument : public Node {
  NameIdentifier name;
  std::vector<std::unique_ptr<ParametrizedType>> types;
};

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

struct MatchCase {
  std::unique_ptr<Expression> value;
  std::unique_ptr<Expression> condition;
  std::unique_ptr<Expression> statement;
};

struct Match : public Node {
  std::unique_ptr<Expression> value;
  std::vector<MatchCase> matches;
};

struct Condition : public Node {
  std::vector<std::unique_ptr<Expression>> conditions; // if, elif
  std::vector<std::unique_ptr<Expression>> stetemets; // if, elif, else
};

struct WhileLoop : public Node { // WhileLoop <-> DoWhileLoop
  std::unique_ptr<Expression> condition;
  std::unique_ptr<Expression> statement;
};

struct ForLoop : public Node {
  std::unique_ptr<AnyName> variable;
  std::unique_ptr<Expression> interval;
  std::unique_ptr<Expression> statement;
};

struct LoopLoop : public Node {
  std::unique_ptr<Expression> statement;
};

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

using BlockStatement = std::variant<
  Expression,
  AliasDefinition,
  VariableDefinition,
  FlowControl,
  PrefixedExpression>;

struct Block : public Node {
  std::vector<std::unique_ptr<BlockStatement>> statements;
};

struct ScopedStatement : public Node {
  std::unique_ptr<SuperExpression> statement;
};

// Operators -----------------

struct BinaryOperatorExpression : public Node {
  OperatorIdentifier operator_name;
  std::unique_ptr<SubExpression> left_expression;
  std::unique_ptr<SubExpression> right_expression;
};

struct UnaryOperatorExpression : public Node { // TODO fix prescendence
  OperatorIdentifier operator_name;
  std::unique_ptr<Expression> expression;
};

// Simple Expressions -----------------

using FunctionArgument = std::variant<SubExpressionToken, TypeSubExpression>;

struct FunctionCallExpression : public Node {
  std::unique_ptr<NameSuperExpression> name;
  std::vector<std::unique_ptr<FunctionArgument>> arguments;
};

struct TupleExpression : public Node {
  std::vector<std::unique_ptr<SubExpression>> expressions;
};

struct VariantExpression : public Node {
  std::vector<std::unique_ptr<SubExpression>> expressions;
};

struct ReturnExpression : public Node {
  std::unique_ptr<Expression> expression;
};

// Lambda -----------------

struct LambdaFunction : public Node {
  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
  std::vector<std::unique_ptr<DefinitionArgument>> arguments;
  std::unique_ptr<Expression> expression;
};

// Name -----------------

struct NameSuperExpression : public Node {
  std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
  std::vector<std::unique_ptr<NameSubSuperExpression>> expressions; // last is not SuperExpression
};

struct NameExpression : public Node {
  std::vector<TypeSubExpression> namespaces;
  std::vector<NameIdentifier> names;
};

struct TupleName : public Node {
  std::vector<std::unique_ptr<AnnotatedName>> names;
};

struct VariantName : public Node {
  std::vector<std::unique_ptr<AnnotatedName>> names;
};

struct AnnotatedName : public Node {
  NameIdentifier name;
  std::unique_ptr<ParametrizedType> type; // optional
};

// TODO ?? mark all optional fields ??

// Type -----------------

struct TypeConstructor : public Node {
  std::unique_ptr<ParametrizedType> type;
  std::vector<std::pair<NameIdentifier, std::unique_ptr<SubExpression>>> parameters;
};

struct TupleType : public Node {
  TypeIdentifierDefinition type; // optional
  std::vector<std::pair<NameIdentifier, std::unique_ptr<AnyType>>> entities; // NameIdentifier is optional
};

struct VariantType : public Node {
  TypeIdentifierDefinition type; // optional
  std::vector<std::pair<TypeIdentifierDefinition, std::unique_ptr<TupleType>>> constructors;
};

struct AnnotatedType : public Node {
  std::unique_ptr<TypeExpression> type_expression;
  std::vector<std::unique_ptr<ParametrizedTypeclass>> annotations;
};

using TypeParameter = std::variant<ParametrizedType, Expression>;

struct ParametrizedType : public Node {
  std::unique_ptr<TypeExpression> type_expression;
  std::vector<std::unique_ptr<TypeParameter>> parameters;
};

struct TypeExpression : public Node {
  std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
  AnyTypeIdentifier type;
};

// Typeclass -----------------

struct AnnotatedTypeclass : public Node {
    std::unique_ptr<TypeclassExpression> typeclass_expression;
    std::vector<std::unique_ptr<ParametrizedTypeclass>> annotations;
};

struct ParametrizedTypeclass : public Node {
    std::unique_ptr<TypeclassExpression> typeclass_expression;
    std::vector<std::unique_ptr<TypeParameter>> parameters;
};

struct TypeclassExpression : public Node {
    std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
    TypeclassIdentifier typeclass;
};

// ----------------- Comments [IGNORE] -----------------
// ----------------- Identifiers, constants, etc. -----------------

struct FloatNumberLiteral : public Node {
  double value;
};

struct NumberLiteral : public Node {
  int64_t value;
};

struct StringLiteral : public Node {
  std::string value;
};

struct CharLiteral : public Node {
  char value;
};

} // namespace tokens

} // namespace interpereter