//! Utilities for parsing
use std::ops::{Deref, DerefMut};
use std::hash::Hash;
use std::iter::{FromIterator, IntoIterator};

use indexmap::IndexMap;

use syn::{bracketed, braced, Token};
use syn::spanned::Spanned;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use proc_macro2::{Ident, TokenStream};
use quote::ToTokens;

/// A type that can be parsed as an argument
/// to a macro.
///
/// This is often implemented by delegating to syn's [Parse].
///
/// However, sometimes it can behave differently.
/// For example, nested [MacroKeywordArgs](crate::MacroKeywordArgs)
/// require surrounding braces `{}` when parsed as a `MacroArg`,
/// but not when parsed via syn's [Parse].
///
/// This gives the effect of requiring braces when nested (as a MacroArg),
/// but not at the top level (via syn's Parse).
pub trait MacroArg: Sized {
    /// Parse the argument to the macro
    fn parse_macro_arg(stream: ParseStream) -> syn::Result<Self>;
}

/// Parses an optional [MacroArg],
/// always returning the `Some` variant
///
/// The `None` variant will only be generated 
/// if the argument is missing
impl<T: MacroArg> MacroArg for Option<T> {
    fn parse_macro_arg(stream: ParseStream) -> syn::Result<Self> {
        Ok(Some(T::parse_macro_arg(stream)?))
    }
}

/// Internal utility for parsing
macro_rules! macro_arg_parse_map {
    ($target:ty; via $delegate:ty, |$src:ident| $transform:expr) => {
        impl MacroArg for $target {
            fn parse_macro_arg(stream: ParseStream) -> syn::Result<Self> {
                let $src: $delegate = stream.parse()?;
                Ok($transform)
            }
        }
    }
}
macro_rules! macro_arg_parse_int {
    ($($target:ty),*) => {
        $(macro_arg_parse_map!($target; via syn::LitInt, |i| i.base10_parse::<$target>()?);)*
    };
}

/// Implements [MacroArg] via syn's [Parse] trait
#[macro_export]
macro_rules! parse_macro_arg_via_syn {
    ($target:path) => (parse_macro_arg_via_syn!($target; for <>););
    ($target:path; for <$($lt:lifetime,)* $($param:ident),*> $(where $($where_tks:tt)*)?) => {
        impl<$($lt,)* $($param),*> $crate::parse::MacroArg for $target $(where $($where_tks)* )* {
            fn parse_macro_arg(stream: syn::parse::ParseStream) -> syn::Result<Self> {
                Ok(stream.parse()?)
            }
        }
    };
}
macro_arg_parse_int!(
    u8, u16, u32, u64, usize,
    i8, i16, i32, i64, isize
);
macro_arg_parse_map!(String; via syn::LitStr, |s| s.value());
macro_arg_parse_map!(bool; via syn::LitBool, |s| s.value());
macro_arg_parse_map!(f64; via syn::LitFloat, |f| f.base10_parse::<f64>()?);
macro_arg_parse_map!(f32; via syn::LitFloat, |f| f.base10_parse::<f32>()?);
macro_arg_parse_map!(char; via syn::LitChar, |c| c.value());

/// The key in a [NestedDict]
pub trait MacroDictKey = MacroArg + Eq + Hash + Spanned;

/// A pair of values in a [NestedDict]
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct KeyValuePair<K: MacroDictKey, V: MacroArg> {
    /// The key 
    pub key: K,
    /// The value
    pub value: V
}
impl<K: MacroDictKey, V: MacroArg> Parse for KeyValuePair<K, V> {
    fn parse(stream: ParseStream) -> syn::Result<Self> {
        let key = K::parse_macro_arg(stream)?;
        stream.parse::<Token![=>]>()?;
        let value = V::parse_macro_arg(stream)?;
        Ok(KeyValuePair { key, value })
    }
}
parse_macro_arg_via_syn!(KeyValuePair::<K, V>; for <K, V> where K: MacroDictKey, V: MacroArg);

/// A nested dictionary mapping keys to values with `=>`,
/// and surrounded by braces
///
/// Duplicated keys are considered an error.
///
///
/// ## Example
/// `{ a => b, c => b }` is a `NestedDict<Ident, Ident>`
pub struct NestedDict<K: MacroDictKey, V: MacroArg> {
    /// The brace token
    pub braces: syn::token::Brace,
    /// The underlying map of keys to values
    pub elements: IndexMap<K, V>
}
impl<K: MacroDictKey, V: MacroArg> NestedDict<K, V> {
    fn try_extend_pairs(&mut self, iter: impl Iterator<Item=KeyValuePair<K, V>>) -> Result<(), syn::Error> {
        for pair in iter {
            let key_span = pair.key.span();
            let existing = self.elements.insert(pair.key, pair.value);
            if existing.is_some() {
                return Err(syn::Error::new(
                    key_span,
                    "Duplicate keys",
                ));
            }
        }
        Ok(())
    }
}
impl<K: MacroDictKey, V: MacroArg> MacroArg for NestedDict<K, V> {
    fn parse_macro_arg(stream: ParseStream) -> syn::Result<Self> {
        let content;
        let braces = braced!(content in stream);
        let pairs = Punctuated::<KeyValuePair<K, V>, Token![,]>::parse_terminated(&content)?;
        let mut res = NestedDict {
            braces, elements: IndexMap::default()
        };
        res.try_extend_pairs(pairs.into_iter())?;
        Ok(res)
    }

}
impl<K: MacroDictKey, V: MacroArg> Deref for NestedDict<K, V> {
    type Target = IndexMap<K, V>;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.elements
    }
}
impl<K: MacroDictKey, V: MacroArg> DerefMut for NestedDict<K, V> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.elements
    }
}


/// A nested list of [Punctuated] items,
/// surrounded by brackets (ex. `[1, 2, 3]`)
///
/// By default, the separator token is the comma `,`
#[derive(PartialEq, Eq, Debug, Hash)]
pub struct NestedList<T: MacroArg, P = Token![,]> {
    /// The brackets tokens
    pub brackets: syn::token::Bracket,
    /// The list of elements, including punctuation
    pub elements: Punctuated<T, P>
}
impl<T: MacroArg, P: Default> From<Vec<T>> for NestedList<T, P> {
    fn from(v: Vec<T>) -> Self {
        v.into_iter().collect::<Self>()
    }
}
impl<T: MacroArg, P: Default> FromIterator<T> for NestedList<T, P> {
    fn from_iter<A: IntoIterator<Item=T>>(iter: A) -> Self {
        NestedList {
            brackets: Default::default(),
            elements: iter.into_iter().collect()
        }
    }
}
// NOTE: Implemented manually to avoid bounds on `T`
impl<T: MacroArg, P> Default for NestedList<T, P> {
    fn default() -> Self {
        NestedList {
            brackets: Default::default(),
            elements: Default::default()
        }
    }
} 
impl<T: MacroArg, P> Deref for NestedList<T, P> {
    type Target = Punctuated<T, P>;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.elements
    }
}
impl<T: MacroArg, P> DerefMut for NestedList<T, P> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.elements
    }
}
impl<T: MacroArg, P: Parse> Parse for NestedList<T, P> {
    fn parse(stream: ParseStream) -> syn::Result<Self> {
        let content;
        Ok(NestedList {
            brackets: bracketed!(content in stream),
            elements: Punctuated::parse_terminated_with(
                &content,
                T::parse_macro_arg
            )?
        })
    }
}
parse_macro_arg_via_syn!(NestedList::<T, P>; for <T, P> where T: MacroArg, P: Parse);



parse_macro_arg_via_syn!(Ident);
parse_macro_arg_via_syn!(syn::Path);
parse_macro_arg_via_syn!(syn::Type);
parse_macro_arg_via_syn!(syn::Expr);
parse_macro_arg_via_syn!(syn::Lifetime);
parse_macro_arg_via_syn!(syn::LitStr);
parse_macro_arg_via_syn!(syn::LitInt);
parse_macro_arg_via_syn!(syn::LitFloat);
parse_macro_arg_via_syn!(syn::LitBool);
parse_macro_arg_via_syn!(syn::Lit);
parse_macro_arg_via_syn!(syn::Meta);
parse_macro_arg_via_syn!(syn::NestedMeta);
parse_macro_arg_via_syn!(syn::Visibility);
/// Wrapper type that parses via syn's [Parse] trait
///
/// Through this wrapper, any AST node can be parsed
/// as a [MacroArg]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct Syn<T: Parse>(pub T);
impl<T: Parse> Syn<T> {
    /// Convert this type into its inner type
    #[inline]
    pub fn into_inner(self) -> T {
        self.0
    }
}
impl<T: Parse> Parse for Syn<T> {
    fn parse(stream: ParseStream) -> syn::Result<Self> {
        Ok(Syn(stream.parse()?))
    }
}
impl<T: Parse + ToTokens> ToTokens for Syn<T> {
    fn to_tokens(&self, stream: &mut TokenStream) {
        self.0.to_tokens(stream)
    }
    fn to_token_stream(&self) -> TokenStream {
        self.0.to_token_stream()
    }
    fn into_token_stream(self) -> TokenStream {
        self.0.into_token_stream()
    }
}
impl<T: Parse> Deref for Syn<T> {
    type Target = T;
    #[inline]
    fn deref(&self) -> &T {
        &self.0
    }
}
impl<T: Parse> DerefMut for Syn<T> {
    #[inline]
    fn deref_mut(&mut self) -> &mut T {
        &mut self.0
    }
}
parse_macro_arg_via_syn!(Syn::<T>; for <T> where T: Parse);