use crate::spec::{EnumBuilder, Node, NodesAggregator, StructBuilder};

/// The specific syntax specification of Cairo.
pub fn get_spec() -> Vec<Node> {
    NodesAggregator::default()
    .add_list("Trivia", "Trivium")
    .add_enum(
        EnumBuilder::new("Trivium")
            .node_with_explicit_kind("SingleLineComment", "TokenSingleLineComment")
            .node_with_explicit_kind("Whitespace", "TokenWhitespace")
            .node_with_explicit_kind("Newline", "TokenNewline")
            .node_with_explicit_kind("Skipped", "TokenSkipped"),
    )
    // --- Expressions ---
    .add_enum(
        EnumBuilder::new("Expr")
            .missing("Missing")
            .node("Path")
            .node_with_explicit_kind("Literal", "TerminalLiteralNumber")
            .node_with_explicit_kind("ShortString", "TerminalShortString")
            .node_with_explicit_kind("False", "TerminalFalse")
            .node_with_explicit_kind("True", "TerminalTrue")
            .node("Parenthesized")
            .node("Unary")
            .node("Binary")
            .node("Tuple")
            .node("FunctionCall")
            .node("StructCtorCall")
            .node("Block")
            .node("Match")
            .node("If")
            .node("ErrorPropagate"),
    )
    .add_separated_list("ExprList", "Expr", "TerminalComma")
    .add_struct(StructBuilder::new("ExprMissing"))
    .add_enum(EnumBuilder::new("PathSegment").missing("Simple").node("WithGenericArgs"))
    .add_struct(StructBuilder::new("PathSegmentSimple").node("ident", "TerminalIdentifier"))
    .add_struct(StructBuilder::new("PathSegmentWithGenericArgs")
        .node("ident", "TerminalIdentifier")
        .node("separator", "TerminalColonColon")
        .node("generic_args", "GenericArgs")
        )
    .add_separated_list("ExprPath", "PathSegment", "TerminalColonColon")
    .add_struct(StructBuilder::new("ExprParenthesized")
        .node("lparen", "TerminalLParen")
        .node("expr", "Expr")
        .node("rparen", "TerminalRParen")
        )
    .add_struct(StructBuilder::new("ExprUnary").node("op", "UnaryOperator").node("expr", "Expr"))
    .add_enum(EnumBuilder::new("UnaryOperator")
        .node_with_explicit_kind("Not", "TerminalNot")
        .node_with_explicit_kind("Minus", "TerminalMinus")
        )
    .add_struct(StructBuilder::new("ExprBinary")
        .node("lhs", "Expr")
        .node("op", "BinaryOperator")
        .node("rhs", "Expr")
        )
    .add_enum(EnumBuilder::new("BinaryOperator")
            .node_with_explicit_kind("Dot", "TerminalDot")
            .node_with_explicit_kind("Not", "TerminalNot")
            .node_with_explicit_kind("Mul", "TerminalMul")
            .node_with_explicit_kind("Div", "TerminalDiv")
            .node_with_explicit_kind("Mod", "TerminalMod")
            .node_with_explicit_kind("Plus", "TerminalPlus")
            .node_with_explicit_kind("Minus", "TerminalMinus")
            .node_with_explicit_kind("EqEq", "TerminalEqEq")
            .node_with_explicit_kind("Neq", "TerminalNeq")
            .node_with_explicit_kind("Eq", "TerminalEq")
            // TODO(yuval): not yet implemented in parser.
            .node_with_explicit_kind("And", "TerminalAnd")
            .node_with_explicit_kind("Or", "TerminalOr")
            .node_with_explicit_kind("Xor", "TerminalXor")
            .node_with_explicit_kind("LE", "TerminalLE")
            .node_with_explicit_kind("GE", "TerminalGE")
            .node_with_explicit_kind("LT", "TerminalLT")
            .node_with_explicit_kind("GT", "TerminalGT")
            )
    .add_struct(StructBuilder::new("ExprTuple")
        .node("lparen", "TerminalLParen")
        .node("expressions", "ExprList")
        .node("rparen", "TerminalRParen")
        )
    .add_struct(StructBuilder::new("ExprFunctionCall")
        .node("path", "ExprPath")
        .node("arguments", "ExprListParenthesized")
        )
    .add_struct(StructBuilder::new("ExprListParenthesized")
        .node("lparen", "TerminalLParen")
        .node("expressions", "ExprList")
        .node("rparen", "TerminalRParen")
        )
    .add_struct(StructBuilder::new("ExprStructCtorCall")
        .node("path", "ExprPath")
        .node("arguments", "ArgListBraced")
        )
    .add_struct(StructBuilder::new("ExprBlock")
        .node("lbrace", "TerminalLBrace")
        .node("statements", "StatementList")
        .node("rbrace", "TerminalRBrace")
        )
    .add_struct(StructBuilder::new("ExprMatch")
        .node("match_kw", "TerminalMatch")
        // TODO(yuval): change to SimpleExpr
        .node("expr", "Expr")
        .node("lbrace", "TerminalLBrace")
        .node("arms", "MatchArms")
        .node("rbrace", "TerminalRBrace")
        )
    .add_separated_list("MatchArms", "MatchArm", "TerminalComma")
    .add_struct(StructBuilder::new("MatchArm")
        .node("pattern", "Pattern")
        .node("arrow", "TerminalMatchArrow")
        .node("expression", "Expr")
        )
    .add_struct(StructBuilder::new("ExprIf")
        .node("if_kw", "TerminalIf")
        .node("condition", "Expr")
        .node("if_block", "ExprBlock")
        .node("else_clause", "OptionElseClause")
        )
    .add_enum(EnumBuilder::new("BlockOrIf")
        .node_with_explicit_kind("Block", "ExprBlock")
        .node_with_explicit_kind("If", "ExprIf")
        )
    .add_struct(StructBuilder::new("ElseClause")
        .node("else_kw", "TerminalElse")
        .node("else_block_or_if", "BlockOrIf")
        )
    .add_option("ElseClause")
    .add_struct(StructBuilder::new("ExprErrorPropagate").node("expr", "Expr").node("op", "TerminalQuestionMark"))
    // --- Struct ctor ---
    .add_struct(StructBuilder::new("StructArgExpr")
        .node("colon", "TerminalColon")
        .node("expr", "Expr")
        )
    .add_option("StructArgExpr")
    .add_struct(StructBuilder::new("StructArgSingle")
        .key_node("identifier", "TerminalIdentifier")
        .node("arg_expr", "OptionStructArgExpr")
        )
    .add_struct(StructBuilder::new("StructArgTail")
        .node("dotdot", "TerminalDotDot")
        .node("expression", "Expr")
        )
    .add_enum(EnumBuilder::new("StructArg")
        .node_with_explicit_kind("StructArgSingle", "StructArgSingle")
        .node_with_explicit_kind("StructArgTail", "StructArgTail")
        )
    .add_separated_list("StructArgList", "StructArg", "TerminalComma")
    .add_struct(StructBuilder::new("ArgListBraced")
        .node("lbrace", "TerminalLBrace")
        .node("arguments", "StructArgList")
        .node("rbrace", "TerminalRBrace")
        )
    // ---Patterns ---
    // TODO(spapini): Support "Or" patterns (e.g. 1 | 2).
    // TODO(spapini): Support tuple patterns (e.g. (x, _)).
    .add_enum(EnumBuilder::new("Pattern")
        .node_with_explicit_kind("Underscore", "TerminalUnderscore")
        .node_with_explicit_kind("Literal", "TerminalLiteralNumber")
        .node_with_explicit_kind("ShortString", "TerminalShortString")
        .node("Identifier")
        .node("Struct")
        .node("Tuple")
        .node("Enum")
        .node_with_explicit_kind("Path", "ExprPath")
        )
    .add_struct(StructBuilder::new("PatternIdentifier")
        .node("modifiers", "ModifierList")
        .key_node("name", "TerminalIdentifier")
        )
    .add_struct(StructBuilder::new("PatternStruct")
        // TODO(spapini): Use SimplePath instead - which is not an expr.
        .node("path", "ExprPath")
        .node("lbrace", "TerminalLBrace")
        .node("params", "PatternStructParamList")
        .node("rbrace", "TerminalRBrace")
        )
    .add_separated_list("PatternStructParamList", "PatternStructParam", "TerminalComma")
    .add_struct(StructBuilder::new("PatternTuple")
        .node("lparen", "TerminalLParen")
        .node("patterns", "PatternList")
        .node("rparen", "TerminalRParen")
        )
    .add_separated_list("PatternList", "Pattern", "TerminalComma")
    .add_enum(EnumBuilder::new("PatternStructParam")
        .node_with_explicit_kind("Single", "TerminalIdentifier")
        .node("WithExpr")
        .node_with_explicit_kind("Tail", "TerminalDotDot")
        )
    .add_struct(StructBuilder::new("PatternStructParamWithExpr")
        .node("name", "TerminalIdentifier")
        .node("colon", "TerminalColon")
        .node("pattern", "Pattern")
        )
    .add_struct(StructBuilder::new("PatternEnum")
        .node("path", "ExprPath")
        .node("lparen", "TerminalLParen")
        .node("pattern", "Pattern")
        .node("rparen", "TerminalRParen")
        )
    // --- Type clauses ---
    // TODO(yuval): support SimpleExpr instead of Expr
    .add_struct(StructBuilder::new("TypeClause").node("colon", "TerminalColon").node("ty", "Expr"))
    .add_option("TypeClause")
    .add_struct(StructBuilder::new("ReturnTypeClause")
        .node("arrow", "TerminalArrow")
        .node("ty", "Expr")
        )
    .add_option("ReturnTypeClause")
    // --- Statements ---
    .add_enum(EnumBuilder::new("Statement")
        .missing("Missing")
        .node("Let")
        .node("Expr")
        .node("Return")
        )
    .add_list("StatementList", "Statement")
    .add_struct(StructBuilder::new("StatementMissing"))
    .add_struct(StructBuilder::new("StatementLet")
        .node("let_kw", "TerminalLet")
        .key_node("pattern", "Pattern")
        .node("type_clause", "OptionTypeClause")
        .node("eq", "TerminalEq")
        .node("rhs", "Expr")
        .node("semicolon", "TerminalSemicolon")
        )
    .add_option("TerminalSemicolon")
    .add_struct(StructBuilder::new("StatementExpr")
        .node("expr", "Expr")
        .node("semicolon", "OptionTerminalSemicolon")
        )
    .add_struct(StructBuilder::new("StatementReturn")
        .node("return_kw", "TerminalReturn")
        .node("expr", "Expr")
        .node("semicolon", "TerminalSemicolon")
        )
    // --- Functions ---
    .add_enum(EnumBuilder::new("ParamName")
        .node_with_explicit_kind("Underscore", "TerminalUnderscore")
        .node_with_explicit_kind("Name", "TerminalIdentifier")
        )
    .add_struct(StructBuilder::new("Param")
        .node("modifiers", "ModifierList")
        .key_node("name", "ParamName")
        .node("type_clause", "TypeClause")
        )
    .add_list("ModifierList", "Modifier")
    .add_enum(EnumBuilder::new("Modifier")
        .node_with_explicit_kind("Ref", "TerminalRef")
        .node_with_explicit_kind("Mut", "TerminalMut")
        )
    .add_separated_list("ParamList", "Param", "TerminalComma")
    .add_struct(StructBuilder::new("ImplicitsClause")
        .node("implicits_kw", "TerminalImplicits")
        .node("lparen", "TerminalLParen")
        .node("implicits", "ImplicitsList")
        .node("rparen", "TerminalRParen")
        )
    .add_separated_list("ImplicitsList", "ExprPath", "TerminalComma")
    .add_option("ImplicitsClause")
    .add_option("TerminalNoPanic")
    // TODO(spapini): Add generic params.
    // This is an unnamed signature, e.g. "() -> Type".
    .add_struct(StructBuilder::new("FunctionSignature")
        .node("lparen", "TerminalLParen")
        .node("parameters", "ParamList")
        .node("rparen", "TerminalRParen")
        .node("ret_ty", "OptionReturnTypeClause")
        .node("implicits_clause", "OptionImplicitsClause")
        .node("optional_no_panic", "OptionTerminalNoPanic")
        )
    // --- Struct Members ---
    // Struct member and enum variant have the same structure.
    .add_struct(StructBuilder::new("Member")
        .key_node("name", "TerminalIdentifier")
        .node("type_clause", "TypeClause")
        )
    .add_separated_list("MemberList", "Member", "TerminalComma")
    // --- Items ---
    .add_enum(EnumBuilder::new("Item")
        .node("Module")
        .node("Use")
        .node("FreeFunction")
        .node("ExternFunction")
        .node("ExternType")
        .node("Trait")
        .node("Impl")
        .node("Struct")
        .node("Enum")
        .node("TypeAlias")
        )
    .add_list("ItemList", "Item")
    .add_struct(StructBuilder::new("Attribute")
         .node("hash", "TerminalHash")
         .node("lbrack", "TerminalLBrack")
         .node("attr", "TerminalIdentifier")
         .node("args", "OptionAttributeArgs")
         .node("rbrack", "TerminalRBrack")
        )
    .add_list("AttributeList", "Attribute")
    .add_struct(StructBuilder::new("ItemModule")
        .node("attributes" ,"AttributeList")
        .node("module_kw", "TerminalModule")
        .key_node("name", "TerminalIdentifier")
        .node("body", "MaybeModuleBody")
        )
    .add_enum(EnumBuilder::new("MaybeModuleBody")
        .node_with_explicit_kind("Some", "ModuleBody")
        .node_with_explicit_kind("None", "TerminalSemicolon")
     )
    .add_struct(StructBuilder::new("ModuleBody")
            .node("lbrace", "TerminalLBrace")
            .node("items", "ItemList")
            .node("rbrace", "TerminalRBrace")
    )
    .add_option("AttributeArgs")
    .add_struct(StructBuilder::new("AttributeArgs")
        .node("lparen", "TerminalLParen")
        .node("arg_list", "AttributeArgList")
        .node("rangle", "TerminalRParen")
        )
    .add_separated_list("AttributeArgList", "Expr", "TerminalComma")
    .add_struct(StructBuilder::new("FunctionDeclaration")
        .node("function_kw", "TerminalFunction")
        .key_node("name", "TerminalIdentifier")
        .node("generic_params", "OptionWrappedGenericParamList")
        .node("signature", "FunctionSignature")
        )
    .add_struct(StructBuilder::new("ItemFreeFunction")
        .node("attributes" ,"AttributeList")
         // TODO(ilya): Use only the name as key node.
        .key_node("declaration", "FunctionDeclaration")
        .node("body", "ExprBlock")
        )
    .add_struct(StructBuilder::new("ItemExternFunction")
        .node("attributes" ,"AttributeList")
        .node("extern_kw", "TerminalExtern")
         // TODO(ilya): Use only the name as key node.
        .key_node("declaration", "FunctionDeclaration")
        .node("semicolon", "TerminalSemicolon")
        )
    .add_struct(StructBuilder::new("ItemExternType")
        .node("attributes" ,"AttributeList")
        .node("extern_kw", "TerminalExtern")
        .node("type_kw", "TerminalType")
        .key_node("name", "TerminalIdentifier")
        .node("generic_params", "OptionWrappedGenericParamList")
        .node("semicolon", "TerminalSemicolon")
        )
    // TODO(spapini): consider having specific ItemLists here.
    .add_struct(StructBuilder::new("ItemTrait")
        .node("attributes" ,"AttributeList")
        .node("trait_kw", "TerminalTrait")
        .key_node("name", "TerminalIdentifier")
        .node("generic_params", "OptionWrappedGenericParamList")
        .node("body", "MaybeTraitBody")
        )
    .add_enum(EnumBuilder::new("MaybeTraitBody")
        .node_with_explicit_kind("Some", "TraitBody")
        .node_with_explicit_kind("None", "TerminalSemicolon")
        )
    .add_struct(StructBuilder::new("TraitBody")
        .node("lbrace", "TerminalLBrace")
        .node("items", "TraitItemList")
        .node("rbrace", "TerminalRBrace")
    )
    .add_list("TraitItemList", "TraitItem")
    .add_enum(EnumBuilder::new("TraitItem")
        // TODO(spapini): types and constants.
        .node("Function")
        )
    .add_struct(StructBuilder::new("TraitItemFunction")
        .node("attributes" ,"AttributeList")
         // TODO(ilya): Use only the name as key node.
        .key_node("declaration", "FunctionDeclaration")
        .node("body", "MaybeTraitFunctionBody")
    )
    .add_enum(EnumBuilder::new("MaybeTraitFunctionBody")
        .node_with_explicit_kind("Some", "ExprBlock")
        .node_with_explicit_kind("None", "TerminalSemicolon")
        )
    .add_struct(StructBuilder::new("ItemImpl")
        .node("attributes" ,"AttributeList")
        .node("impl_kw", "TerminalImpl")
        .key_node("name", "TerminalIdentifier")
        .node("generic_params", "OptionWrappedGenericParamList")
        .node("of_kw", "TerminalOf")
        .node("trait_path", "ExprPath")
        .node("body", "MaybeImplBody")
        )
    .add_enum(EnumBuilder::new("MaybeImplBody")
        .node_with_explicit_kind("Some", "ImplBody")
        .node_with_explicit_kind("None", "TerminalSemicolon")
        )
    .add_struct(StructBuilder::new("ImplBody")
            .node("lbrace", "TerminalLBrace")
            .node("items", "ItemList")
            .node("rbrace", "TerminalRBrace")
        )
    .add_struct(StructBuilder::new("ItemStruct")
        .node("attributes" ,"AttributeList")
        .node("struct_kw", "TerminalStruct")
        .key_node("name", "TerminalIdentifier")
        .node("generic_params", "OptionWrappedGenericParamList")
        .node("lbrace", "TerminalLBrace")
        .node("members", "MemberList")
        .node("rbrace", "TerminalRBrace")
        )
    .add_struct(StructBuilder::new("ItemEnum")
        .node("attributes" ,"AttributeList")
        .node("enum_kw", "TerminalEnum")
        .key_node("name", "TerminalIdentifier")
        .node("generic_params", "OptionWrappedGenericParamList")
        .node("lbrace", "TerminalLBrace")
        .node("variants", "MemberList")
        .node("rbrace", "TerminalRBrace")
        )
    .add_struct(StructBuilder::new("ItemTypeAlias")
        .node("attributes" ,"AttributeList")
        .node("type_kw", "TerminalType")
        .key_node("name", "TerminalIdentifier")
        .node("generic_params", "OptionWrappedGenericParamList")
        .node("eq", "TerminalEq")
        .node("ty", "Expr")
        .node("semicolon", "TerminalSemicolon")
        )
    .add_struct(StructBuilder::new("ItemUse")
        .node("attributes" ,"AttributeList")
        .node("use_kw", "TerminalUse")
        .key_node("name", "ExprPath")
        .node("semicolon", "TerminalSemicolon")
        )
    // --- Generics ---
    .add_struct(StructBuilder::new("GenericArgs")
        .node("langle", "TerminalLT")
        .node("generic_args", "GenericArgList")
        .node("rangle", "TerminalGT")
        )
    .add_separated_list("GenericArgList", "Expr", "TerminalComma")
    .add_option("WrappedGenericParamList")
    .add_struct(StructBuilder::new("WrappedGenericParamList")
        .node("langle", "TerminalLT")
        .node("generic_params", "GenericParamList")
        .node("rangle", "TerminalGT")
        )
    .add_separated_list("GenericParamList", "GenericParam", "TerminalComma")
    // TODO(spapini): Remove this indirection.
    .add_struct(StructBuilder::new("GenericParam").key_node("name", "TerminalIdentifier"))
    // --- Tokens + Terminals ---
    .add_token_and_terminal("Identifier")
    .add_token_and_terminal("LiteralNumber")
    .add_token_and_terminal("ShortString")
    .add_keyword_token_and_terminal("False")
    .add_keyword_token_and_terminal("True")
    .add_keyword_token_and_terminal("Extern")
    .add_keyword_token_and_terminal("Type")
    .add_keyword_token_and_terminal("Function")
    .add_keyword_token_and_terminal("Module")
    .add_keyword_token_and_terminal("Enum")
    .add_keyword_token_and_terminal("Struct")
    .add_keyword_token_and_terminal("Trait")
    .add_keyword_token_and_terminal("Impl")
    .add_keyword_token_and_terminal("Of")
    .add_keyword_token_and_terminal("Let")
    .add_keyword_token_and_terminal("Return")
    .add_keyword_token_and_terminal("Match")
    .add_keyword_token_and_terminal("If")
    .add_keyword_token_and_terminal("Else")
    .add_keyword_token_and_terminal("Use")
    .add_keyword_token_and_terminal("Implicits")
    .add_keyword_token_and_terminal("Ref")
    .add_keyword_token_and_terminal("Mut")
    .add_keyword_token_and_terminal("NoPanic")
    .add_token_and_terminal("And")
    .add_token_and_terminal("AndAnd")
    .add_token_and_terminal("Or")
    .add_token_and_terminal("OrOr")
    .add_token_and_terminal("Xor")
    .add_token_and_terminal("EqEq")
    .add_token_and_terminal("Neq")
    .add_token_and_terminal("GE")
    .add_token_and_terminal("GT")
    .add_token_and_terminal("LE")
    .add_token_and_terminal("LT")
    .add_token_and_terminal("Not")
    .add_token_and_terminal("Plus")
    .add_token_and_terminal("Minus")
    .add_token_and_terminal("Mul")
    .add_token_and_terminal("Div")
    .add_token_and_terminal("Mod")
    .add_token_and_terminal("Colon")
    .add_token_and_terminal("ColonColon")
    .add_token_and_terminal("Comma")
    .add_token_and_terminal("Dot")
    .add_token_and_terminal("DotDot")
    .add_token_and_terminal("Eq")
    .add_token_and_terminal("Semicolon")
    .add_token_and_terminal("QuestionMark")
    .add_token_and_terminal("Underscore")
    .add_token_and_terminal("Hash")
    .add_token_and_terminal("LBrace")
    .add_token_and_terminal("RBrace")
    .add_token_and_terminal("LBrack")
    .add_token_and_terminal("RBrack")
    .add_token_and_terminal("LParen")
    .add_token_and_terminal("RParen")
    .add_token_and_terminal("Arrow")
    .add_token_and_terminal("MatchArrow")
    .add_token_and_terminal("EndOfFile")
    .add_token_and_terminal("BadCharacters")
    // --- Meta ---
    .add_struct(StructBuilder::new("SyntaxFile")
        .node("items", "ItemList")
        .node("eof", "TerminalEndOfFile")
        )
    .add_token("SingleLineComment")
    .add_token("Whitespace")
    .add_token("Newline")
    .add_token("Missing")
    .add_token("Skipped").get()
}