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

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

use crate::{
    AnyFailure, AnyObject, AnyOperation, AnySetting, AnySuccess, AnyValue, GiteratedStack,
    ObjectOperationPair, ObjectSettingPair, ObjectValuePair, StackOperationState,
};

/// Stores runtime metadata for all in-use Giterated protocol types.
#[derive(Default)]
pub struct RuntimeMetadata {
    pub objects: HashMap<String, ObjectMeta>,
    pub operations: HashMap<ObjectOperationPair<'static>, OperationMeta>,
    pub values: HashMap<ObjectValuePair<'static>, ValueMeta>,
    pub settings: HashMap<ObjectSettingPair<'static>, SettingMeta>,
}

impl RuntimeMetadata {
    pub fn register_object<O: GiteratedObject + 'static>(&mut self) {
        let object_name = O::object_name().to_string();

        let object_meta = ObjectMeta::new::<O>();

        if self.objects.insert(object_name, object_meta).is_some() {
            trace!(
                "Registration of object {} overwrote previous registration.",
                O::object_name()
            );
        } else {
            trace!("Registration of object {}.", O::object_name())
        }
    }

    pub fn register_operation<O: GiteratedObject + 'static, D: GiteratedOperation<O> + 'static>(
        &mut self,
    ) {
        let _object_name = O::object_name().to_string();
        let _operation_name = D::operation_name().to_string();

        if self
            .operations
            .insert(
                ObjectOperationPair::from_types::<O, D>(),
                OperationMeta::new::<O, D>(),
            )
            .is_some()
        {
            trace!(
                "Registration of object operation {}<{}> overwrote previous registration.",
                D::operation_name(),
                O::object_name()
            );
        } else {
            trace!(
                "Registration of object operation {}<{}>.",
                D::operation_name(),
                O::object_name()
            )
        }
    }

    pub fn register_value<
        O: GiteratedObject + 'static,
        V: GiteratedObjectValue<Object = O> + 'static,
    >(
        &mut self,
    ) {
        if self
            .values
            .insert(ObjectValuePair::from_types::<O, V>(), ValueMeta::new::<V>())
            .is_some()
        {
            trace!(
                "Registration of value <{}>::{} overwrote previous registration.",
                O::object_name(),
                V::value_name()
            );
        } else {
            trace!(
                "Registration of value <{}>::{}.",
                O::object_name(),
                V::value_name()
            );
        }

        self.operations.insert(
            ObjectOperationPair::from_types::<O, GetValue>(),
            OperationMeta::new::<O, GetValue>(),
        );
    }

    pub fn register_setting<O: GiteratedObject + 'static, S: Setting + 'static + Clone>(&mut self) {
        if self
            .settings
            .insert(
                ObjectSettingPair::from_types::<O, S>(),
                SettingMeta::new::<O, S>(),
            )
            .is_some()
        {
            trace!(
                "Registration of setting {} overwrote previous registration.",
                S::name()
            );
        } else {
            trace!("Registration of setting {}.", S::name());
        }

        self.operations.insert(
            ObjectOperationPair::from_types::<O, SetSetting>(),
            OperationMeta::new::<O, SetSetting>(),
        );
    }

    pub fn append(&mut self, other: Self) {
        self.objects.extend(other.objects);
        self.operations.extend(other.operations);
        self.values.extend(other.values);
        self.settings.extend(other.settings);
    }
}

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

pub trait IntoValueMeta {
    fn name() -> String;
    fn deserialize(buffer: &[u8]) -> Result<AnyValue, serde_json::Error>;
    fn serialize(value: AnyValue) -> Result<Vec<u8>, serde_json::Error>;
    fn typed_get() -> Box<dyn Any + Send + Sync>;
    fn is_get_value_typed(typed_get_value: AnyOperation) -> 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<AnyValue, serde_json::Error> {
        Ok(AnyValue::new(serde_json::from_slice::<V>(buffer)?))
    }

    fn serialize(value: AnyValue) -> Result<Vec<u8>, serde_json::Error> {
        let value = value.downcast_ref::<V>().unwrap();

        serde_json::to_vec(&*value)
    }

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

    fn is_get_value_typed(typed_get_value: AnyOperation) -> 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 serialize: fn(AnyOperation) -> Result<Vec<u8>, serde_json::Error>,
    pub deserialize: fn(&[u8]) -> Result<AnyOperation, serde_json::Error>,
    pub any_is_same: fn(&dyn Any) -> bool,
    pub serialize_success: fn(AnySuccess) -> Result<Vec<u8>, serde_json::Error>,
    pub serialize_error: fn(AnyFailure) -> Result<Vec<u8>, serde_json::Error>,
    pub deserialize_success: fn(Vec<u8>) -> Result<AnySuccess, serde_json::Error>,
    pub deserialize_failure: fn(Vec<u8>) -> Result<AnyFailure, serde_json::Error>,
}

pub trait IntoOperationMeta<O> {
    fn name() -> String;
    fn deserialize(buffer: &[u8]) -> Result<AnyOperation, serde_json::Error>;
    fn serialize_success(success: AnySuccess) -> Result<Vec<u8>, serde_json::Error>;
    fn serialize_failure(failure: AnyFailure) -> Result<Vec<u8>, serde_json::Error>;
    fn deserialize_success(success: Vec<u8>) -> Result<AnySuccess, serde_json::Error>;
    fn deserialize_failure(failure: Vec<u8>) -> Result<AnyFailure, serde_json::Error>;
    fn any_is_same(other: &dyn Any) -> bool;
    fn serialize(operation: AnyOperation) -> Result<Vec<u8>, serde_json::Error>;
}

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

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

    fn serialize_success(success: AnySuccess) -> Result<Vec<u8>, serde_json::Error> {
        let to_serialize = success.0.downcast_ref::<D::Success>().unwrap();
        serde_json::to_vec(&to_serialize)
    }

    fn serialize_failure(failure: AnyFailure) -> Result<Vec<u8>, serde_json::Error> {
        let to_serialize = failure.0.downcast_ref::<D::Failure>().unwrap();
        serde_json::to_vec(&to_serialize)
    }

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

    fn serialize(operation: AnyOperation) -> Result<Vec<u8>, serde_json::Error> {
        let operation: &D = operation.downcast_ref().unwrap();

        serde_json::to_vec(operation)
    }

    fn deserialize_success(success: Vec<u8>) -> Result<AnySuccess, serde_json::Error> {
        let success: D::Success = serde_json::from_slice(&success)?;

        Ok(AnySuccess(Arc::new(success)))
    }

    fn deserialize_failure(failure: Vec<u8>) -> Result<AnyFailure, serde_json::Error> {
        let failure: D::Failure = serde_json::from_slice(&failure)?;

        Ok(AnyFailure(Arc::new(failure)))
    }
}

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,
            serialize: I::serialize,
            deserialize_success: I::deserialize_success,
            deserialize_failure: I::deserialize_failure,
        }
    }
}

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

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

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

    fn home_uri(object: AnyObject) -> String {
        let object: &O = object.downcast_ref().unwrap();

        object.home_uri()
    }
}

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

                Ok(AnyObject::new(object))
            }),
            to_str: Box::new(|source| {
                let object: &I = source.downcast_ref().unwrap();

                object.to_string()
            }),
            any_is_same: I::any_is_same,
            home_uri: <I as IntoObjectMeta>::home_uri,
        }
    }
}

pub struct SettingMeta {
    pub name: String,
    pub deserialize: fn(Value) -> Result<AnySetting, serde_json::Error>,
    pub serialize: fn(AnySetting) -> Result<Value, serde_json::Error>,
    pub setting_updated: for<'fut> fn(
        AnyObject,
        AnySetting,
        GiteratedStack<StackOperationState>,
        &StackOperationState,
    ) -> LocalBoxFuture<'_, ()>,
}

pub trait IntoSettingMeta<O> {
    fn name() -> String;
    fn deserialize(value: Value) -> Result<AnySetting, serde_json::Error>;
    fn serialize(setting: AnySetting) -> Result<Value, serde_json::Error>;
    fn setting_updated(
        object: AnyObject,
        setting: AnySetting,
        stack: GiteratedStack<StackOperationState>,
        operation_state: &StackOperationState,
    ) -> LocalBoxFuture<'_, ()>;
}

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

    fn deserialize(value: Value) -> Result<AnySetting, serde_json::Error> {
        Ok(AnySetting::new::<O, S>(serde_json::from_value::<S>(value)?))
    }

    fn serialize(setting: AnySetting) -> Result<Value, serde_json::Error> {
        serde_json::to_value(setting.downcast_ref::<S>().unwrap())
    }

    fn setting_updated(
        object: AnyObject,
        setting: AnySetting,
        stack: GiteratedStack<StackOperationState>,
        operation_state: &StackOperationState,
    ) -> LocalBoxFuture<'_, ()> {
        async move {
            stack
                .setting_update(
                    object.downcast_ref::<O>().unwrap().clone(),
                    setting.downcast_ref::<S>().unwrap().clone(),
                    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,
        }
    }
}