use std::any::Any;
use std::fmt::{self, Debug};
use std::marker::PhantomData;
use std::sync::Arc;

use super::{ObjectType, ServerMetadata, ServerPermissions};
use crate::ids::SyncId;

#[derive(Clone, Debug, Default)]
pub enum ConflictStatus<T> {
    #[default]
    NoConflicts,
    ConflictingChanges {
        object: Arc<T>,
    },
}

impl<T> ConflictStatus<T> {
    /// Utility function that allows for a more ergonomic way of figuring out whether there is a
    /// conflict (for cases where we don't care about the conflict details).
    pub fn has_conflicts(&self) -> bool {
        matches!(self, ConflictStatus::ConflictingChanges { .. })
    }
}

/// Common behavior that server-backed models expose to generic server objects.
pub trait ServerObjectModel: Debug + Clone + Send + Sync + 'static {
    /// Returns the object type for this model.
    fn object_type(&self) -> ObjectType;
}

/// Common trait for server objects that allows us to use them as trait objects
/// and downcast to concrete types when needed.
pub trait ServerObject: Debug + Send + Sync {
    /// Returns the object type of this server object
    fn object_type(&self) -> ObjectType;

    /// Returns this object as a ref to the Any type.  Needed for typecasts.
    fn as_any(&self) -> &dyn Any;

    /// Returns the trait object as a concrete type reference by downcasting it.
    /// Returns None if the downcast fails.
    fn as_concrete_type<K, M>(
        server_object: &dyn ServerObject,
    ) -> Option<&GenericServerObject<K, M>>
    where
        Self: Sized,
        K: 'static,
        M: 'static,
    {
        server_object
            .as_any()
            .downcast_ref::<GenericServerObject<K, M>>()
    }

    /// Returns a cloned boxed version of this server object.
    /// Note that we can't force the ServerObject trait to derive from Cloned
    /// directly because that would make the trait not object safe.  This
    /// is a workaround.
    fn clone_box(&self) -> Box<dyn ServerObject>;
}

/// An object that maps directly to the data returned from the server
/// for a given model and id type.
pub struct GenericServerObject<K, M> {
    pub id: SyncId,
    pub model: M,
    pub metadata: ServerMetadata,
    pub permissions: ServerPermissions,
    _marker: PhantomData<fn() -> K>,
}

impl<K, M> Clone for GenericServerObject<K, M>
where
    M: Clone,
{
    fn clone(&self) -> Self {
        Self::new(
            self.id,
            self.model.clone(),
            self.metadata.clone(),
            self.permissions.clone(),
        )
    }
}

impl<K, M> Debug for GenericServerObject<K, M>
where
    M: Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("GenericServerObject")
            .field("id", &self.id)
            .field("model", &self.model)
            .field("metadata", &self.metadata)
            .field("permissions", &self.permissions)
            .finish()
    }
}

impl<K, M> GenericServerObject<K, M> {
    /// Constructs a server object from its server-provided parts.
    pub fn new(
        id: SyncId,
        model: M,
        metadata: ServerMetadata,
        permissions: ServerPermissions,
    ) -> Self {
        Self {
            id,
            model,
            metadata,
            permissions,
            _marker: PhantomData,
        }
    }
}

impl<'a, K, M> From<&'a dyn ServerObject> for Option<&'a GenericServerObject<K, M>>
where
    K: 'static,
    M: 'static,
{
    fn from(value: &'a dyn ServerObject) -> Self {
        value.as_any().downcast_ref::<GenericServerObject<K, M>>()
    }
}

impl<'a, K, M> From<&'a Box<dyn ServerObject>> for Option<&'a GenericServerObject<K, M>>
where
    K: 'static,
    M: 'static,
{
    fn from(value: &'a Box<dyn ServerObject>) -> Self {
        value.as_ref().into()
    }
}

impl<K, M> ServerObject for GenericServerObject<K, M>
where
    K: 'static,
    M: ServerObjectModel,
{
    fn object_type(&self) -> ObjectType {
        self.model.object_type()
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn clone_box(&self) -> Box<dyn ServerObject> {
        Box::new(self.clone())
    }
}