use std::rc::Rc;

use nom::{
    branch::alt,
    bytes::complete::{escaped_transform, tag, take_while},
    character::{
        complete::{alpha1, char, line_ending, none_of, not_line_ending, one_of, space1},
        is_alphanumeric,
    },
    combinator::{cut, eof, map, not, opt, peek, recognize, value, verify},
    error::{context, ErrorKind, ParseError, VerboseError},
    multi::{many0, many1, separated_list0, separated_list1},
    sequence::{delimited, pair, preceded, separated_pair, terminated, tuple},
    IResult, InputIter, InputLength, InputTake, Parser, Slice,
};
use nom_locate::{position, LocatedSpan};

use crate::{
    identifier::{Id, IdStore},
    parsing::StoreRef,
};

pub type Span<'a> = LocatedSpan<&'a str, StoreRef>;
pub type ParseResult<'a, O> = IResult<Span<'a>, O, VerboseError<Span<'a>>>;

use crate::ast::*;

fn rc_string(s: &str) -> Rc<String> {
    Rc::new(s.to_string())
}

fn is_keyword(input: &str) -> bool {
    let keywords = [
        "if",
        "then",
        "else",
        "is",
        "fn",
        "for",
        "while",
        "in",
        "true",
        "false",
        "let",
        "in",
        "mut",
        "return",
        "break",
        "continue",
        "type",
        "alias",
        "self",
        "Self",
        "interface",
        "impl",
        "module",
        "import",
    ];

    keywords.iter().any(|kw| kw == &input)
}

fn fresh_id(span: &Span) -> Id<ASTItem> {
    let mut table_handle = span.extra.borrow_mut();
    table_handle.fresh()
}

fn tok<'a, O>(
    input_parser: impl Parser<Span<'a>, O, VerboseError<Span<'a>>>,
) -> impl FnMut(Span<'a>) -> IResult<Span<'a>, O, VerboseError<Span<'a>>> {
    context("token", preceded(ws0, input_parser))
}

fn toknl<'a, O>(
    input_parser: impl Parser<Span<'a>, O, VerboseError<Span<'a>>>,
) -> impl FnMut(Span<'a>) -> IResult<Span<'a>, O, VerboseError<Span<'a>>> {
    context("token/newline", preceded(pair(many0(tok(statement_delimiter)), ws0), input_parser))
}

fn kw<'a>(keyword_str: &'static str) -> impl FnMut(Span<'a>) -> ParseResult<()> {
    context("keyword", tok(value((), tag(keyword_str))))
}

// whitespace does consume at least one piece of whitespace - use ws0 for maybe none
fn whitespace(input: Span) -> ParseResult<()> {
    context("whitespace", alt((preceded(peek(tag("/*")), block_comment), line_comment, value((), space1))))(
        input,
    )
}

fn ws0(input: Span) -> ParseResult<()> {
    context("WS0", value((), many0(whitespace)))(input)
}

fn line_comment(input: Span) -> ParseResult<()> {
    value((), tuple((tag("//"), not_line_ending)))(input)
}

fn block_comment(input: Span) -> ParseResult<()> {
    fn inner_parser(mut input: Span) -> ParseResult<()> {
        loop {
            let mut iter = input.iter_indices();
            while let Some((idx, _ch)) = iter.next() {
                if idx + 2 > input.input_len() {
                    return Err(nom::Err::Failure(VerboseError::from_error_kind(input, ErrorKind::Verify)));
                }
                if input.slice(idx..idx + 2).fragment() == &"/*" {
                    let (rest, _seen) = input.take_split(idx);

                    let (rest, ()) = block_comment(rest)?;
                    input = rest;
                    break;
                }

                if input.slice(idx..idx + 2).fragment() == &"*/" {
                    let (rest, _seen) = input.take_split(idx);
                    return Ok((rest, ()));
                }
            }
        }
    }

    context("block-comment", value((), tuple((tag("/*"), inner_parser, tag("*/")))))(input)
}

fn statement_delimiter(input: Span) -> ParseResult<()> {
    context("statement-delimiter", tok(alt((value((), line_ending), value((), char(';'))))))(input)
}

pub fn program(input: Span) -> ParseResult<AST> {
    let id = fresh_id(&input);
    let (rest, statements) = context(
        "AST",
        terminated(
            map(
                delimited(
                    many0(statement_delimiter),
                    separated_list0(many1(statement_delimiter), statement),
                    many0(statement_delimiter),
                ),
                |items| items.into(),
            ),
            tok(eof),
        ),
    )(input)?;

    let ast = AST { id, statements };
    Ok((rest, ast))
}

fn block_template<'a, O, O2>(
    delimiter: impl Parser<Span<'a>, O2, VerboseError<Span<'a>>>,
    input_parser: impl Parser<Span<'a>, O, VerboseError<Span<'a>>>,
) -> impl FnMut(Span<'a>) -> IResult<Span<'a>, Vec<O>, VerboseError<Span<'a>>> {
    delimited(
        pair(tok(char('{')), many0(statement_delimiter)),
        cut(separated_list0(delimiter, input_parser)),
        pair(many0(statement_delimiter), tok(char('}'))),
    )
}

pub fn block(input: Span) -> ParseResult<Block> {
    context("block", map(block_template(many1(statement_delimiter), statement), |items| items.into()))(input)
}

fn statement(input: Span) -> ParseResult<Statement> {
    let (input, pos) = position(input)?;
    let location = pos.location_offset().into();
    let id = fresh_id(&input);
    let (rest, kind) = context(
        "Parsing-statement",
        alt((
            map(flow, StatementKind::Flow),
            map(import, StatementKind::Import),
            map(declaration, StatementKind::Declaration),
            map(expression, StatementKind::Expression),
        )),
    )(input)?;
    Ok((rest, Statement { id, location, kind }))
}

fn import(input: Span) -> ParseResult<ImportSpecifier> {
    fn path_components(input: Span) -> ParseResult<Vec<Rc<String>>> {
        map(
            tuple((opt(tag("::")), identifier, many0(preceded(tag("::"), identifier_span)))),
            |(_maybe_root, first, rest)| {
                let mut components = vec![rc_string(first.fragment())];
                components.extend(rest.into_iter().map(|n| rc_string(n.fragment())));
                components
            },
        )(input)
    }

    fn import_suffix(input: Span) -> ParseResult<ImportedNames> {
        alt((
            value(ImportedNames::All, tag("::*")),
            map(
                preceded(
                    tag("::"),
                    delimited(char('{'), cut(separated_list1(tok(char(',')), identifier)), char('}')),
                ),
                |names| ImportedNames::List(names.into_iter().map(|n| rc_string(n.fragment())).collect()),
            ),
        ))(input)
    }

    let id = fresh_id(&input);
    map(
        preceded(kw("import"), cut(pair(path_components, opt(import_suffix)))),
        move |(path_components, suffix)| ImportSpecifier {
            id,
            path_components,
            imported_names: suffix.unwrap_or(ImportedNames::LastOfPath),
        },
    )(input)
}

fn flow(input: Span) -> ParseResult<FlowControl> {
    alt((
        map(kw("continue"), |_| FlowControl::Continue),
        map(kw("break"), |_| FlowControl::Break),
        map(preceded(kw("return"), opt(expression)), FlowControl::Return),
    ))(input)
}

fn declaration(input: Span) -> ParseResult<Declaration> {
    alt((binding, type_decl, func, annotation, module, interface, implementation))(input)
}

fn implementation(input: Span) -> ParseResult<Declaration> {
    alt((
        map(
            preceded(kw("impl"), tuple((type_singleton_name, kw("for"), type_identifier, decl_block))),
            |(if_name, _, type_name, block)| Declaration::Impl {
                type_name,
                interface_name: Some(if_name),
                block,
            },
        ),
        map(preceded(kw("impl"), pair(type_identifier, decl_block)), |(type_name, block)| {
            Declaration::Impl { type_name, interface_name: None, block }
        }),
    ))(input)
}

fn decl_block(input: Span) -> ParseResult<Vec<Declaration>> {
    block_template(many1(statement_delimiter), func_decl)(input)
}

fn interface(input: Span) -> ParseResult<Declaration> {
    map(preceded(kw("interface"), pair(identifier, signature_block)), |(name, signatures)| {
        Declaration::Interface { name: rc_string(name.fragment()), signatures }
    })(input)
}

fn signature_block(input: Span) -> ParseResult<Vec<Signature>> {
    block_template(many1(statement_delimiter), func_signature)(input)
}

fn annotation(input: Span) -> ParseResult<Declaration> {
    map(
        tuple((
            tok(char('@')),
            identifier,
            opt(delimited(tok(char('(')), separated_list1(tok(char(',')), expression), tok(char(')')))),
            statement_delimiter,
            statement,
        )),
        |(_, name, args, _, inner)| Declaration::Annotation {
            name: rc_string(name.fragment()),
            arguments: if let Some(args) = args { args } else { vec![] },
            inner: Box::new(inner),
        },
    )(input)
}

fn func(input: Span) -> ParseResult<Declaration> {
    alt((func_decl, map(func_signature, Declaration::FuncSig)))(input)
}

fn func_decl(input: Span) -> ParseResult<Declaration> {
    map(pair(func_signature, block), |(sig, decl)| Declaration::FuncDecl(sig, decl))(input)
}

fn func_signature(input: Span) -> ParseResult<Signature> {
    let normal_fn = context("ordinary-fn", tuple((identifier, formal_params, opt(type_anno))));
    let operator_fn = context(
        "operator-fn",
        tuple((delimited(tok(char('(')), operator, tok(char(')'))), formal_params, opt(type_anno))),
    );

    context(
        "func-signature",
        preceded(
            kw("fn"),
            cut(alt((
                map(normal_fn, |(name, params, type_anno)| Signature {
                    name: rc_string(name.fragment()),
                    operator: false,
                    params,
                    type_anno,
                }),
                map(operator_fn, |(op, params, type_anno)| Signature {
                    name: rc_string(op.sigil()),
                    operator: true,
                    params,
                    type_anno,
                }),
            ))),
        ),
    )(input)
}

fn formal_params(input: Span) -> ParseResult<Vec<FormalParam>> {
    context(
        "formal-params",
        verify(
            delimited(tok(char('(')), separated_list0(tok(char(',')), formal_param), tok(char(')'))),
            |params: &Vec<_>| params.len() < 256,
        ),
    )(input)
}

fn formal_param(input: Span) -> ParseResult<FormalParam> {
    map(
        tuple((identifier, opt(type_anno), opt(preceded(tok(char('=')), expression)))),
        |(name, anno, default)| FormalParam { name: rc_string(name.fragment()), anno, default },
    )(input)
}

fn type_decl(input: Span) -> ParseResult<Declaration> {
    context(
        "type-decl",
        alt((
            map(
                tuple((kw("type"), kw("alias"), identifier, tok(char('=')), identifier)),
                |(_, _, alias, _, name)| Declaration::TypeAlias {
                    alias: rc_string(alias.fragment()),
                    original: rc_string(name.fragment()),
                },
            ),
            map(
                tuple((kw("type"), opt(kw("mut")), type_singleton_name, tok(char('=')), type_body)),
                |(_, mutable, name, _, body)| Declaration::TypeDecl {
                    name,
                    body,
                    mutable: mutable.is_some(),
                },
            ),
        )),
    )(input)
}

fn type_body(input: Span) -> ParseResult<TypeBody> {
    let id = fresh_id(&input);
    context(
        "type-body",
        alt((
            map(record_variant, move |fields| TypeBody::ImmediateRecord { id, fields }),
            map(separated_list0(tok(char('|')), variant_spec), TypeBody::Variants),
        )),
    )(input)
}

fn record_variant(input: Span) -> ParseResult<Vec<(Rc<String>, TypeIdentifier)>> {
    context(
        "record-variant",
        delimited(
            pair(tok(char('{')), many0(statement_delimiter)),
            terminated(separated_list1(toknl(char(',')), toknl(record_variant_item)), opt(toknl(char(',')))),
            pair(many0(statement_delimiter), tok(char('}'))),
        ),
    )(input)
}

fn variant_spec(input: Span) -> ParseResult<Variant> {
    fn tuple_variant(input: Span) -> ParseResult<VariantKind> {
        map(
            delimited(tok(char('(')), separated_list1(tok(char(',')), type_identifier), tok(char(')'))),
            VariantKind::TupleStruct,
        )(input)
    }

    let id = fresh_id(&input);
    let (rest, (name, kind)) = alt((
        pair(identifier, map(record_variant, VariantKind::Record)),
        pair(identifier, tuple_variant),
        map(identifier, |ident| (ident, VariantKind::UnitStruct)),
    ))(input)?;

    Ok((rest, Variant { id, name: rc_string(name.fragment()), kind }))
}

fn record_variant_item(input: Span) -> ParseResult<(Rc<String>, TypeIdentifier)> {
    context(
        "record-variant-item",
        map(tuple((identifier, tok(char(':')), type_identifier)), |(name, _, ty)| {
            (rc_string(name.fragment()), ty)
        }),
    )(input)
}

fn binding(input: Span) -> ParseResult<Declaration> {
    let parser = tuple((kw("let"), opt(kw("mut")), identifier, opt(type_anno), tok(char('=')), expression));
    map(parser, |(_, maybe_mut, ident, type_anno, _, expr)| Declaration::Binding {
        name: rc_string(ident.fragment()),
        constant: maybe_mut.is_none(),
        type_anno,
        expr,
    })(input)
}

fn module(input: Span) -> ParseResult<Declaration> {
    map(tuple((kw("module"), identifier, block)), |(_, name, items)| Declaration::Module {
        name: rc_string(name.fragment()),
        items,
    })(input)
}

pub fn expression(input: Span) -> ParseResult<Expression> {
    let id = fresh_id(&input);
    map(pair(expression_kind(true), opt(type_anno)), move |(kind, type_anno)| Expression {
        id,
        type_anno,
        kind,
    })(input)
}

fn expression_no_struct(input: Span) -> ParseResult<Expression> {
    let id = fresh_id(&input);
    map(pair(expression_kind(false), opt(type_anno)), move |(kind, type_anno)| Expression {
        id,
        type_anno,
        kind,
    })(input)
}

fn expr_or_block(input: Span) -> ParseResult<Block> {
    let (input, pos) = position(input)?;
    let id = fresh_id(&input);
    let location = pos.location_offset().into();
    alt((
        block,
        map(expression, move |expr| Statement { id, location, kind: StatementKind::Expression(expr) }.into()),
    ))(input)
}

fn type_anno(input: Span) -> ParseResult<TypeIdentifier> {
    preceded(tok(char(':')), type_identifier)(input)
}

fn type_identifier(input: Span) -> ParseResult<TypeIdentifier> {
    alt((
        map(
            delimited(tok(char('(')), separated_list0(tok(char(',')), type_identifier), tok(char(')'))),
            TypeIdentifier::Tuple,
        ),
        map(type_singleton_name, TypeIdentifier::Singleton),
    ))(input)
}

fn type_singleton_name(input: Span) -> ParseResult<TypeSingletonName> {
    map(pair(identifier, opt(type_params)), |(name, params)| TypeSingletonName {
        name: rc_string(name.fragment()),
        params: if let Some(params) = params { params } else { vec![] },
    })(input)
}

fn type_params(input: Span) -> ParseResult<Vec<TypeIdentifier>> {
    delimited(tok(char('<')), separated_list1(tok(char(',')), type_identifier), tok(char('>')))(input)
}

pub fn expression_kind(allow_struct: bool) -> impl FnMut(Span) -> ParseResult<ExpressionKind> {
    move |input: Span| context("expression-kind", precedence_expr(allow_struct))(input)
}

fn precedence_expr(allow_struct: bool) -> impl FnMut(Span) -> ParseResult<ExpressionKind> {
    move |input: Span| {
        let handle = input.extra.clone();
        let precedence_continuation = pair(operator, prefix_expr(allow_struct));
        map(
            pair(prefix_expr(allow_struct), many0(precedence_continuation)),
            move |(first, rest): (ExpressionKind, Vec<(BinOp, ExpressionKind)>)| {
                let mut handle_ref = handle.borrow_mut();
                BinopSequence { first, rest }.do_precedence(&mut handle_ref)
            },
        )(input)
    }
}

fn operator(input: Span) -> ParseResult<BinOp> {
    context(
        "operator",
        tok(map(
            preceded(cut(not(tag("*/"))), recognize(many1(one_of("+-*/%<>=!$&|?^`")))),
            |sigil_span: Span| BinOp::from_sigil(sigil_span.fragment()),
        )),
    )(input)
}

fn prefix_op(input: Span) -> ParseResult<PrefixOp> {
    tok(map(recognize(one_of("+-!")), |sigil: Span| PrefixOp::from_sigil(sigil.fragment())))(input)
}

fn prefix_expr(allow_struct: bool) -> impl FnMut(Span) -> ParseResult<ExpressionKind> {
    move |input: Span| {
        let id = fresh_id(&input);
        context(
            "prefix-expr",
            map(pair(opt(prefix_op), extended_expr(allow_struct)), move |(prefix, expr)| {
                if let Some(prefix) = prefix {
                    let expr = Expression::new(id, expr);
                    ExpressionKind::PrefixExp(prefix, Box::new(expr))
                } else {
                    expr
                }
            }),
        )(input)
    }
}

#[derive(Debug)]
enum ExtendedPart<'a> {
    Index(Vec<Expression>),
    Call(Vec<InvocationArgument>),
    Accessor(&'a str),
}

fn extended_expr(allow_struct: bool) -> impl FnMut(Span) -> ParseResult<ExpressionKind> {
    move |input: Span| {
        let (s, (primary, parts)) =
            context("extended-expr", pair(primary_expr(allow_struct), many0(extended_expr_part)))(input)?;

        let mut expression = Expression::new(fresh_id(&s), primary);
        for part in parts.into_iter() {
            let kind = match part {
                ExtendedPart::Index(indexers) =>
                    ExpressionKind::Index { indexee: Box::new(expression), indexers },
                ExtendedPart::Call(arguments) => ExpressionKind::Call { f: Box::new(expression), arguments },
                ExtendedPart::Accessor(name) => {
                    let name = rc_string(name);
                    ExpressionKind::Access { name, expr: Box::new(expression) }
                }
            };
            expression = Expression::new(fresh_id(&s), kind);
        }

        Ok((s, expression.kind))
    }
}

fn extended_expr_part(input: Span) -> ParseResult<ExtendedPart> {
    fn index_part(input: Span) -> ParseResult<Vec<Expression>> {
        delimited(tok(char('[')), cut(separated_list1(tok(char(',')), expression)), tok(char(']')))(input)
    }

    fn call_part(input: Span) -> ParseResult<Vec<InvocationArgument>> {
        context(
            "call-part",
            verify(
                //TODO generalize this `not`
                delimited(
                    tok(char('(')),
                    separated_list0(tok(char(',')), preceded(not(tok(char(')'))), invocation_argument)),
                    tok(char(')')),
                ),
                |output: &Vec<_>| output.len() <= 255,
            ),
        )(input)
    }

    fn access_part(input: Span) -> ParseResult<&str> {
        preceded(tok(char('.')), map(identifier, |item| *item.fragment()))(input)
    }

    alt((
        map(index_part, ExtendedPart::Index),
        map(call_part, ExtendedPart::Call),
        map(access_part, ExtendedPart::Accessor),
    ))(input)
}

fn invocation_argument(input: Span) -> ParseResult<InvocationArgument> {
    context(
        "invocation-argument",
        cut(alt((
            map(tok(char('_')), |_| InvocationArgument::Ignored),
            map(tuple((identifier, tok(char('=')), expression)), |(name, _, expr)| {
                InvocationArgument::Keyword { name: rc_string(name.fragment()), expr }
            }),
            map(expression, InvocationArgument::Positional),
        ))),
    )(input)
}

fn primary_expr(allow_struct: bool) -> impl FnMut(Span) -> ParseResult<ExpressionKind> {
    move |input: Span| {
        if allow_struct {
            context("primary-expr", alt((primary_expr_no_struct, named_struct, identifier_expr)))(input)
        } else {
            context("primary-expr", alt((primary_expr_no_struct, identifier_expr)))(input)
        }
    }
}

fn primary_expr_no_struct(input: Span) -> ParseResult<ExpressionKind> {
    context(
        "primary-expr-no-struct",
        alt((
            while_expr,
            for_expr,
            if_expr,
            lambda_expr,
            list_expr,
            paren_expr,
            bool_literal,
            float_literal,
            number_literal,
            string_literal,
        )),
    )(input)
}

fn named_struct(input: Span) -> ParseResult<ExpressionKind> {
    context(
        "named-struct",
        map(pair(qualified_identifier, record_block), |(name, fields)| ExpressionKind::NamedStruct {
            name,
            fields,
        }),
    )(input)
}

//TODO support anonymous structs and Elm-style update syntax for structs
fn record_block(input: Span) -> ParseResult<Vec<(Rc<String>, Expression)>> {
    let record_entry =
        separated_pair(map(identifier, |span| rc_string(span.fragment())), tok(char(':')), expression);

    delimited(tok(char('{')), separated_list0(tok(char(',')), record_entry), tok(char('}')))(input)
}

fn lambda_expr(input: Span) -> ParseResult<ExpressionKind> {
    context(
        "lambda-expr",
        preceded(
            tok(char('\\')),
            alt((
                map(tuple((formal_params, opt(type_anno), block)), |(params, type_anno, body)| {
                    ExpressionKind::Lambda { params, type_anno, body }
                }),
                map(tuple((formal_param, opt(type_anno), block)), |(param, type_anno, body)| {
                    ExpressionKind::Lambda { params: vec![param], type_anno, body }
                }),
            )),
        ),
    )(input)
}

fn while_expr(input: Span) -> ParseResult<ExpressionKind> {
    context(
        "while-expr",
        map(preceded(kw("while"), pair(opt(expression_no_struct), block)), move |(condition, body)| {
            ExpressionKind::WhileExpression { condition: condition.map(Box::new), body }
        }),
    )(input)
}

fn if_expr(input: Span) -> ParseResult<ExpressionKind> {
    fn else_case(input: Span) -> ParseResult<Option<Block>> {
        opt(preceded(kw("else"), expr_or_block))(input)
    }

    fn cond_block(input: Span) -> ParseResult<IfExpressionBody> {
        map(block_template(many1(statement_delimiter), cond_arm), IfExpressionBody::CondList)(input)
    }

    fn cond_arm(input: Span) -> ParseResult<ConditionArm> {
        let condition = map(preceded(kw("is"), pattern), Condition::Pattern);
        let condition_guard = opt(preceded(kw("if"), expression));
        alt((
            map(preceded(kw("else"), expr_or_block), |body| ConditionArm {
                condition: Condition::Else,
                guard: None,
                body,
            }),
            map(
                tuple((condition, condition_guard, kw("then"), expr_or_block)),
                |(condition, guard, _, body)| ConditionArm { condition, guard, body },
            ),
        ))(input)
    }

    fn simple_pattern_match(input: Span) -> ParseResult<IfExpressionBody> {
        map(
            tuple((preceded(kw("is"), pattern), preceded(kw("then"), pair(expr_or_block, else_case)))),
            |(pattern, (then_case, else_case))| IfExpressionBody::SimplePatternMatch {
                pattern,
                then_case,
                else_case,
            },
        )(input)
    }

    fn simple_conditional(input: Span) -> ParseResult<IfExpressionBody> {
        map(preceded(kw("then"), pair(expr_or_block, else_case)), |(then_case, else_case)| {
            IfExpressionBody::SimpleConditional { then_case, else_case }
        })(input)
    }

    fn if_expr_body(input: Span) -> ParseResult<IfExpressionBody> {
        alt((cond_block, simple_pattern_match, simple_conditional))(input)
    }

    context(
        "if-expr",
        map(preceded(kw("if"), pair(opt(expression_no_struct), if_expr_body)), |(discriminator, body)| {
            ExpressionKind::IfExpression { discriminator: discriminator.map(Box::new), body: Box::new(body) }
        }),
    )(input)
}

fn pattern(input: Span) -> ParseResult<Pattern> {
    alt((
        map(
            delimited(tok(char('(')), separated_list1(tok(char(',')), pattern), tok(char(')'))),
            Pattern::TuplePattern,
        ),
        simple_pattern,
    ))(input)
}

fn simple_pattern(input: Span) -> ParseResult<Pattern> {
    fn record_pattern_entry(input: Span) -> ParseResult<(Rc<String>, Pattern)> {
        let id = fresh_id(&input);
        alt((
            map(separated_pair(identifier, tok(char(':')), pattern), |(ident, pat)| {
                (rc_string(ident.fragment()), pat)
            }),
            map(identifier, move |ident| {
                let qn = QualifiedName { id, components: vec![rc_string(ident.fragment())] };
                (rc_string(ident.fragment()), Pattern::VarOrName(qn))
            }),
        ))(input)
    }

    alt((
        pattern_literal,
        map(
            pair(
                qualified_identifier,
                delimited(tok(char('(')), separated_list0(tok(char(',')), pattern), tok(char(')'))),
            ),
            |(qn, members)| Pattern::TupleStruct(qn, members),
        ),
        map(
            pair(
                qualified_identifier,
                delimited(
                    tok(char('{')),
                    separated_list0(tok(char(',')), record_pattern_entry),
                    tok(char('}')),
                ),
            ),
            |(qn, members)| Pattern::Record(qn, members),
        ),
        map(qualified_identifier, Pattern::VarOrName),
    ))(input)
}

fn pattern_literal(input: Span) -> ParseResult<Pattern> {
    alt((
        value(Pattern::Ignored, kw("_")),
        value(Pattern::Literal(PatternLiteral::BoolPattern(true)), kw("true")),
        value(Pattern::Literal(PatternLiteral::BoolPattern(false)), kw("false")),
        map(tok(bare_string_literal), |s| Pattern::Literal(PatternLiteral::StringPattern(Rc::new(s)))),
        map(pair(opt(tok(char('-'))), alt((float_literal, number_literal))), |(sign, num)| {
            Pattern::Literal(PatternLiteral::NumPattern { neg: sign.is_some(), num })
        }),
    ))(input)
}

fn for_expr(input: Span) -> ParseResult<ExpressionKind> {
    fn for_enumerators(input: Span) -> ParseResult<Vec<Enumerator>> {
        alt((
            delimited(tok(char('{')), separated_list0(tok(char(',')), enumerator), tok(char('}'))),
            map(enumerator, |enumerator| vec![enumerator]),
        ))(input)
    }

    //TODO add guards, etc.
    fn enumerator(input: Span) -> ParseResult<Enumerator> {
        alt((
            map(separated_pair(identifier, kw("<-"), expression_no_struct), |(ident, generator)| {
                Enumerator { identifier: rc_string(ident.fragment()), generator, assignment: false }
            }),
            //TODO distinguish these two cases in AST
            map(separated_pair(identifier, kw("="), expression_no_struct), |(ident, generator)| Enumerator {
                identifier: rc_string(ident.fragment()),
                generator,
                assignment: true,
            }),
        ))(input)
    }

    fn for_body(input: Span) -> ParseResult<Box<ForBody>> {
        alt((
            preceded(kw("return"), map(expression_no_struct, |expr| Box::new(ForBody::MonadicReturn(expr)))),
            map(block, |body| Box::new(ForBody::StatementBlock(body))),
        ))(input)
    }

    context(
        "for-expr",
        map(preceded(kw("for"), pair(for_enumerators, for_body)), |(enumerators, body)| {
            ExpressionKind::ForExpression { enumerators, body }
        }),
    )(input)
}

fn paren_expr(input: Span) -> ParseResult<ExpressionKind> {
    delimited(
        tok(char('(')),
        map(separated_list0(tok(char(',')), expression), |mut exprs| match exprs.len() {
            1 => exprs.pop().unwrap().kind,
            _ => ExpressionKind::TupleLiteral(exprs),
        }),
        tok(char(')')),
    )(input)
}

fn list_expr(input: Span) -> ParseResult<ExpressionKind> {
    map(delimited(tok(char('[')), separated_list0(tok(char(',')), expression), tok(char(']'))), |items| {
        ExpressionKind::ListLiteral(items)
    })(input)
}

fn string_literal(input: Span) -> ParseResult<ExpressionKind> {
    context(
        "string-literal",
        tok(map(pair(opt(identifier), bare_string_literal), |(prefix, s)| ExpressionKind::StringLiteral {
            s: Rc::new(s),
            prefix: prefix.map(|s| rc_string(s.fragment())),
        })),
    )(input)
}

fn bare_string_literal(input: Span) -> ParseResult<String> {
    let string_escape_transforms = alt((
        value('\\', tag("\\")),
        value('"', tag("\"")),
        value('\n', tag("n")),
        value('\t', tag("t")),
        map(delimited(tag(r#"u{"#), recognize(digit_group_hex), tag("}")), |value| {
            char::from_u32(u32::from_str_radix(value.fragment(), 16).unwrap()).unwrap()
        }),
    ));
    alt((
        map(tag(r#""""#), |_| String::new()),
        preceded(
            peek(char('"')),
            cut(delimited(
                char('"'),
                escaped_transform(none_of(r#""\"#), '\\', string_escape_transforms),
                char('"'),
            )),
        ),
    ))(input)
}

fn identifier_expr(input: Span) -> ParseResult<ExpressionKind> {
    context("identifier-expr", map(qualified_identifier, ExpressionKind::Value))(input)
}

fn qualified_identifier(input: Span) -> ParseResult<QualifiedName> {
    let id = fresh_id(&input);
    tok(map(separated_list1(tag("::"), map(identifier_span, |x| rc_string(x.fragment()))), move |items| {
        QualifiedName { id, components: items }
    }))(input)
}

fn identifier(input: Span) -> ParseResult<Span> {
    context("identifier", tok(identifier_span))(input)
}

fn identifier_span(input: Span) -> ParseResult<Span> {
    let (rest, parsed) = recognize(tuple((
        alt((tag("_"), alpha1)),
        take_while(|ch: char| is_alphanumeric(ch as u8) || ch == '_'),
    )))(input.clone())?;

    if is_keyword(parsed.fragment()) {
        return Err(nom::Err::Failure(VerboseError::from_error_kind(input, nom::error::ErrorKind::Verify)));
    }

    Ok((rest, parsed))
}

fn bool_literal(input: Span) -> ParseResult<ExpressionKind> {
    context(
        "bool-literal",
        alt((
            map(kw("true"), |_| ExpressionKind::BoolLiteral(true)),
            map(kw("false"), |_| ExpressionKind::BoolLiteral(false)),
        )),
    )(input)
}

fn float_literal(input: Span) -> ParseResult<ExpressionKind> {
    context(
        "float-literal",
        tok(map(
            alt((
                recognize(tuple((digits(digit_group_dec), char('.'), opt(digits(digit_group_dec))))),
                recognize(tuple((char('.'), digits(digit_group_dec)))),
            )),
            |ds| ExpressionKind::FloatLiteral(ds.fragment().parse().unwrap()),
        )),
    )(input)
}

fn number_literal(input: Span) -> ParseResult<ExpressionKind> {
    context(
        "number-literal",
        map(alt((tok(hex_literal), tok(bin_literal), tok(dec_literal))), ExpressionKind::NatLiteral),
    )(input)
}

fn dec_literal(input: Span) -> ParseResult<u64> {
    map(digits(digit_group_dec), |chars: Vec<char>| {
        let s: String = chars.into_iter().collect();
        s.parse().unwrap()
    })(input)
}

fn hex_literal(input: Span) -> ParseResult<u64> {
    map(preceded(alt((tag("0x"), tag("0X"))), digits(digit_group_hex)), |chars: Vec<char>| {
        let s: String = chars.into_iter().collect();
        parse_hex(&s).unwrap()
    })(input)
}

fn bin_literal(input: Span) -> ParseResult<u64> {
    map(preceded(alt((tag("0b"), tag("0B"))), digits(digit_group_bin)), |chars: Vec<char>| {
        let s: String = chars.into_iter().collect();
        parse_binary(&s).unwrap()
    })(input)
}

fn digits<'a, E: ParseError<Span<'a>>>(
    digit_type: impl Parser<Span<'a>, Vec<char>, E>,
) -> impl FnMut(Span<'a>) -> IResult<Span<'a>, Vec<char>, E> {
    map(separated_list1(many1(char('_')), digit_type), |items: Vec<Vec<char>>| {
        items.into_iter().flatten().collect()
    })
}

fn digit_group_dec(input: Span) -> ParseResult<Vec<char>> {
    many1(one_of("0123456789"))(input)
}

fn digit_group_hex(input: Span) -> ParseResult<Vec<char>> {
    many1(one_of("0123456789abcdefABCDEF"))(input)
}

fn digit_group_bin(input: Span) -> ParseResult<Vec<char>> {
    many1(one_of("01"))(input)
}

fn parse_binary(digits: &str) -> Result<u64, &'static str> {
    let mut result: u64 = 0;
    let mut multiplier = 1;
    for d in digits.chars().rev() {
        match d {
            '1' => result += multiplier,
            '0' => (),
            '_' => continue,
            _ => unreachable!(),
        }
        multiplier = match multiplier.checked_mul(2) {
            Some(m) => m,
            None => return Err("Binary expression will overflow"),
        }
    }
    Ok(result)
}

fn parse_hex(digits: &str) -> Result<u64, &'static str> {
    let mut result: u64 = 0;
    let mut multiplier: u64 = 1;
    for d in digits.chars().rev() {
        if d == '_' {
            continue;
        }
        match d.to_digit(16) {
            Some(n) => result += n as u64 * multiplier,
            None => return Err("Internal parser error: invalid hex digit"),
        }
        multiplier = match multiplier.checked_mul(16) {
            Some(m) => m,
            None => return Err("Hexadecimal expression will overflow"),
        }
    }
    Ok(result)
}

#[derive(Debug)]
struct BinopSequence {
    first: ExpressionKind,
    rest: Vec<(BinOp, ExpressionKind)>,
}

impl BinopSequence {
    fn do_precedence(self, store: &mut IdStore<ASTItem>) -> ExpressionKind {
        fn helper(
            precedence: i32,
            lhs: ExpressionKind,
            rest: &mut Vec<(BinOp, ExpressionKind)>,
            store: &mut IdStore<ASTItem>,
        ) -> Expression {
            let mut lhs = Expression::new(store.fresh(), lhs);
            while let Some((next_op, next_rhs)) = rest.pop() {
                let new_precedence = next_op.get_precedence();
                if precedence >= new_precedence {
                    rest.push((next_op, next_rhs));
                    break;
                }
                let rhs = helper(new_precedence, next_rhs, rest, store);
                lhs = Expression::new(
                    store.fresh(),
                    ExpressionKind::BinExp(next_op, Box::new(lhs), Box::new(rhs)),
                );
            }
            lhs
        }
        let mut as_stack = self.rest.into_iter().rev().collect();
        helper(BinOp::min_precedence(), self.first, &mut as_stack, store).kind
    }
}

#[cfg(test)]
mod test {
    use std::cell::RefCell;

    use pretty_assertions::assert_eq;

    use super::*;

    macro_rules! span {
        ($func:expr, $input:expr) => {{
            let id_store: IdStore<ASTItem> = IdStore::new();
            let span = Span::new_extra($input, Rc::new(RefCell::new(id_store)));
            $func(span).map(|(span, x)| (*span.fragment(), x))
        }};
    }

    #[test]
    fn combinator_test1() {
        assert_eq!(span!(digits(digit_group_dec), "342"), Ok(("", vec!['3', '4', '2'])));
        assert_eq!(span!(bin_literal, "0b1111qsdf"), Ok(("qsdf", 15)));
        assert_eq!(span!(bare_string_literal, r#""fah""#), Ok(("", "fah".to_string())));
        assert_eq!(span!(bare_string_literal, r#""""#), Ok(("", "".to_string())));
        assert_eq!(*span!(identifier_span, "modulek").unwrap().1.fragment(), "modulek");
        assert!(span!(identifier_span, "module").is_err());
    }

    #[test]
    fn combinator_test_ws0() {
        assert_eq!(span!(block_comment, "/*yolo*/ "), Ok((" ", ())));
        assert_eq!(span!(block_comment, "/*yolo*/ jumpy /*nah*/ "), Ok((" jumpy /*nah*/ ", ())));
        assert_eq!(span!(ws0, " /*    yolo  */"), Ok(("", ())));
        assert_eq!(span!(ws0, "/*  /* no */   yolo  */ "), Ok(("", ())));
    }

    #[test]
    fn combinator_test2() {
        for s in ["  15", "   0b1111", "   1_5_", "0XF__", "0Xf"].iter() {
            assert_eq!(span!(expression_kind(true), s).unwrap().1, ExpressionKind::NatLiteral(15));
        }

        assert_eq!(
            span!(expression_kind(true), " /*gay*/  true").unwrap().1,
            ExpressionKind::BoolLiteral(true)
        );
    }
}