use std::collections::HashMap;

use std::iter;

use quote::quote;

use syn::Error;

use syn::FnArg;

use syn::Ident;

use syn::ImplItem;

use syn::ImplItemFn;

use syn::ItemImpl;

use syn::LitBool;

use syn::Pat;

use syn::Path;

use syn::parse::Parse;

use syn::parse::ParseStream;

use syn::parse::Result;

use syn::parse_quote;

use syn::spanned::Spanned;

use syn::token;

mod kw {

    syn::custom_keyword!(shortcut);

    syn::custom_keyword!(rule);

    syn::custom_keyword!(parser);

}

/// Attributes for the parser macro

struct MakeParserAttrs {

    parser: Path,

    rule_enum: Path,

}

/// Arguments for an alias attribute

struct AliasArgs {

    target: Ident,

    is_shortcut: bool,

}

/// Source of an alias, including identifier and shortcut status.

struct AliasSrc {

    ident: Ident,      // Identifier

    is_shortcut: bool, // Whether it's a shortcut

}

/// Parsed function metadata including function body, name, input argument, and aliases.

struct ParsedFn<'a> {

    // Body of the function

    function: &'a mut ImplItemFn,

    // Name of the function.

    fn_name: Ident,

    // Name of the first argument of the function, which should be of type `Node`.

    input_arg: Ident,

    // List of aliases pointing to this function

    alias_srcs: Vec<AliasSrc>,

}

impl Parse for MakeParserAttrs {

        // By default, the pest parser is the same type as the pest_consume one

        // By default, use the `Rule` type in scope

            } else {

            }

            } else {

            }

        }

}

impl Parse for AliasArgs {

            // #[alias(rule, shortcut = true)]

        } else {

            // #[alias(rule)]

        };

}

/// Collects and maps aliases from an implementation block.

    }

/// Extracts an identifier from a function argument.

        },

    }

/// Parses a function to extract metadata for rule method processing.

    // Rule methods must have exactly one argument

    // Get the name of the first function argument

        "Function should have at least a self-reference in alias sources"

    );

/// Applies special attributes to parsed functions.

    // `alias` attr

    // f.alias_srcs has always at least 1 element because it has an entry pointing from itself.

    // Modify function block to handle shortcuts and aliases

        let mut #input_arg = #input_arg;

        // While the current rule allows shortcutting, and there is a single child, and the

        // child can still be parsed by the current function, then skip to that child.

        while #self_ty::allows_shortcut(#input_arg.as_rule()) {

            if let ::std::result::Result::Ok(child)

                    = #input_arg.children().single() {

                if child.as_aliased_rule::<Self>() == #self_ty::rule_alias(#rule_enum::#fn_name) {

                    #input_arg = child;

                    continue;

                }

            }

            break

        }

        match #input_arg.as_rule() {

            #(#rule_enum::#aliases => Self::#aliases(#input_arg),)*

            #rule_enum::#fn_name => #block,

            r => panic!(

                "merc_pest_consume::parser: called the `{}` method on a node with rule `{:?}`",

                stringify!(#fn_name),

                r

            )

        }

    });

        "Function must have at least one alias source (itself)"

    );

/// Main function for generating the parser implementation.

    // Collect aliases and build rule matching logic

                #rule_enum::#ident => Self::AliasedRule::#tgt,

            )

                #rule_enum::#ident => #is_shortcut,

            )

    // Process functions and apply attributes

                #[allow(non_snake_case)]

                #method

            );

    // Create functions for any remaining aliases

            // Get the signature of one of the functions that has this alias

                #sig {

                    match #input_arg.as_rule() {

                        #(#rule_enum::#srcs => Self::#srcs(#input_arg),)*

                        // We can't match on #rule_enum::#tgt since `tgt` might be an arbitrary

                        // identifier.

                        r if &format!("{:?}", r) == stringify!(#tgt) =>

                            return ::std::result::Result::Err(#input_arg.error(format!(

                                "merc_pest_consume::parser: missing method for rule {}",

                                stringify!(#tgt),

                            ))),

                        r => return ::std::result::Result::Err(#input_arg.error(format!(

                            "merc_pest_consume::parser: called method `{}` on a node with rule `{:?}`",

                            stringify!(#tgt),

                            r

                        ))),

                    }

                }

            ))

    // Generate the final implementation

        "Must have at least one aliased rule variant"

    );

        #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]

        #[allow(non_camel_case_types)]

        pub enum AliasedRule {

            #(#aliased_rule_variants,)*

        }

        impl #impl_generics ::merc_pest_consume::Parser for #ty #where_clause {

            type Rule = #rule_enum;

            type AliasedRule = AliasedRule;

            type Parser = #parser;

            fn rule_alias(rule: Self::Rule) -> Self::AliasedRule {

                match rule {

                    #(#rule_alias_branches)*

                    // TODO: return a proper error ?

                    r => panic!("Rule `{:?}` does not have a corresponding parsing method", r),

                }

            }

            fn allows_shortcut(rule: Self::Rule) -> bool {

                match rule {

                    #(#shortcut_branches)*

                    _ => false,

                }

            }

        }

        #imp

    ))