lxy 0.1.1

use std::any::TypeId;
use std::ptr;
use std::sync::{Arc, RwLock};

use crate::error::Result;
use crate::utils::map::TypedMap;

use super::{BoxedFactory, BoxedResolver, Container, Factory, Resolver};

/// A very simple but safe wrapper around a raw pointer to an `Arc<T>`,
/// aims to erase the type `T` while preserving the reference counting semantics.
///
/// With [ResolvedRaw] stored in containers,
/// we will be able to store different types in a single container cache.
#[derive(Debug)]
pub struct ResolvedRaw {
  ptr: *const (),
  clone_fn: unsafe fn(*const ()) -> *const (),
  drop_fn: unsafe fn(*const ()),
}

unsafe impl Send for ResolvedRaw {}
unsafe impl Sync for ResolvedRaw {}

unsafe fn clone_arc<T>(ptr: *const ()) -> *const ()
where
  T: 'static,
{
  // SAFETY: `ptr` originated from `Arc::into_raw(Arc<T>)`.
  unsafe { Arc::increment_strong_count(ptr as *const T) };
  ptr
}

unsafe fn drop_arc<T>(ptr: *const ())
where
  T: 'static,
{
  // SAFETY: `ptr` originated from `Arc::into_raw(Arc<T>)`.
  drop(unsafe { Arc::from_raw(ptr as *const T) });
}

impl<T> From<Arc<T>> for ResolvedRaw
where
  T: 'static + Sized,
{
  fn from(arc: Arc<T>) -> Self {
    ResolvedRaw {
      ptr: Arc::into_raw(arc) as *const (),
      clone_fn: clone_arc::<T>,
      drop_fn: drop_arc::<T>,
    }
  }
}

impl Clone for ResolvedRaw {
  fn clone(&self) -> Self {
    ResolvedRaw {
      ptr: unsafe { (self.clone_fn)(self.ptr) },
      clone_fn: self.clone_fn,
      drop_fn: self.drop_fn,
    }
  }
}

impl Drop for ResolvedRaw {
  fn drop(&mut self) {
    if self.ptr.is_null() {
      return;
    }

    unsafe { (self.drop_fn)(self.ptr) };
  }
}

impl ResolvedRaw {
  /// Converts back to `Arc<T>`.
  ///
  /// # Safety
  ///
  /// The caller must ensure that the original type `T` is the same as the type being converted to.
  /// Otherwise, this will lead to undefined behavior.
  unsafe fn recover<T>(mut self) -> Arc<T> {
    // we make a null ptr to underlaying Arc<T> and swap it with self.0 to avoid double free
    let ptr = self.ptr as *const T;
    self.ptr = ptr::null::<()>();
    unsafe { Arc::from_raw(ptr) }
  }
}

/// A trait to easily convert any type into [ResolvedRaw].
trait IntoResolvedRaw {
  fn into_resolved_raw(self) -> ResolvedRaw;
}

impl<T> IntoResolvedRaw for T
where
  T: 'static + Sized,
{
  fn into_resolved_raw(self) -> ResolvedRaw {
    let arc = Arc::new(self);
    ResolvedRaw {
      ptr: Arc::into_raw(arc) as *const (),
      clone_fn: clone_arc::<T>,
      drop_fn: drop_arc::<T>,
    }
  }
}

/// Simple wrapper resolver to map any resolved [T] into [ResolvedRaw].
#[derive(Clone)]
struct MapIntoResolvedRaw<T>(T);

impl<Rg, R> Resolver<Rg> for MapIntoResolvedRaw<R>
where
  R: Resolver<Rg> + Clone + Send + Sync + 'static,
  R::Return: IntoResolvedRaw + 'static,
{
  type Return = ResolvedRaw;

  fn resolve(&self, registry: &Rg) -> Result<ResolvedRaw> {
    self
      .0
      .resolve(registry)
      .map(|resolved| resolved.into_resolved_raw())
  }
}

struct RawResolver<Registry>(BoxedResolver<Registry, ResolvedRaw>);

impl<Registry> RawResolver<Registry> {
  fn new<R>(resolver: R) -> Self
  where
    R: Resolver<Registry> + Clone + Send + Sync + 'static,
    R::Return: IntoResolvedRaw + 'static,
  {
    Self(BoxedResolver::new(MapIntoResolvedRaw(resolver)))
  }
}

/// A singleton container
///
/// ## Cache
///
/// The container maintains an internal cache to store resolved instances.
/// When an instance is requested via the `get` method, the container first checks
/// the cache to see if the instance has already been created. If it has, the cached
/// instance is returned. If not, the container uses the registered factory to create
/// the instance, stores it in the cache, and then returns it.
///
/// ## Thread Safety
///
/// The container uses `RwLock` to ensure thread-safe access to the cache. This allows multiple threads
/// to read from the cache concurrently, while write access (when adding new instances) is exclusive.
/// This design ensures that the container can be safely used in multi-threaded environments.
///
/// ## Example
///
/// ```rust
/// use std::sync::Arc;
/// use lxy::container::{RawContainer, Container, Value};
///
/// #[derive(Debug, Clone)]
/// struct Service;
///
/// #[derive(Debug)]
/// struct App {
///    service: Arc<Service>,
/// }
///
/// let mut container = RawContainer::default();
///
/// container.add(Value(Service));
/// container.bind(Service);
/// container.add(|service: Arc<Service>| App { service });
///
/// let app = container.get::<App>();  // Ok(Arc<App>)
/// let app2 = container.get::<App>(); // Ok(Arc<App>)
///
/// assert!(app.is_ok());
/// assert_eq!(Arc::into_raw(app.unwrap()), Arc::into_raw(app2.unwrap()));
/// ```
#[derive(Default, Clone)]
pub struct RawContainer {
  map: Arc<RwLock<TypedMap<RawResolver<Self>>>>,
  cache: Arc<RwLock<TypedMap<ResolvedRaw>>>,
}

impl RawContainer {
  /// Creates a new empty [RawContainer].
  pub fn new() -> Self {
    Self::default()
  }
}

impl Container for RawContainer {
  fn add<F, T, Deps>(&mut self, factory: F)
  where
    F: Factory<T, Deps>,
    T: 'static,
    Deps: 'static,
  {
    let id: TypeId = TypeId::of::<T>();

    // We need to clear the cache entry when a new factory is added for the same type.
    self
      .map
      .write()
      .unwrap()
      .insert(id, RawResolver::new(BoxedFactory::new(factory)));

    self.cache.write().unwrap().remove(&id);
  }

  fn bind<T>(&mut self, instance: T)
  where
    T: 'static,
  {
    let id: TypeId = TypeId::of::<T>();
    self
      .cache
      .write()
      .unwrap()
      .insert(id, instance.into_resolved_raw());
  }

  fn get<T>(&self) -> Result<Arc<T>>
  where
    T: 'static,
  {
    use crate::error::TypedError;

    let id: TypeId = TypeId::of::<T>();

    // Check cache first
    let mut entry = self.cache.read().unwrap().get(&id).cloned();

    if entry.is_none() {
      // Get resolver or return error
      let resolver = self
        .map
        .read()
        .unwrap()
        .get(&id)
        .ok_or_else(|| {
          super::TypeNotRegistered::error(format!(
            "Type '{}' is not registered in the container",
            std::any::type_name::<T>()
          ))
        })?
        .0
        .clone();

      // Resolve (may fail with dependency errors)
      let raw = resolver.resolve(self)?;

      // Cache the result
      self.cache.write().unwrap().entry(id).or_insert(raw.clone());
      entry = Some(raw);
    }

    entry.map(|raw| unsafe { raw.recover() }).ok_or_else(|| {
      unreachable!(
        "Entry must be Some at this point as we either got it from cache or just inserted it"
      )
    })
  }

  fn drop<T>(&mut self)
  where
    T: 'static,
  {
    let id: TypeId = TypeId::of::<T>();
    self.cache.write().unwrap().remove(&id);
  }
}

#[cfg(test)]
mod tests {
  use super::{RawContainer, ResolvedRaw};
  use crate::container::{Container, DependencyResolutionFailed, TypeNotRegistered, Value};
  use std::sync::Arc;

  #[derive(PartialEq, Debug, Clone)]
  struct Service;

  #[derive(PartialEq, Debug)]
  struct App {
    service: Arc<Service>,
  }

  #[test]
  fn test_create_from_arc() {
    let value = Arc::new(42);
    assert_eq!(Arc::strong_count(&value), 1);

    let raw: ResolvedRaw = value.clone().into();
    assert_eq!(Arc::strong_count(&value), 2);

    let recovered = unsafe { raw.recover::<i32>() };
    assert_eq!(Arc::strong_count(&value), 2);
    assert_eq!(*recovered, 42);
  }

  #[test]
  fn test_resolved_raw_clone_increments_strong_count() {
    use std::mem::ManuallyDrop;

    let value = Arc::new(123_i32);
    assert_eq!(Arc::strong_count(&value), 1);

    // Keep one Arc alive so we can reliably inspect strong_count.
    let raw: ManuallyDrop<ResolvedRaw> = ManuallyDrop::new(value.clone().into());
    assert_eq!(Arc::strong_count(&value), 2);

    // Cloning ResolvedRaw must create another strong reference.
    let _raw2: ManuallyDrop<ResolvedRaw> = ManuallyDrop::new((*raw).clone());
    assert_eq!(Arc::strong_count(&value), 3,);
  }

  #[test]
  fn test_all_together() {
    let mut container = RawContainer::default();

    container.add(Value(Service));
    container.add(|service: Arc<Service>| App { service });

    let app = container.get::<App>();
    let app2 = container.get::<App>();

    assert!(app.is_ok());
    assert_eq!(Arc::into_raw(app.unwrap()), Arc::into_raw(app2.unwrap()));
  }

  #[test]
  fn test_drop_removes_instance_from_cache_without_factory() {
    let mut container = RawContainer::default();

    // Bind an instance directly to the cache without a factory
    container.bind(Service);

    // Verify the instance is in the cache
    let service = container.get::<Service>();
    assert!(service.is_ok());

    // Drop the instance
    container.drop::<Service>();

    // Subsequent get should return Err since there's no factory
    let service_after_drop = container.get::<Service>();
    assert!(service_after_drop.is_err());
  }

  #[test]
  fn test_drop_allows_factory_to_create_new_instance() {
    use std::sync::atomic::{AtomicU32, Ordering};

    #[derive(Debug, Clone)]
    struct CountedService {
      id: u32,
    }

    let mut container = RawContainer::default();

    // Counter to track factory invocations - local to this test for isolation
    // Arc<AtomicU32> is used to satisfy Factory trait bounds (Send + Sync)
    let counter = Arc::new(AtomicU32::new(0));

    // Add a factory that creates a new instance with incremented counter each time
    let counter_clone = counter.clone();
    container.add(move || {
      let id = counter_clone.fetch_add(1, Ordering::SeqCst);
      CountedService { id }
    });

    // Get the first instance - factory creates it with id=0
    let service1 = container
      .get::<CountedService>()
      .expect("First get should create and cache instance");
    assert_eq!(service1.id, 0);

    // Get again - should return the cached instance (id=0)
    let service1_again = container
      .get::<CountedService>()
      .expect("Second get should return cached instance");
    assert_eq!(service1_again.id, 0);
    assert!(Arc::ptr_eq(&service1, &service1_again));

    // Drop the cached instance
    container.drop::<CountedService>();

    // Get again - should re-resolve from factory with new id=1
    let service2 = container
      .get::<CountedService>()
      .expect("Third get should re-resolve from factory");
    assert_eq!(
      service2.id, 1,
      "Factory should create new instance after drop"
    );

    // Verify the instances are different Arc pointers
    assert!(
      !Arc::ptr_eq(&service1, &service2),
      "New instance should be created, not reusing dropped one"
    );
  }

  #[test]
  fn test_type_not_registered_error() {
    let container = RawContainer::new();

    let result = container.get::<Service>();
    assert!(result.is_err());

    let err = result.unwrap_err();
    assert!(err.is(TypeNotRegistered));
    assert!(err.message().contains("Service"));
  }

  #[test]
  fn test_dependency_chain_error() {
    #[derive(Debug)]
    struct Config;

    #[derive(Debug)]
    struct ServiceWithConfig {
      _config: Arc<Config>,
    }

    let mut container = RawContainer::new();

    // Register Service that depends on Config (not registered)
    container.add(|config: Arc<Config>| ServiceWithConfig { _config: config });

    let result = container.get::<ServiceWithConfig>();
    assert!(result.is_err());

    let err = result.unwrap_err();
    assert!(err.is(DependencyResolutionFailed));
    assert!(err.message().contains("ServiceWithConfig"));
    assert!(err.message().contains("Config"));

    // Check source chain
    let source = err.source().expect("Should have source error");
    assert!(source.to_string().contains("Config"));
  }

  #[test]
  fn test_deep_dependency_chain_error() {
    #[derive(Debug)]
    struct Config;

    #[derive(Debug)]
    struct ServiceWithConfig {
      _config: Arc<Config>,
    }

    #[derive(Debug)]
    struct AppWithService {
      _service: Arc<ServiceWithConfig>,
    }

    let mut container = RawContainer::new();

    // Create chain: App -> Service -> Config (Config missing)
    container.add(|config: Arc<Config>| ServiceWithConfig { _config: config });
    container.add(|service: Arc<ServiceWithConfig>| AppWithService { _service: service });

    let result = container.get::<AppWithService>();
    assert!(result.is_err());

    let err = result.unwrap_err();
    // Should show: App failed because Service failed because Config missing
    assert!(err.message().contains("AppWithService"));
    assert!(err.message().contains("ServiceWithConfig"));

    // Check that we can trace through the source chain
    let mut source_opt = err.source();
    let mut depth = 0;
    while let Some(source) = source_opt {
      depth += 1;
      source_opt = source.source();
    }
    assert_eq!(depth, 2, "Should have 2 levels in the error chain");
  }
}