noema 0.1.3

use std::fmt::Display;
use std::sync::Arc;

use crate::resolver::Container;

/// Trait for generate a Collecion Types
///
/// # Examples
/// ```ignore
/// #[derive(Default)]
/// struct Steps;
/// impl Collection for Steps {
///     type Value = i32;
///
///     fn name(&self) -> String {
///         "Steps".to_string()
///     }
/// }
/// ```
pub trait Collection {
    /// Define the valur for all items
    type Value: Display + Eq + Default;

    /// Define a name for collection
    fn name(&self) -> String;
    /// Define what is the collection
    fn describe(&self) -> String {
        format!("Collection with name: {}", self.name())
    }
    /// default value of collection (by defect is default value of Value)
    fn default_value(&self) -> Self::Value {
        <Self::Value as Default>::default()
    }
}

/// Item trait for items collections
///
/// # Examples
/// ```ignore
/// #[derive(Default)]
/// struct Steps;
/// impl Collection for Steps {
///     type Value = i32;
///
///     fn name(&self) -> String {
///         "Steps".to_string()
///     }
/// }
/// #[derive(Default)]
/// struct StepOne;
/// impl Item for StepOne {
///     type CollectionType = Steps;
///     fn name(&self) -> String {
///         "Step One".to_string()
///     }
///     fn value(&self) -> <Self::CollectionType as Collection>::Value {
///         12
///     }
/// }
/// collections!(Steps: [StepOne]);
/// let steps = items_collection_locator::<Steps>();
/// assert!(steps.collection().name() == "Steps".to_string());
/// ```
pub trait Item: Send + Sync {
    type CollectionType: Collection + Default;
    /// Get value of the flag
    fn value(&self) -> <Self::CollectionType as Collection>::Value;

    /// Get name of the flag
    fn name(&self) -> String;

    /// Get description of the flag
    fn description(&self) -> String {
        format!("Item {}: {}", self.name(), self.value())
    }

    /// Convert to tuple when (name, value, description)
    fn to_tuple(&self) -> (String, <Self::CollectionType as Collection>::Value, String) {
        (self.name(), self.value(), self.description())
    }
}

/// Collection for Items of type I
pub trait ItemsCollection<C: Collection + Default + ?Sized + Send + Sync> {
    /// Get all flag elements
    fn all(&self) -> Arc<Vec<Arc<dyn Item<CollectionType = C> + Send + Sync>>>;

    fn type_properties(&self) -> C {
        <C as Default>::default()
    }

    // Get elements matching a predicate
    // # Examples
    // ```
    // let name = "Hola".to_string();
    // let new_items = items_collection.find(&|e| e.name() == &name)
    // ```
    fn find(
        &self,
        predicate: &dyn Fn(&Arc<dyn Item<CollectionType = C> + Send + Sync>) -> bool,
    ) -> Vec<Arc<dyn Item<CollectionType = C> + Send + Sync>> {
        let mut result = Vec::new();
        for element in self.all().iter() {
            if predicate(element) {
                result.push(element.clone());
            }
        }
        result
    }

    /// Get one enumeration element by value
    fn by_value(&self, value: C::Value) -> Option<Arc<dyn Item<CollectionType = C> + Send + Sync>> {
        self.find(&|e| e.value() == value).into_iter().next()
    }

    /// Get one enumeration element by name
    fn by_name(&self, name: &str) -> Option<Arc<dyn Item<CollectionType = C> + Send + Sync>> {
        self.find(&|e| e.name() == name).into_iter().next()
    }

    /// Convert to tuple when (name, value, description)
    fn to_tuple(&self) -> Vec<(String, C::Value, String)> {
        let mut result = Vec::new();
        for e in self.all().iter() {
            result.push(e.to_tuple());
        }
        result
    }
}

/// Get items collection for item type with collection type C
/// # Examples
/// ```ignore
/// let steps = collection::<Steps>();
/// assert!(steps.type_properties().name() == "Steps".to_string());
/// ```
pub fn collection<C: Send + Sync>() -> impl ItemsCollection<C> + Send + Sync
where
    C: Collection + Default + 'static,
    Container: ItemsCollection<C> + Send + Sync,
{
    return Container;
}

/// Macro to define items collections for item types
/// WHERE
///     Each CollectionType must Implement Collection
///     Each Item must Implement Item set CollectionType how same Collection
///
/// Supports multiple flags collections:
/// - CollectionType: [Impl1, Impl2, Impl3]
///
/// # Examples
/// ```ignore
/// collections!(
///     MyCollectionTypeA: [MyItemImplA1, MyItemImplA2, MyItemImplA3],
///     MyCollectionTypeB: [MyItemImplB1, MyItemsImplB2]
/// );
/// ```
#[macro_export]
macro_rules! collections {
    // Entry point - process all items
    ($($item:tt)*) => {
        $crate::__items_collections_internal!($($item)*);
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __items_collections_internal {
    // Base case - empty
    () => {};

    // Collection Type: [Items implementations], more items
    ($tcollection:ty: [$($impl:ty),* $(,)?], $($rest:tt)*) => {
        const _: () = {
            use std::sync::{Arc, LazyLock};
            use $crate::items::{Item, ItemsCollection};
            use $crate::resolver::Container;

            static _NOEMA_COLLECTION: LazyLock<Arc<Vec<Arc<dyn Item<CollectionType = $tcollection> + Send + Sync>>>> =
                LazyLock::new(|| {
                    let mut elements: Vec<Arc<dyn Item<CollectionType = $tcollection> + Send + Sync>> = Vec::new();
                    $(
                        elements.push(Arc::new(<$impl>::default()) as Arc<dyn Item<CollectionType = $tcollection> + Send + Sync>);
                    )*
                    Arc::new(elements)
                });

            impl ItemsCollection<$tcollection> for Container {
                fn all(&self) -> Arc<Vec<Arc<dyn Item<CollectionType = $tcollection> + Send + Sync>>> {
                    _NOEMA_COLLECTION.clone()
                }
            }
        };
        $crate::__items_collections_internal!($($rest)*);
    };

    // Collection Type: [Items implementations], last item
    ($tcollection:ty: [$($impl:ty),* $(,)?]) => {
        const _: () = {
            use std::sync::{Arc, LazyLock};
            use $crate::items::{Item, ItemsCollection};
            use $crate::resolver::Container;

            static _NOEMA_COLLECTION: LazyLock<Arc<Vec<Arc<dyn Item<CollectionType = $tcollection> + Send + Sync>>>> =
                LazyLock::new(|| {
                    let mut elements: Vec<Arc<dyn Item<CollectionType = $tcollection> + Send + Sync>> = Vec::new();
                    $(
                        elements.push(Arc::new(<$impl>::default()) as Arc<dyn Item<CollectionType = $tcollection> + Send + Sync>);
                    )*
                    Arc::new(elements)
                });

            impl ItemsCollection<$tcollection> for Container {
                fn all(&self) -> Arc<Vec<Arc<dyn Item<CollectionType = $tcollection> + Send + Sync>>> {
                    _NOEMA_COLLECTION.clone()
                }
            }
        };
    };
}

#[cfg(test)]
mod test {
    use crate::items::collection;

    #[test]
    fn test_items_collections() {
        use crate::items::{Collection, Item, ItemsCollection};
        #[derive(Default)]
        struct Steps;
        impl Collection for Steps {
            type Value = i32;

            fn name(&self) -> String {
                "Steps".to_string()
            }
        }
        #[derive(Default)]
        struct StepOne;
        impl Item for StepOne {
            type CollectionType = Steps;
            fn name(&self) -> String {
                "Step One".to_string()
            }
            fn value(&self) -> <Self::CollectionType as Collection>::Value {
                12
            }
        }
        collections!(Steps: [StepOne]);
        let steps = collection::<Steps>();
        assert!(steps.type_properties().name() == "Steps".to_string());
    }
}