use std::{any::Any, ops::Deref, sync::Arc};

use giterated_models::{
    object::GiteratedObject, operation::GiteratedOperation, settings::Setting,
    value::GiteratedObjectValue,
};

use crate::{
    ObjectMeta, ObjectOperationPair, ObjectSettingPair, ObjectValuePair, OperationMeta, ValueMeta,
};

#[derive(Clone)]
pub struct AnyObject {
    inner: Arc<dyn Any + Send + Sync>,
    meta: Arc<ObjectMeta>,
    kind: &'static str,
}

impl AnyObject {
    pub fn new<O: GiteratedObject + 'static>(object: O) -> Self {
        Self {
            inner: Arc::new(object) as _,
            meta: Arc::new(ObjectMeta::new::<O>()),
            kind: O::object_name(),
        }
    }

    pub fn new_raw(_object: Arc<dyn Any + Send + Sync>, _kind: &'static str) -> Self {
        todo!()
    }

    pub fn kind(&self) -> &'static str {
        self.kind
    }

    pub fn meta(&self) -> &Arc<ObjectMeta> {
        &self.meta
    }
}

impl Deref for AnyObject {
    type Target = dyn Any + Send + Sync;

    fn deref(&self) -> &Self::Target {
        self.inner.as_ref()
    }
}

#[derive(Clone)]
pub struct AnyOperation {
    inner: Arc<dyn Any + Send + Sync>,
    meta: Arc<OperationMeta>,
    kind: ObjectOperationPair<'static>,
}

impl AnyOperation {
    pub fn new<O: GiteratedObject + 'static, D: GiteratedOperation<O> + 'static>(
        operation: D,
    ) -> Self {
        Self {
            inner: Arc::new(operation) as _,
            meta: Arc::new(OperationMeta::new::<O, D>()),
            kind: ObjectOperationPair::from_types::<O, D>(),
        }
    }

    pub fn new_raw(
        _operation: Arc<dyn Any + Send + Sync>,
        _kind: ObjectOperationPair<'static>,
    ) -> Self {
        todo!()
    }

    pub fn kind(&self) -> ObjectOperationPair<'static> {
        self.kind
    }

    pub fn meta(&self) -> &Arc<OperationMeta> {
        &self.meta
    }
}

impl Deref for AnyOperation {
    type Target = dyn Any + Send + Sync;

    fn deref(&self) -> &Self::Target {
        self.inner.as_ref()
    }
}

#[derive(Clone)]
pub struct AnyValue {
    inner: Arc<dyn Any + Send + Sync>,
    kind: ObjectValuePair<'static>,
}

impl AnyValue {
    pub fn new<O: GiteratedObject, V: GiteratedObjectValue<Object = O> + 'static>(
        value: V,
    ) -> Self {
        Self {
            inner: Arc::new(value) as _,
            kind: ObjectValuePair::from_types::<O, V>(),
        }
    }

    pub fn new_raw(_value: Arc<dyn Any + Send + Sync>, _kind: ObjectValuePair<'static>) -> Self {
        todo!()
    }

    pub fn kind(&self) -> ObjectValuePair<'static> {
        self.kind
    }
}

impl Deref for AnyValue {
    type Target = dyn Any + Send + Sync;

    fn deref(&self) -> &Self::Target {
        self.inner.as_ref()
    }
}

#[derive(Clone)]
pub struct AnySetting {
    inner: Arc<dyn Any + Send + Sync>,
    kind: ObjectSettingPair<'static>,
}

impl AnySetting {
    pub fn new<O: GiteratedObject, S: Setting + 'static>(setting: S) -> Self {
        Self {
            inner: Arc::new(setting) as _,
            kind: ObjectSettingPair::from_types::<O, S>(),
        }
    }

    pub fn new_raw(
        _setting: Arc<dyn Any + Send + Sync>,
        _kind: ObjectSettingPair<'static>,
    ) -> Self {
        todo!()
    }

    pub fn kind(&self) -> ObjectSettingPair<'static> {
        self.kind
    }
}

impl Deref for AnySetting {
    type Target = dyn Any + Send + Sync;

    fn deref(&self) -> &Self::Target {
        self.inner.as_ref()
    }
}

#[derive(Clone)]
pub struct AnySuccess(pub Arc<dyn Any + Send>);

#[derive(Clone)]
pub struct AnyFailure(pub Arc<dyn Any + Send>);

/// Should be renamed.
///
/// Allows accepting object types that are either GiteratedObject types or
/// AnyObject.
pub trait MaybeDynamicObject: Clone {
    fn from_any(object: &AnyObject) -> Self;

    fn object_name() -> &'static str;
}

impl<O: GiteratedObject> MaybeDynamicObject for O {
    fn from_any(_object: &AnyObject) -> Self {
        todo!()
    }

    fn object_name() -> &'static str {
        <O as GiteratedObject>::object_name()
    }
}

impl MaybeDynamicObject for AnyObject {
    fn from_any(object: &AnyObject) -> Self {
        object.clone()
    }

    fn object_name() -> &'static str {
        "any"
    }
}

pub trait MaybeDynamicValue {
    fn from_any(value: &AnyValue) -> Self;
    fn into_any(self) -> AnyValue;
    fn meta() -> Option<ValueMeta>;

    fn value_name() -> &'static str;
}

impl<V: GiteratedObjectValue> MaybeDynamicValue for V {
    fn from_any(_object: &AnyValue) -> Self {
        todo!()
    }

    fn value_name() -> &'static str {
        todo!()
    }

    fn into_any(self) -> AnyValue {
        todo!()
    }

    fn meta() -> Option<ValueMeta> {
        todo!()
    }
}

impl MaybeDynamicValue for AnyValue {
    fn value_name() -> &'static str {
        "any"
    }

    fn from_any(value: &AnyValue) -> Self {
        value.clone()
    }

    fn into_any(self) -> AnyValue {
        self
    }

    fn meta() -> Option<ValueMeta> {
        todo!()
    }
}