use std::{any::Any, str::FromStr, sync::Arc};

use futures_util::{future::LocalBoxFuture, FutureExt};
use giterated_models::{
    object::GiteratedObject,
    operation::GiteratedOperation,
    settings::Setting,
    value::{GetValueTyped, GiteratedObjectValue},
};
use serde_json::Value;

use crate::{GiteratedStack, StackOperationState};

pub struct ValueMeta {
    pub name: String,
    pub deserialize: fn(&[u8]) -> Result<Box<dyn Any>, serde_json::Error>,
    pub serialize: fn(Box<dyn Any + Send + Sync>) -> Result<Vec<u8>, serde_json::Error>,
    pub typed_get: fn() -> Box<dyn Any + Send + Sync>,
    pub is_get_value_typed: fn(&Box<dyn Any + Send + Sync>) -> bool,
}

pub trait IntoValueMeta {
    fn name() -> String;
    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any>, serde_json::Error>;
    fn serialize(value: Box<dyn Any + Send + Sync>) -> Result<Vec<u8>, serde_json::Error>;
    fn typed_get() -> Box<dyn Any + Send + Sync>;
    fn is_get_value_typed(typed_get_value: &Box<dyn Any + Send + Sync>) -> bool;
}

impl<O: GiteratedObject, V: GiteratedObjectValue<Object = O> + 'static> IntoValueMeta for V {
    fn name() -> String {
        V::value_name().to_string()
    }

    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any>, serde_json::Error> {
        Ok(Box::new(serde_json::from_slice(buffer)?))
    }

    fn serialize(value: Box<dyn Any + Send + Sync>) -> Result<Vec<u8>, serde_json::Error> {
        let value = value.downcast::<V>().unwrap();

        serde_json::to_vec(&*value)
    }

    fn typed_get() -> Box<dyn Any + Send + Sync> {
        Box::new(GetValueTyped::<V> {
            value_name: V::value_name().to_string(),
            ty: Default::default(),
        })
    }

    fn is_get_value_typed(typed_get_value: &Box<dyn Any + Send + Sync>) -> bool {
        typed_get_value.is::<GetValueTyped<V>>()
    }
}

impl ValueMeta {
    pub fn new<I: IntoValueMeta + 'static>() -> Self {
        Self {
            name: I::name(),
            deserialize: I::deserialize,
            serialize: I::serialize,
            typed_get: I::typed_get,
            is_get_value_typed: I::is_get_value_typed,
        }
    }
}

pub struct OperationMeta {
    pub name: String,
    pub object_kind: String,
    pub deserialize: fn(&[u8]) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error>,
    pub any_is_same: fn(&dyn Any) -> bool,
    pub serialize_success: fn(Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error>,
    pub serialize_error: fn(Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error>,
}

pub trait IntoOperationMeta<O> {
    fn name() -> String;
    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error>;
    fn serialize_success(success: Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error>;
    fn serialize_failure(failure: Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error>;
    fn any_is_same(other: &dyn Any) -> bool;
}

impl<O, D> IntoOperationMeta<O> for D
where
    D::Failure: 'static,
    D::Success: 'static,
    O: GiteratedObject,
    D: GiteratedOperation<O> + 'static,
{
    fn name() -> String {
        D::operation_name().to_string()
    }

    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error> {
        Ok(Box::new(serde_json::from_slice::<D>(buffer)?) as Box<dyn Any + Send + Sync>)
    }

    fn serialize_success(success: Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error> {
        let to_serialize = success.downcast::<D::Success>().unwrap();
        serde_json::to_vec(&to_serialize)
    }

    fn serialize_failure(failure: Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error> {
        let to_serialize = failure.downcast::<D::Failure>().unwrap();
        serde_json::to_vec(&to_serialize)
    }

    fn any_is_same(other: &dyn Any) -> bool {
        other.is::<D>()
    }
}

impl OperationMeta {
    pub fn new<O: GiteratedObject + 'static, I: IntoOperationMeta<O> + 'static>() -> Self {
        Self {
            name: I::name(),
            deserialize: I::deserialize,
            serialize_success: I::serialize_success,
            serialize_error: I::serialize_failure,
            object_kind: O::object_name().to_string(),
            any_is_same: I::any_is_same,
        }
    }
}

pub struct ObjectMeta {
    pub name: String,
    pub from_str: Box<dyn Fn(&str) -> Result<Box<dyn Any + Send + Sync>, ()> + Send + Sync>,
    pub any_is_same: fn(&dyn Any) -> bool,
}

pub trait IntoObjectMeta: FromStr {
    fn name() -> String;
    fn any_is_same(other: &dyn Any) -> bool;
}

impl<O: GiteratedObject + 'static> IntoObjectMeta for O {
    fn name() -> String {
        O::object_name().to_string()
    }

    fn any_is_same(other: &dyn Any) -> bool {
        other.is::<O>()
    }
}

impl ObjectMeta {
    pub fn new<I: IntoObjectMeta + Send + Sync + 'static>() -> Self {
        Self {
            name: I::name(),
            from_str: Box::new(|source| {
                let object = I::from_str(source).map_err(|_| ())?;

                Ok(Box::new(object) as Box<dyn Any + Send + Sync>)
            }),
            any_is_same: I::any_is_same,
        }
    }
}

pub struct SettingMeta {
    pub name: String,
    pub deserialize: fn(Value) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error>,
    pub serialize: fn(&(dyn Any + Send + Sync)) -> Result<Value, serde_json::Error>,
    pub setting_updated: for<'fut> fn(
        Box<dyn Any + Send + Sync>,
        Box<dyn Any + Send + Sync>,
        Arc<GiteratedStack>,
        &StackOperationState,
    ) -> LocalBoxFuture<'_, ()>,
}

pub trait IntoSettingMeta<O> {
    fn name() -> String;
    fn deserialize(value: Value) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error>;
    fn serialize(setting: &(dyn Any + Send + Sync)) -> Result<Value, serde_json::Error>;
    fn setting_updated(
        object: Box<dyn Any + Send + Sync>,
        setting: Box<dyn Any + Send + Sync>,
        stack: Arc<GiteratedStack>,
        operation_state: &StackOperationState,
    ) -> LocalBoxFuture<'_, ()>;
}

impl<O: GiteratedObject + 'static, S: Setting + 'static> IntoSettingMeta<O> for S {
    fn name() -> String {
        S::name().to_string()
    }

    fn deserialize(value: Value) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error> {
        Ok(Box::new(serde_json::from_value::<S>(value)?))
    }

    fn serialize(setting: &(dyn Any + Send + Sync)) -> Result<Value, serde_json::Error> {
        serde_json::to_value(setting.downcast_ref::<S>().unwrap())
    }

    fn setting_updated(
        object: Box<dyn Any + Send + Sync>,
        setting: Box<dyn Any + Send + Sync>,
        stack: Arc<GiteratedStack>,
        operation_state: &StackOperationState,
    ) -> LocalBoxFuture<'_, ()> {
        async move {
            stack
                .setting_update(
                    *object.downcast::<O>().unwrap(),
                    *setting.downcast::<S>().unwrap(),
                    operation_state,
                )
                .await
        }
        .boxed_local()
    }
}

impl SettingMeta {
    pub fn new<O: GiteratedObject, I: IntoSettingMeta<O> + 'static>() -> Self {
        Self {
            name: I::name(),
            deserialize: I::deserialize,
            serialize: I::serialize,
            setting_updated: I::setting_updated,
        }
    }
}