tlang.lalrpop

use crate::tree::Expr;
use crate::tree::Literal;
use crate::tree::Op;

grammar;

pub Exprs : Expr = MultiLine<Expr> => Expr::Block {
    body: <>
};
Identifier : Expr = <i:r"[a-zA-Z_][a-zA-Z0-9_]*"> => Expr::Ident{name: i.to_string()};
Block: Expr = "{" <e:Exprs> "}" => e;
Num : Expr = <n:r"[0-9]+"> => Expr::Literal{value: Literal::Number(n.parse::<f64>().unwrap())} ;
Str : Expr = <s:r#"'(\\.|[^"])*'"#> => Expr::Literal{value: Literal::String(s[1..s.len()-1].to_string())} ;
IfExpr : Expr = "if" <e:Expr> "{" <e1:Exprs>  "}" => Expr::IfThen{cond: Box::new(e), then: Box::new(e1)};
IfElseExpr : Expr = <e1:IfExpr> "else" <e2:Block>  => {
    match e1 {
        Expr::IfThen{cond, then} => Expr::IfThenElse{cond, then, else_: Box::new(e2)},
        _ => panic!("Invalid if-else expression")
    }
};

ForExpr : Expr = "for" <e1:Expr> "in" <e2:Expr> "{" <e3:Exprs> "}" => Expr::For{
    name: Box::new(e1),
    iter: Box::new(e2),
    body: Box::new(e3)
};

WhileExpr : Expr = "while" <e1:Expr> "{" <e2:Exprs> "}" => Expr::While{
    cond: Box::new(e1),
    body: Box::new(e2)
};

LetExpr : Expr = "let" <e1:Identifier> "=" <e2:Expr>  => Expr::Assign{name: match e1 {
    Expr::Ident{name} => name,
    _ => panic!("Invalid let expression")
}, value: Box::new(e2)};


Op: Expr = {
    <e1:Term> "+" <e2:Fact> => Expr::BinOp{left: Box::new(e1), op: Op::Add, right: Box::new(e2)},
    <e1:Term> "-" <e2:Fact> => Expr::BinOp{left: Box::new(e1), op: Op::Sub, right: Box::new(e2)},
    Fact
};


Fact: Expr = {
    <e1:Fact> "*" <e2:Term> => Expr::BinOp{left: Box::new(e1), op: Op::Mul, right: Box::new(e2)},
    <e1:Fact> "/" <e2:Term> => Expr::BinOp{left: Box::new(e1), op: Op::Div, right: Box::new(e2)},
    Term
};

CmpOp: Expr = {
    <e1:Term> "==" <e2:Term> => Expr::BinOp{left: Box::new(e1), op: Op::Eq, right: Box::new(e2)},
    <e1:Term> "!=" <e2:Term> => Expr::BinOp{left: Box::new(e1), op: Op::Neq, right: Box::new(e2)},
    <e1:Term> "<" <e2:Term> => Expr::BinOp{left: Box::new(e1), op: Op::Lt, right: Box::new(e2)},
    <e1:Term> "<=" <e2:Term> => Expr::BinOp{left: Box::new(e1), op: Op::Le, right: Box::new(e2)},
    <e1:Term> ">" <e2:Term> => Expr::BinOp{left: Box::new(e1), op: Op::Gt, right: Box::new(e2)},
    <e1:Term> ">=" <e2:Term> => Expr::BinOp{left: Box::new(e1), op: Op::Ge, right: Box::new(e2)}
};



List: Expr = {
    "[" <s:Expr *> <e:("," Expr)*> "]" => {
        let i = s.into_iter();
        let n = e.into_iter().map(|x| x.1);
        Expr::List {
            elems: i.chain(n).collect::<Vec<Expr>>()
        }
    }
};

ArgDef: Vec<Expr> = {
    "(" <s:Identifier*> <e:("," Identifier)*> ")"  => {
        let i = s.into_iter();
        let n = e.into_iter().map(|x| x.1);
        i.chain(n).collect::<Vec<Expr>>()
    }
}; 

ArgCall: Vec<Expr> = {
    "(" <s:Expr*> <e:("," Expr)*> ")"  => {
        let i = s.into_iter();
        let n = e.into_iter().map(|x| x.1);
        i.chain(n).collect::<Vec<Expr>>()
    }
};

FunDef : Expr = "def" <e1:Identifier>  <e2:ArgDef>  "{" <e3:Exprs> "}" => {
    match e1 {
        Expr::Ident{name} => Expr::FunDef{name, args: e2, body: Box::new(e3) },
        _ => panic!("Invalid function definition")
    }
}; 

True : Expr = "true" => Expr::Literal{value: Literal::Bool(true)};
False : Expr = "false" => Expr::Literal{value: Literal::Bool(false)};

Call : Expr = "@" <e1:Identifier> <e2:ArgCall>  => Expr::Call{name: match e1 {
    Expr::Ident{name} => name,
    _ => panic!("Invalid function call")
}, args: e2};


Value = { Num, Str, Identifier , True, False, Call, List};
Term = {
    Value,
    "(" <e:Expr> ")" => e,

};
Expr = {
    Block,
    IfExpr,
    IfElseExpr,
    ForExpr,
    WhileExpr,
    LetExpr,
    Op,
    CmpOp,
    FunDef
};



MultiLine<T> : Vec<T> = {
    <v:(<T> "\n") *> <e:T*>  => {
        v.into_iter().chain(e).collect()
    }
};