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

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

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

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();

        Ok(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: Box::new(I::deserialize) as _,
            serialize: Box::new(I::serialize) as _,
            typed_get: Box::new(I::typed_get) as _,
            is_get_value_typed: Box::new(I::is_get_value_typed) as _,
        }
    }
}

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

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: Box::new(I::deserialize) as _,
            serialize_success: Box::new(I::serialize_success) as _,
            serialize_error: Box::new(I::serialize_failure) as _,
            object_kind: O::object_name().to_string(),
            any_is_same: Box::new(I::any_is_same) as _,
        }
    }
}

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: Box<dyn Fn(&dyn Any) -> bool + Send + Sync>,
}

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: Box::new(I::any_is_same) as _,
        }
    }
}

pub struct SettingMeta {
    pub name: String,
    pub deserialize: Box<dyn Fn(&[u8]) -> Result<Box<dyn Any>, serde_json::Error> + Send + Sync>,
    pub serialize:
        Box<dyn Fn(Box<dyn Any + Send + Sync>) -> Result<Value, serde_json::Error> + Send + Sync>,
}

pub trait IntoSettingMeta {
    fn name() -> String;
    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any>, serde_json::Error>;
    fn serialize(setting: Box<dyn Any + Send + Sync>) -> Result<Value, serde_json::Error>;
}

impl<S: Setting> IntoSettingMeta for S {
    fn name() -> String {
        S::name().to_string()
    }

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

    fn serialize(setting: Box<dyn Any + Send + Sync>) -> Result<Value, serde_json::Error> {
        Ok(*setting.downcast::<Value>().unwrap())
    }
}

impl SettingMeta {
    pub fn new<I: IntoSettingMeta + 'static>() -> Self {
        Self {
            name: I::name(),
            deserialize: Box::new(I::deserialize) as _,
            serialize: Box::new(I::serialize) as _,
        }
    }
}