extern crate proc_macro;
extern crate proc_macro2;
extern crate syn;
#[macro_use] extern crate quote;

use proc_macro::TokenStream;
use syn::punctuated::Punctuated;
use std::fmt;
use std::io::Write;
use syn::spanned::Spanned;

fn _rustfmt<C: fmt::Display>(code: C) -> String{
    // rustfmt_core::format_code_block(code, rustfmt_core::Config::default()).unwrap()
    let code = format!("{}", code);
    let mut child = ::std::process::Command::new("rustfmt")
        .stdin(::std::process::Stdio::piped())
        .stdout(::std::process::Stdio::piped())
        .spawn()
        .expect("Failed to format source snippet");
    {
        let stdin = child.stdin.as_mut().expect("Failed to open stdin");
        stdin.write_all(code.as_bytes()).expect("Failed to write to stdin");
    }
    let out = child.wait_with_output().expect("Failed to format source snippet").stdout;
    String::from_utf8_lossy(&out).to_string()
}

#[proc_macro_derive(ParamsDefault, attributes(param))]
pub fn parameter_group(input: TokenStream) -> TokenStream {
    let parameter_group = syn::parse_macro_input!(input as ParamsDefault);
    parameter_group.impl_default().into()
}


struct DefaultValue{
    value: syn::Expr,
}

impl syn::parse::Parse for DefaultValue{
    fn parse(input: syn::parse::ParseStream) -> syn::Result<DefaultValue>{
        Ok(DefaultValue{
            value: input.parse()?
        })
    }
}

struct Range{
    range: syn::Expr
}

impl syn::parse::Parse for Range {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Range> {
        Ok(Range{
            range: input.parse()?,
        })
    }
}

struct With{
    with: syn::Expr,
}

impl syn::parse::Parse for With{
    fn parse(input: syn::parse::ParseStream) -> syn::Result<With> {
        let with = input.parse().map_err(|err| syn::Error::new(
                        err.span(),
                        "With value should be an expression or string literal"))?;
        let with = if let syn::Expr::Lit(with) = with{
            if let syn::Lit::Str(with) = with.lit {
                syn::parse_str(&with.value())?
            }else{
                return Err(syn::Error::new(
                    input.span(),
            "With value should be an expression or string literal"));
            }
        }else{
            with
        };
        Ok(With{
            with
        })
    }
}

enum ParameterAttributeTts{
    DefaultValue(DefaultValue),
    Range(Range),
    LogRange(Range),
    With(With),
}

impl syn::parse::Parse for ParameterAttributeTts{
    fn parse(input: syn::parse::ParseStream) -> syn::Result<ParameterAttributeTts>{
        let path: syn::Path = input.parse()?;
        if path.is_ident("default"){
            let _eq_token: syn::Token![=] = input.parse()?;
            let default_value: DefaultValue = input.parse()?;
            Ok(ParameterAttributeTts::DefaultValue(default_value))
        }else if path.is_ident("range"){
            let _eq_token: syn::Token![=] = input.parse()?;
            let expr: syn::Expr = input.parse()?;
            let range = if let syn::Expr::Lit(lit) = &expr{
                if let syn::Lit::Str(lit) = &lit.lit {
                    syn::parse_str(&lit.value())
                        .map_err(|err| syn::Error::new(err.span(), "Parsing field attribute range literal"))?
                }else{
                    return Err(syn::Error::new(input.span(), "Range has to be an expresion or string literal"))
                }
            }else{
                Range{ range: expr }
            };
            Ok(ParameterAttributeTts::Range(range))
        }else if path.is_ident("range_log"){
            let _eq_token: syn::Token![=] = input.parse()?;
            let expr: syn::Expr = input.parse()?;
            let range = if let syn::Expr::Lit(lit) = &expr{
                if let syn::Lit::Str(lit) = &lit.lit {
                    syn::parse_str(&lit.value())
                        .map_err(|err| syn::Error::new(err.span(), "Parsing field attribute range literal"))?
                }else{
                    return Err(syn::Error::new(input.span(), "Range has to be an expresion or string literal"))
                }
            }else{
                Range{ range: expr }
            };
            Ok(ParameterAttributeTts::LogRange(range))
        }else if path.is_ident("with"){
            let _eq_token: syn::Token![=] = input.parse()?;
            let with = input.parse()?;
            Ok(ParameterAttributeTts::With(with))
        }else{
            Err(syn::Error::new(
                path.span(),
                &format!(
                    "Error parsing param attribute {} which is not supported, supported attributes: \"default\", \"range\", \"range_log\" and \"with\"",
                    path.segments[0].ident,
                )
            ))
        }
    }
}

struct GuiAttribute{
    pub pound_token: syn::token::Pound,
    pub bracket_token: syn::token::Bracket,
    pub gui_path: syn::Path,
    pub paren: Option<syn::token::Paren>,
    pub attributes: Punctuated<ParameterAttributeTts, syn::Token![,]>,
}

// impl syn::parse::Parse for GuiAttribute{
//     fn parse(input: syn::parse::ParseStream) -> syn::Result<GuiAttribute>{
//         let content;
//         let pound_token = input.parse()?;
//         let bracket_token = syn::bracketed!(content in input);
//         let gui_path: syn::Path = content.parse()?;
//         let paren;
//         let attributes;
//         if gui_path.is_ident("param"){
//             let attr_content;
//             paren = Some(syn::parenthesized!(attr_content in content));
//             attributes = attr_content.parse_terminated(ParameterAttributeTts::parse)?;
//         }else{
//             content.cursor().token_stream();
//             paren = None;
//             attributes = Punctuated::new();
//         }
//         Ok(GuiAttribute{
//             pound_token,
//             bracket_token,
//             gui_path,
//             paren,
//             attributes,
//         })
//     }
// }

struct Parameter{
    attrs: Vec<GuiAttribute>,
    vis: syn::Visibility,
    ident: syn::Ident,
    colon_token: syn::Token![:],
    ty: syn::Type
}

impl Parameter{
    fn parameter_default(&self) -> syn::Result<proc_macro2::TokenStream> {
        let mut default_values = self.attrs.iter().flat_map(|attrs| attrs.attributes.iter())
            .filter_map(|attr| if let ParameterAttributeTts::DefaultValue(default) = attr{
                Some(default)
            }else{
                None
            });
        let default_value = default_values.next();
        if let Some(default_value) = default_values.next() {
            return Err(syn::Error::new(
                self.ident.span(),
                "Parameter has more than one default value attribute"))
        }

        let mut ranges = self.attrs.iter().flat_map(|attrs| attrs.attributes.iter())
            .filter_map(|attr| if let ParameterAttributeTts::Range(range) = attr{
                Some(range)
            }else{
                None
            });
        let range = ranges.next();
        if let Some(range) = ranges.next() {
            return Err(syn::Error::new(
                self.ident.span(),
                "Parameter has more than one range attribute"))
        }

        let mut ranges_log = self.attrs.iter().flat_map(|attrs| attrs.attributes.iter())
            .filter_map(|attr| if let ParameterAttributeTts::LogRange(range) = attr{
                Some(range)
            }else{
                None
            });
        let range_log = ranges_log.next();
        if ranges_log.next().is_some() {
            return Err(syn::Error::new(
                self.ident.span(),
                "Parameter has more than one range attribute"))
        }

        let mut withs = self.attrs.iter().flat_map(|attrs| attrs.attributes.iter())
            .filter_map(|attr| if let ParameterAttributeTts::With(with) = attr{
                Some(with)
            }else{
                None
            });
        let with = withs.next();
        if withs.next().is_some() {
            return Err(syn::Error::new(
                self.ident.span(),
                "Parameter has more than with attribute"))
        }

        if range_log.is_some() && range.is_some(){
            return Err(syn::Error::new(
                self.ident.span(),
                "Parameter can only have range or range_log but not both"));
        }

        if with.is_some() && (default_value.is_some() || range.is_some() || range_log.is_some()){
            return Err(syn::Error::new(
                self.ident.span(),
                "Parameter can only have a with attribute or a default / range / range_log but not both"))
        }

        if let Some(with) = with {
            let with = &with.with;
            Ok(quote!{
                #with
            })
        }else{
            match &self.ty {
                syn::Type::Path(type_path) => {
                    let ty: Punctuated<syn::Ident, syn::Token![::]> = type_path.path.segments.iter()
                        .map(|path_segment| path_segment.ident.clone())
                        .collect();
                    match (default_value, range, range_log) {
                        (Some(default), Some(range), None) => {
                            let default = &default.value;
                            let range = &range.range;
                            Ok(quote!{
                                #ty ::new(#default, #range)
                            })
                        }

                        (Some(default), None, Some(range)) => {
                            let default = &default.value;
                            let range = &range.range;
                            Ok(quote!{
                                #ty ::new_log_scale(#default, #range)
                            })
                        }

                        (Some(default), None, None) => {
                            let default = &default.value;
                            Ok(quote!{
                                #default.into()
                            })
                        }

                        (None, None, None) => {
                            Ok(quote!{
                                #ty::default()
                            })
                        }

                        _ => Err(syn::Error::new(
                                self.ident.span(),
                                "Parameter range without default value not supported yet"))
                    }
                },
                syn::Type::Tuple(tuple) => {
                    // Err(syn::Error::new(self.ident.span(), "Tuple type not supported yet in default ParameterGroup impl"))
                    if range.is_some() || range_log.is_some() {
                        return Err(syn::Error::new(
                            self.ident.span(),
                            "Ranges are only supported with RangedProperty or RangedPropertyMut, not with tuples",
                        ))
                    }
                    match default_value {
                        Some(default) => {
                            let default = &default.value;
                            Ok(quote!{
                                #default.into()
                            })
                        }

                        None => {
                            Ok(quote!{
                                Default::default()
                            })
                        }
                    }
                }
                _ => {
                    Err(syn::Error::new(self.ident.span(), "Only Path or types supported in default ParameterGroup impl"))
                }
            }
        }

    }
}


impl syn::parse::Parse for Parameter{
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Parameter>{
        let attrs = syn::Attribute::parse_outer(input)?
            .into_iter()
            .filter(|attr| attr.path.is_ident("param"))
            .map(|attr| {
                let attributes = attr.parse_args_with(Punctuated::parse_terminated)?;
                Ok(GuiAttribute{
                    pound_token: attr.pound_token,
                    bracket_token: attr.bracket_token,
                    gui_path: attr.path,
                    paren: None,
                    attributes,
                })
            }).collect::<syn::Result<Vec<_>>>()?;

        Ok(Parameter{
            attrs,
            vis: input.parse()?,
            ident: input.parse()?,
            colon_token: input.parse()?,
            ty: input.parse()?,
        })
    }
}

struct ParamsDefault{
    attrs: Vec<syn::Attribute>,
    vis: syn::Visibility,
    struct_token: syn::Token![struct],
    ident: syn::Ident,
    generics: syn::Generics,
    brace_token: syn::token::Brace,
    fields: Punctuated<Parameter, syn::Token![,]>,
}

impl syn::parse::Parse for ParamsDefault{
    fn parse(input: syn::parse::ParseStream) -> syn::Result<ParamsDefault>{
        let attrs = syn::Attribute::parse_outer(input)?;
        let content;
        let vis = input.parse()?;
        let struct_token = input.parse()?;
        let ident = input.parse()?;
        let generics = input.parse()?;
        let brace_token = syn::braced!(content in input);
        let fields = content.parse_terminated(Parameter::parse)?;
        Ok(ParamsDefault{
            attrs,
            vis,
            struct_token,
            ident,
            generics,
            brace_token,
            fields,
        })
    }
}

impl ParamsDefault{
    fn impl_default(&self) -> proc_macro2::TokenStream{
        let name = &self.ident;
        let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
        let let_field = self.fields.iter().map(|f| &f.ident);
        let field = self.fields.iter().map(|f| &f.ident);
        let default = self.fields.iter().map(|f| match f.parameter_default(){
            Ok(default) => default,
            Err(err) => err.to_compile_error(),
        });
        quote!{
            impl #impl_generics Default for #name #ty_generics #where_clause{
                fn default() -> #name #ty_generics {
                    #( let #let_field = #default; )*
                    #name {
                        #( #field, )*
                    }
                }
            }
        }
    }
}