//! Small numbers can be used to describe some constrained data.
//! For example, a number of alignment bytes:
//! 
//! ```rust
//! use small_num::small_num;
//! 
//! small_num! {
//!     #[derive(Clone, Debug, PartialEq, Copy, Eq, PartialOrd, Ord, Hash)]
//!     pub enum AlignBytes: [1, 2, 4];
//! }
//! 
//! let bytes = AlignBytes::new(2);
//! assert_eq!(bytes, Some(AlignBytes::_2));
//! assert_eq!(AlignBytes::new(3), None);
//! assert_eq!(std::mem::size_of::<Option<AlignBytes>>(), 1);
//! ```
//! 
//! Or an integer valid for a spicific range:
//! 
//! ```rust
//! use small_num::small_num;
//! 
//! small_num! {
//!     #[derive(Clone, Debug, PartialEq, Copy, Eq, PartialOrd, Ord, Hash)]
//!     pub enum U7: ..128;
//! }
//! 
//! assert_eq!(U7::new(0), Some(U7::_0));
//! assert_eq!(U7::new(50), Some(U7::_50));
//! assert_eq!(U7::new(127), Some(U7::_127));
//! assert_eq!(U7::new(128), None);
//! assert_eq!(std::mem::size_of::<Option<U7>>(), 1);
//! ```
//! 
//! It can be casted to an integer with `as` operator:
//! 
//! ```rust
//! use small_num::small_num;
//! 
//! small_num! {
//!     #[derive(Clone, Debug, PartialEq, Copy, Eq, PartialOrd, Ord, Hash)]
//!     pub enum Num50to100: 50..=100;
//! }
//! 
//! assert_eq!(Num50to100::new(69).unwrap() as u32, 69);
//! ```



pub mod util {
    pub use seq_macro::seq;
    pub use paste::paste;
}



/// Macro used to create small numbers. It comes in two forms: as a range
/// and a list of valid values.
/// 
/// # List form
/// 
/// It creates enum with given list of values.
/// 
/// ```rust,ignore
/// small_num! {
///     pub enum ListNum: [<list of values>];
/// }
/// ```
/// 
/// # Range form
/// 
/// It creates enum with all numbers from given range.
/// 
/// ```rust,ignore
/// small_num! {
///     pub enum RangeNum: <START>..<END>;
/// }
/// ```
#[macro_export]
macro_rules! small_num {
    (
        $( #[$meta:meta] )*
        $vis:vis enum $Name:ident : [ $($value:literal),* $(,)? ];
    ) => {
        $crate::util::paste! {
            $( #[$meta] )*
            $vis enum $Name {
                $(
                    [<_ $value>] = $value,
                )*
            }
        }

        impl $Name {
            #[allow(dead_code)]
            $vis const fn new(value: u32) -> Option<Self> {
                $crate::util::paste! {
                    Some(match value {
                        $(
                            $value => Self::[<_ $value>],
                        )*
                        _ => return None,
                    })
                }
            }

            #[allow(dead_code)]
            $vis const unsafe fn new_unchecked(value: u32) -> Self {
                $crate::util::paste! {
                    match value {
                        $(
                            $value => Self::[<_ $value>],
                        )*
                        _ => unsafe { ::core::hint::unreachable_unchecked() },
                    }
                }
            }
        }
    };

    (
        $( #[$meta:meta] )*
        $vis:vis enum $Name:ident : $start:literal..$end:literal;
    ) => {
        $crate::util::seq!(N in $start..$end {
            $( #[$meta] )*
            $vis enum $Name {
                #(
                    _~N = N,
                )*
            }
        });

        impl $Name {
            #[allow(dead_code)]
            $vis const fn new(value: u32) -> Option<Self> {
                $crate::util::seq!(N in $start..$end {
                    Some(match value {
                        #( N => Self::_~N, )*
                        _ => return None,
                    })
                })
            }

            #[allow(dead_code)]
            $vis const unsafe fn new_unchecked(value: u32) -> Self {
                $crate::util::seq!(N in $start..$end {
                    match value {
                        #( N => Self::_~N, )*
                        _ => unsafe { ::core::hint::unreachable_unchecked() },
                    }
                })
            }
        }
    };

    (
        $( #[$meta:meta] )*
        $vis:vis enum $Name:ident : $start:literal..=$end:literal;
    ) => {
        $crate::util::seq!(N in $start..=$end {
            $( #[$meta] )*
            $vis enum $Name {
                #(
                    _~N = N,
                )*
            }
        });

        impl $Name {
            #[allow(dead_code)]
            $vis const fn new(value: u32) -> Option<Self> {
                $crate::util::seq!(N in $start..=$end {
                    Some(match value {
                        #( N => Self::_~N, )*
                        _ => return None,
                    })
                })
            }

            #[allow(dead_code)]
            $vis const unsafe fn new_unchecked(value: u32) -> Self {
                $crate::util::seq!(N in $start..=$end {
                    match value {
                        #( N => Self::_~N, )*
                        _ => ::core::hint::unreachable_unchecked(),
                    }
                })
            }
        }
    };

    (
        $( #[$meta:meta] )*
        $vis:vis enum $Name:ident : ..$end:literal;
    ) => {
        $crate::small_num! {
            $( #[$meta] )*
            $vis enum $Name : 0..$end;
        }
    };

    (
        $( #[$meta:meta] )*
        $vis:vis enum $Name:ident : ..=$end:literal;
    ) => {
        $crate::small_num! {
            $( #[$meta] )*
            $vis enum $Name : 0..=$end;
        }
    };

    (
        $( #[$meta:meta] )*
        $vis:vis enum $Name:ident : $( $start:literal )? ..;
    ) => {
        ::core::compile_error!("RageTo in range_num is unsupported");
    };
}



#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_list() {
        small_num! {
            #[derive(Clone, Debug, PartialEq, Copy)]
            pub enum ListNum: [1, 2, 4, 8];
        }

        assert_eq!(ListNum::new(1), Some(ListNum::_1));
        assert_eq!(ListNum::new(2), Some(ListNum::_2));
        assert_eq!(ListNum::new(4), Some(ListNum::_4));
        assert_eq!(ListNum::new(8), Some(ListNum::_8));
        assert_eq!(ListNum::new(9), None);
    }

    #[test]
    fn test_range() {
        small_num! {
            #[derive(Clone, Debug, PartialEq, Copy)]
            pub enum RangeNum: 10..15;
        }

        assert_eq!(RangeNum::new(10), Some(RangeNum::_10));
        assert_eq!(RangeNum::new(11), Some(RangeNum::_11));
        assert_eq!(RangeNum::new(16), None);
    }
}