use crate::ast;

grammar(id_generator: &ast::IdGenerator);

match {
    r"[0-9]+",
    r"[0-9]+\.[0-9]+",
    r"[A-Za-z_][A-Za-z0-9_]*",
    ":",
    ";",
    "{",
    "}",
    "(",
    ")",
    ".",
    "+",
    "-",
    "*",
    "/",
    "fn",
    "return",
    "let",
    "true",
    "false",
    "if",
    "else",
    "=",
    "for",
    "type",
    "trait",
    "struct",
    "impl",
    ",",

    r"\s*" => { },
    r"//[^\n\r]*[\n\r]*" => { }, // `// comment`
}


pub LiteralInt: String = {
    <literal:r"[0-9]+"> => literal.to_string()
};

pub SpannedLiteralInt: ast::LiteralInt = {
    <literal_int:Spanned<LiteralInt>> => ast::LiteralInt{value: literal_int, type_: ast::TypeUsage::new_builtin("i64".to_string())}
};

pub LiteralFloat: String = {
    <literal:r"[0-9]+\.[0-9]+"> => literal.to_string()
};

pub SpannedLiteralFloat: ast::LiteralFloat = {
    <literal_float:Spanned<LiteralFloat>> => ast::LiteralFloat{value: literal_float, type_: ast::TypeUsage::new_builtin("f64".to_string())}
};

pub LiteralBool: String = {
    "true" => "true".to_string(),
    "false" => "false".to_string(),
};

pub SpannedLiteralBool: ast::LiteralBool = {
    <literal_bool:Spanned<LiteralBool>> => ast::LiteralBool{value: literal_bool, type_: ast::TypeUsage::new_builtin("bool".to_string())}
};

pub Identifier: String = {
    <i:r"[A-Za-z_][A-Za-z0-9_]*"> => i.to_string()
};

pub LiteralStructField: (ast::Identifier, ast::Expression) = {
    <field:SpannedIdentifier> ":" <expr:Expression> => (field, expr)
};

pub LiteralStruct: ast::LiteralStruct = {
    <i:SpannedIdentifier> "{" <field_list:Comma<LiteralStructField>> "}" => ast::LiteralStruct{
        name: i.clone(),
        fields: field_list,
        type_: ast::TypeUsage::new_named(i.clone()),
    }
};

pub SpannedIdentifier: ast::Identifier = {
    <i:Spanned<Identifier>> => ast::Identifier{name: i}
};

pub FunctionCall: ast::FunctionCall = {
    <source:Term> "(" <args:Comma<Expression>> ")" => ast::FunctionCall{source: source, arguments: args, type_: ast::TypeUsage::new_unknown(&id_generator)}
};

pub StructGetter: ast::StructGetter = {
    <source:Term> "." <field:SpannedIdentifier> => ast::StructGetter{source: source, attribute: field, type_: ast::TypeUsage::new_unknown(&id_generator)}
};

pub VariableUsage: ast::VariableUsage = {
    <identifier:SpannedIdentifier> => ast::VariableUsage{name: identifier, type_: ast::TypeUsage::new_unknown(&id_generator)}
};

pub IfExpression: ast::IfExpression = {
    "if" "("<c:Expression>")" <b:Block> => ast::IfExpression{condition: c, block: b, else_: None, type_: ast::TypeUsage::new_unknown(&id_generator)},
    "if" "("<c:Expression>")" <b:Block> "else" <e:Block> => ast::IfExpression{condition: c, block: b, else_: Some(e), type_: ast::TypeUsage::new_unknown(&id_generator)},
};

pub Expression: ast::Expression = {
    <l:Expression> "+" <r:Factor> => {
        ast::Expression{
            subexpression: Box::new(ast::Subexpression::Op(ast::Operation{left: l, op: ast::Operator::Plus, right: r})),
            type_: ast::TypeUsage::new_unknown(&id_generator),
        }
    },
    <l:Expression> "-" <r:Factor> => {
        ast::Expression{
            subexpression: Box::new(ast::Subexpression::Op(ast::Operation{left: l, op: ast::Operator::Minus, right: r})),
            type_: ast::TypeUsage::new_unknown(&id_generator),
        }
    },
    Factor,
};

pub Factor: ast::Expression = {
    <l:Factor> "*" <r:Term> => {
        ast::Expression{
            subexpression: Box::new(ast::Subexpression::Op(ast::Operation{left: l, op: ast::Operator::Mul, right: r})),
            type_: ast::TypeUsage::new_unknown(&id_generator),
        }
    },
    <l:Factor> "/" <r:Term> => {
        ast::Expression{
            subexpression: Box::new(ast::Subexpression::Op(ast::Operation{left: l, op: ast::Operator::Div, right: r})),
            type_: ast::TypeUsage::new_unknown(&id_generator),
        }
    },
    Term,
};

pub Term: ast::Expression = {
    SpannedLiteralInt => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralInt(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    SpannedLiteralFloat => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralFloat(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    SpannedLiteralBool => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralBool(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    LiteralStruct => ast::Expression{subexpression: Box::new(ast::Subexpression::LiteralStruct(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    FunctionCall => ast::Expression{subexpression: Box::new(ast::Subexpression::FunctionCall(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    StructGetter => ast::Expression{subexpression: Box::new(ast::Subexpression::StructGetter(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    VariableUsage => ast::Expression{subexpression: Box::new(ast::Subexpression::VariableUsage(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    IfExpression => ast::Expression{subexpression: Box::new(ast::Subexpression::If(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    Block => ast::Expression{subexpression: Box::new(ast::Subexpression::Block(<>)), type_: ast::TypeUsage::new_unknown(&id_generator)},
    "(" <e:Expression> ")" => e,
};


pub ReturnStatement: ast::ReturnStatement = {
    "return" <e:Expression> => ast::ReturnStatement{source: e}
};

pub LetStatement: ast::LetStatement = {
    //TODO: support destructuring with tuples, when they exist.
    //TODO: add mut, weak
    "let" <n:SpannedIdentifier> "=" <e:Expression> => ast::LetStatement{variable_name: n, type_: ast::TypeUsage::new_unknown(&id_generator), expression: e},
    "let" <n:SpannedIdentifier> ":" <t:TypeUsage> "=" <e:Expression> => ast::LetStatement{variable_name: n, type_: t, expression: e},
};

pub AssignmentStatement: ast::AssignmentStatement = {
    <v:VariableUsage> "=" <e:Expression> => ast::AssignmentStatement{source: ast::AssignmentTarget::Variable(v), expression: e},
    <sg:StructGetter> "=" <e:Expression> => ast::AssignmentStatement{source: ast::AssignmentTarget::StructAttr(sg), expression: e},
};

pub Statement: ast::Statement = {
    <r:ReturnStatement> ";" => ast::Statement::Return(r),
    <l:LetStatement> ";" => ast::Statement::Let(l),
    <a:AssignmentStatement> ";" => ast::Statement::Assignment(a),
    <e:Expression> ";" => ast::Statement::Expression(e),
};

pub Block: ast::Block = {
    "{" <v:(<Statement>)*> <e:Expression?> "}" => match e {
        None => ast::Block{statements: v, type_: ast::TypeUsage::new_unknown(&id_generator)},
        Some(e) => {
            let mut v = v;
            v.push(ast::Statement::Expression(e));
            ast::Block{statements: v, type_: ast::TypeUsage::new_unknown(&id_generator)}
        }
    }
};

pub TypeUsage: ast::TypeUsage = {
    <n:SpannedIdentifier> => ast::TypeUsage::Named(ast::NamedTypeUsage{name: n}),
    "fn" "(" <args:Comma<TypeUsage>> ")" => ast::TypeUsage::Function(ast::FunctionTypeUsage{arguments: args, return_type: Box::new(ast::new_unit())}),
    "fn" "(" <args:Comma<TypeUsage>> ")" ":" <rt:TypeUsage> => ast::TypeUsage::Function(ast::FunctionTypeUsage{arguments: args, return_type: Box::new(rt)}),
};

pub VariableDeclaration: ast::VariableDeclaration = {
    <i:SpannedIdentifier> ":" <t:TypeUsage> => ast::VariableDeclaration{name: i, type_: t},
};

pub FunctionDeclaration: ast::FunctionDeclaration = {
    "fn" <n:SpannedIdentifier> "(" <args:Comma<VariableDeclaration>> ")" => ast::FunctionDeclaration{name: n, arguments: args, return_type: ast::new_unit()},
    "fn" <n:SpannedIdentifier> "(" <args:Comma<VariableDeclaration>> ")" ":" <rt:TypeUsage> => ast::FunctionDeclaration{name: n, arguments: args, return_type: rt},
};

pub Function: ast::Function = {
    <d:FunctionDeclaration> <b:Block> => ast::Function{declaration: d, block: b}
};

pub StructField: ast::StructField = {
    <i:SpannedIdentifier> ":" <t:TypeUsage> => ast::StructField{name: i, type_: t},
};

pub StructTypeDeclaration: ast::StructTypeDeclaration = {
    "type" <i:SpannedIdentifier> "struct" "{" <f:Comma<StructField>> "}" => ast::StructTypeDeclaration{name: i, fields: f}
};

pub AliasTypeDeclaration: ast::AliasTypeDeclaration = {
    "type" <i:SpannedIdentifier> "=" <t:TypeUsage> ";" => ast::AliasTypeDeclaration{name: i, replaces: t}
};

pub TraitItem: ast::TraitItem = {
    <fd:FunctionDeclaration> ";" => ast::TraitItem::FunctionDeclaration(fd),
    <f:Function> => ast::TraitItem::Function(f),
};

pub TraitTypeDeclaration: ast::TraitTypeDeclaration = {
    "type" <i:SpannedIdentifier> "trait" "{" <ti:TraitItem*> "}" => ast::TraitTypeDeclaration{name: i, functions: ti},
};

pub TypeDeclaration: ast::TypeDeclaration = {
    <s:StructTypeDeclaration> => ast::TypeDeclaration::Struct(s),
    <a:AliasTypeDeclaration> => ast::TypeDeclaration::Alias(a),
    <t:TraitTypeDeclaration> => ast::TypeDeclaration::Trait(t),
};

pub Impl: ast::Impl = {
    "impl" <i:SpannedIdentifier> "{" <f:Function*> "}" => ast::Impl{trait_: None, struct_name: i, functions: f},
    "impl" <t:SpannedIdentifier> "for" <i:SpannedIdentifier> "{" <f:Function*> "}" => ast::Impl{trait_: Some(t), struct_name: i, functions: f},
};

pub ModuleItem: ast::ModuleItem = {
    <f:Function> => ast::ModuleItem::Function(f),
    <td:TypeDeclaration> => ast::ModuleItem::TypeDeclaration(td),
    <i:Impl> => ast::ModuleItem::Impl(i),
};

pub Module: ast::Module = {
    <i:ModuleItem*> => ast::Module{items: i}
};

// From https://lalrpop.github.io/lalrpop/tutorial/006_macros.html
// Comma seperated list of T with optional trailing comma
Comma<T>: Vec<T> = {
    <v:(<T> ",")*> <e:T?> => match e {
        None => v,
        Some(e) => {
            let mut v = v;
            v.push(e);
            v
        }
    }
};

Spanned<Rule>: ast::Spanned<Rule> = {
  <l: @L> <rule: Rule> <r: @R> => ast::Spanned{span: ast::Span{left: l, right: r}, value: rule}
};