use crate::{
	ast::{
		self,
		expr::{self, Expr},
		pat::Pat,
		typ::{self, Type},
	},
	token::*,
};

pub use rules::*;

peg::parser! {
	pub grammar rules<'a>() for TokenStream<'a> {
		use expr::OpBinary::*;
		use expr::OpUnary::*;

		pub rule recipe() -> ast::Recipe<'a>
			= recipe:recipe_stmt()* { recipe }

		pub rule recipe_stmt() -> ast::RecipeStmt<'a>
			= [Token::Keyword(Keyword::Fetch)] name:ident() p('{') body:body() p('}') {
				ast::RecipeStmt::Fetch { name, body: ast::Body(Vec::new()) }
			}
			/ [Token::Keyword(Keyword::Task)] name:ident() p('(') params:func_params() p(')')
			  p('{') body:body() p('}') {
				ast::RecipeStmt::Task { name, params, body }
			}
			/ stmt:body_stmt() p(';') {
				ast::RecipeStmt::BodyStmt(stmt)
			}

		pub rule body() -> ast::Body<'a>
			= body:body_stmt() ++ p(';') { ast::Body(body) }

		pub rule body_stmt() -> ast::BodyStmt<'a>
			= dest:typed_pat() op:assign_op() expr:expr() {
				ast::BodyStmt::assign(dest, op, false, expr)
			}
			/ dest:typed_pat() p2('=', '+') expr:expr() {
				ast::BodyStmt::assign(dest, Some(Add), true, expr)
			}
			/ expr:expr() {
				ast::BodyStmt::Expr { expr: Box::new(expr) }
			}
			/ { ast::BodyStmt::Empty }

		rule assign_op() -> Option<expr::OpBinary>
			= p('=') { None }
			/ p2('+', '=') { Some(Add) }
			/ p2('-', '=') { Some(Sub) }
			/ p2('*', '=') { Some(Mul) }
			/ p2('/', '=') { Some(Div) }
			/ p2('%', '=') { Some(Rem) }

		rule typed_pat() -> ast::TypedPat<'a>
			= pat:pat() typ:tagged(<p(':')>, <typ()>)? { ast::TypedPat { pat, typ } }

		rule typ() -> Type<'a>
			= lit:typ_literal() { Type::Literal(lit) }
			/ path:path() { Type::Path(path) }
			/ p('(') t:typ() p(')') { Type::Paren(Box::new(t)) }

		rule typ_literal() -> typ::Literal<'a>
			= p('(') p(')') { typ::Literal::Unit }
			/ p('(') elements:(typ() ** p(',')) p(',')? p(')') {
				typ::Literal::Tuple(elements)
			}
			/ p('[') typ:typ() len:tagged(<p(';')>, <number()>)? p(']') { ?
				let len = len
					.map(|n| usize::try_from(n).or(Err("Invalid array length")))
					.transpose()?;
				Ok(typ::Literal::Array(Box::new(typ), len))
			}
			/ p('{') entries:delimited(<struct_field_typ()>, <p(',')>) p('}') {
				typ::Literal::Struct(entries)
			}

		rule pat() -> Pat<'a>
			= path:path() { Pat::Path(path) }

		rule struct_field_typ() -> typ::StructField<'a>
			= field:field() p(':') typ:typ() {
				typ::StructField { name: field.name, typ }
			}

		pub rule expr() -> Expr<'a> = precedence! {
			left:(@) p2('|', '|') right:@ { Expr::binary(left, Or, right) }
			--
			left:(@) p2('&', '&') right:@ { Expr::binary(left, And, right) }
			--
			left:(@) p2('=', '=') right:@ { Expr::binary(left, Eq, right) }
			left:(@) p2('!', '=') right:@ { Expr::binary(left, Ne, right) }
			left:(@) p('<')  right:@ { Expr::binary(left, Lt, right) }
			left:(@) p('>')  right:@ { Expr::binary(left, Gt, right) }
			left:(@) p2('<', '=') right:@ { Expr::binary(left, Le, right) }
			left:(@) p2('>', '=') right:@ { Expr::binary(left, Ge, right) }
			--
			left:(@) p('+')  right:@ { Expr::binary(left, Add, right) }
			left:(@) p('-')  right:@ { Expr::binary(left, Sub, right) }
			--
			left:(@) p('*')  right:@ { Expr::binary(left, Mul, right) }
			left:(@) p('/')  right:@ { Expr::binary(left, Div, right) }
			left:(@) p('%')  right:@ { Expr::binary(left, Rem, right) }
			--
			p('-') expr:@ { Expr::unary(Neg, expr) }
			p('!') expr:@ { Expr::unary(Not, expr) }
			--
			expr:@ p('(') params:call_params() p(')') {
				Expr::apply(expr, params)
			}
			expr:@ p('[') index:expr() p(']') { Expr::index(expr, index) }
			--
			expr:@ p('.') method:field() p('(') params:call_params() p(')') {
				Expr::method(expr, method, params)
			}
			expr:@ p('.') field:field() { Expr::field(expr, field) }
			--
			p('(') e:expr() p(')') { Expr::paren(e) }
			e:atom() { e }
		}

		rule atom() -> Expr<'a>
			= lit:literal() { Expr::Literal(lit) }
			/ path:path() { Expr::Path(path) }

		rule call_params() -> Vec<expr::Expr<'a>>
			= args:delimited(<expr()>, <p(',')>) { args }

		rule func_params() -> Vec<ast::FuncParam<'a>>
			= params:delimited(<func_param()>, <p(',')>) { params }

		rule func_param() -> ast::FuncParam<'a>
			= name:ident() p(':') typ:typ() { ast::FuncParam { name, typ } }

		rule literal() -> expr::Literal<'a>
			= [Token::Keyword(Keyword::True)] { expr::Literal::Bool(true) }
			/ [Token::Keyword(Keyword::False)] { expr::Literal::Bool(false) }
			/ n:number() { expr::Literal::Int(n) }
			/ [Token::Str(Str { pieces, kind })] { ?
				let pieces = pieces
					.iter()
					.map(|piece| piece.try_into())
					.collect::<Result<_, _>>()?;
				Ok(expr::Literal::Str{ pieces, kind: *kind })
			}
			/ p('(') p(')') { expr::Literal::Unit }
			/ p('(') elements:(expr() ** p(',')) p(',')? p(')') {
				expr::Literal::Tuple(elements)
			}
			/ p('[') elements:delimited(<expr()>, <p(',')>) p(']') {
				expr::Literal::Array(elements)
			}
			/ p('{') entries:delimited(<struct_field()>, <p(',')>) p('}') {
				expr::Literal::Struct(entries)
			}

		rule struct_field() -> expr::StructField<'a>
			= field:field() p('=') value:expr() {
				expr::StructField { name: field.name, value }
			}

		rule path() -> ast::Path<'a>
			= components:ident() ++ p2(':', ':') { ast::Path { components } }

		rule field() -> ast::Ident<'a>
			= ident()
			/ [Token::Number(content)] {
				ast::Ident { name: content }
			}

		rule number() -> u64
			= [Token::Number(s)] { ?
				let (radix, rest) = if let Some(rest) = s.strip_prefix("0x") {
					(16, rest)
				} else if let Some(rest) = s.strip_prefix("0o") {
					(8, rest)
				} else if let Some(rest) = s.strip_prefix("0b") {
					(2, rest)
				} else {
					(10, *s)
				};
				let digits = rest.replace('_', "");
				u64::from_str_radix(&digits, radix).or(Err("number"))
			}

		rule p_(ch: char)
			= [Token::Punct(Punct(c, Spacing::Joint)) if *c == ch] {}

		rule p(ch: char) -> ()
			= [Token::Punct(Punct(c, _)) if *c == ch] {}

		rule p2(ch1: char, ch2: char)
			= p_(ch1) p(ch2)

		rule ident() -> ast::Ident<'a>
			= [Token::Ident(name)] { ast::Ident { name } }

		rule delimited<T>(expr: rule<T>, delim: rule<()>) -> Vec<T>
			= values:(expr() ++ delim()) delim()? { values }
			/ { Vec::new() }

		rule tagged<T>(tag: rule<()>, value: rule<T>) -> T
			= tag() v:value() { v }
	}
}