ruwebframe 0.1.1

use std::any::Any;
use std::collections::HashMap;
use std::sync::{Arc, Mutex, OnceLock, RwLock};

/// 存储的条目：可以是工厂函数，也可以是已创建的单例实例
enum Entry {
    /// 工厂：每次 get 都调用，创建新实例
    Factory(Box<dyn Fn() -> Box<dyn Any> + Send + Sync>),
    /// 单例：首次 get 时创建，之后复用
    Singleton {
        factory: Box<dyn Fn() -> Box<dyn Any> + Send + Sync>,
        instance: Mutex<Option<Arc<dyn Any + Send + Sync>>>,
    },
}
// static GLOBAL: OnceLock<RwLock<Container>> = OnceLock::new();
//
// fn global() -> &'static RwLock<Container> {
//     GLOBAL.get_or_init(|| RwLock::new(Container::new()))
// }
pub struct Container {
    pub items: HashMap<String, Entry>,
}

impl Container {
    pub fn new() -> Self {
        Self {
            items: HashMap::new(),

        }
    }

    /// 注册一个工厂函数（每次 get 都创建新实例）
    pub fn register<F, T>(&mut self, key: &str, factory: F)
    where
        F: Fn() -> T + Send + Sync + 'static,
        T: Any + Send + Sync + 'static,
    {
        self.items.insert(
            key.to_string(),
            Entry::Factory(Box::new(move || Box::new(factory()) as Box<dyn Any>)),
        );
    }

    /// 注册一个单例工厂（首次 get 时创建，之后复用）
    pub fn register_singleton<F, T>(&mut self, key: &str, factory: F)
    where
        F: Fn() -> T + Send + Sync + 'static,
        T: Any + Send + Sync + 'static,
    {
        self.items.insert(
            key.to_string(),
            Entry::Singleton {
                factory: Box::new(move || Box::new(factory()) as Box<dyn Any>),
                instance: Mutex::new(None),
            },
        );
    }

    /// 获取实例（多例模式：每次调用都 new）
    pub fn get<T: Any + Clone>(&self, key: &str) -> Option<T> {
        let entry = self.items.get(key)?;
        match entry {
            Entry::Factory(factory) => {
                let boxed = factory();
                boxed.downcast_ref::<T>().cloned()
            }
            Entry::Singleton { .. } => {
                // 单例用 get_singleton
                None
            }
        }
    }

    /// 获取单例实例（首次 new，之后复用）
    pub fn get_singleton_c<T: Any + Send + Sync + Clone>(&self, key: &str) -> Option<T> {
        let entry = self.items.get(key)?;
        match entry {
            Entry::Singleton { factory, instance } => {
                let mut guard = instance.lock().ok()?;
                if guard.is_none() {
                    let boxed = factory();
                    let arc = Arc::new(
                        *boxed
                            .downcast::<T>()
                            .expect("类型不匹配：注册和解析的类型不一致"),
                    );
                    *guard = Some(arc);
                }
                guard.as_ref().map(|arc| {
                    arc.downcast_ref::<T>()
                        .expect("类型转换失败")
                        .clone()
                })
            }
            Entry::Factory { .. } => None,
        }
    }
    /// 返回 Arc<T>：零拷贝，多持有者共享同一实例
    pub fn get_singleton<T: Any + Send + Sync>(&self, key: &str) -> Option<Arc<T>> {
        let entry = self.items.get(key)?;
        match entry {
            Entry::Singleton { factory, instance } => {
                let mut guard = instance.lock().ok()?;

                // 懒加载：首次访问时才 new
                if guard.is_none() {
                    let boxed = factory();
                    let val = *boxed.downcast::<T>()
                        .expect("类型不匹配：注册和解析的类型不一致");
                    *guard = Some(Arc::new(val) as Arc<dyn Any + Send + Sync>);
                }

                // Arc<dyn Any> -> Arc<T>，只增加引用计数
                guard.as_ref().map(|arc_any| {
                    arc_any.clone().downcast::<T>()
                        .expect("单例内部类型转换失败")
                })
            }
            Entry::Factory { .. } => None,
        }
    }
    /// ✅ 统一入口：自动判断 key 是单例还是工厂
    pub fn get_bean<T: Any + Send + Sync>(&self, key: &str) -> Option<Arc<T>> {
        let entry = self.items.get(key)?;
        match entry {
            // 工厂模式：每次调用都 new，包成 Arc 返回
            Entry::Factory(factory) => {
                let boxed = factory();
                let val = *boxed.downcast::<T>().ok()?;
                Some(Arc::new(val))
            }
            // 单例模式：首次 new 并缓存，之后复用
            Entry::Singleton { factory, instance } => {
                let mut guard = instance.lock().ok()?;
                if guard.is_none() {
                    let val = *factory().downcast::<T>().ok()?;
                    *guard = Some(Arc::new(val) as Arc<dyn Any + Send + Sync>);
                }
                guard.as_ref()?.clone().downcast::<T>().ok()
            }
        }
    }

    /// 如果你想在外部提前知道某个 key 是什么类型
    pub fn is_singleton(&self, key: &str) -> bool {
        matches!(self.items.get(key), Some(Entry::Singleton { .. }))
    }
}


// ==================== 使用示例 ====================

#[derive(Debug, Clone)]
struct Database {
    id: u64,
}

impl Database {
    fn new() -> Self {
        println!(">>> Database::new() 被调用了！");
        Self { id: rand::random() }
    }
}

#[derive(Debug, Clone)]
struct Logger;

impl Logger {
    fn new() -> Self {
        println!(">>> Logger::new() 被调用了！");
        Self
    }
}

fn main() {
    let mut container = Container::new();

    // 1. 注册多例：每次 get 都创建新的 Database
    container.register("db", Database::new);

    // 2. 注册单例：Logger 只会被创建一次
    container.register_singleton("logger", Logger::new);

    println!("--- 第一次 get db ---");
    let db1 = container.get::<Database>("db").unwrap();
    println!("db1: {:?}\n", db1);

    println!("--- 第二次 get db ---");
    let db2 = container.get::<Database>("db").unwrap();
    println!("db2: {:?}\n", db2);

    println!("--- 第一次 get logger ---");
    let log1 = container.get_singleton::<Logger>("logger").unwrap();
    println!("log1: {:?}\n", log1);

    println!("--- 第二次 get logger ---");
    let log2 = container.get_singleton::<Logger>("logger").unwrap();
    println!("log2: {:?}\n", log2);

    println!("db1 == db2 ? {}", db1.id == db2.id); // false，不同实例
    println!("log1 == log2 ? {}", std::ptr::eq(&log1, &log2)); // true，同一实例
}

// ==================== 自动注册机制 ====================



/// 注册项：每个类型提交一个，启动时统一收集
pub struct Reg {
    pub name: &'static str,
    pub apply: fn(&mut  crate::rudi::dicontainer::dicontainer::Container),
}

// 声明收集池
inventory::collect!(Reg);

/// 启动时一次性扫描所有注册项
pub fn bootstrap(container: &mut crate::rudi::dicontainer::dicontainer::Container) {
    for reg in inventory::iter::<Reg> {
        (reg.apply)(container);
    }

}

/// 简化宏：一行完成注册
#[macro_export]
macro_rules! register_singleton {
    ($key:expr, $type:ty, $factory:expr) => {
        inventory::submit! {
            $crate::rudi::dicontainer::dicontainer::Reg {
                name: $key,
                apply: |c: &mut $crate::rudi::dicontainer::dicontainer::Container| {
                    c.register_singleton($key, $factory);
                },
            }
        }
    };
}

#[macro_export]
macro_rules! register_transient {
    ($key:expr, $type:ty, $factory:expr) => {
        inventory::submit! {
            $crate::rudi::dicontainer::dicontainer::Reg {
                name: $key,
                apply: |c: &mut $crate::rudi::dicontainer::dicontainer::Container| {
                    c.register($key, $factory);
                },
            }
        }
    };
}