pub mod handler;
pub mod runtime;
pub mod state;
pub mod update;

use std::{
    any::Any, collections::HashMap, future::Future, ops::Deref, pin::Pin, str::FromStr, sync::Arc,
};

use futures_util::FutureExt;
use giterated_models::{
    error::OperationError,
    instance::{
        AuthenticationTokenRequest, Instance, RegisterAccountRequest, RepositoryCreateRequest,
    },
    object::{
        AnyObject, GiteratedObject, Object, ObjectRequest, ObjectRequestError, ObjectResponse,
    },
    object_backend::ObjectBackend,
    operation::{AnyOperation, GiteratedOperation},
    repository::{AccessList, Repository},
    settings::{AnySetting, GetSetting, SetSetting, Setting},
    user::User,
    value::{AnyValue, GetValue, GiteratedObjectValue},
};
use handler::GiteratedBackend;
use serde::{de::DeserializeOwned, Serialize};
use serde_json::Value;
use state::HandlerState;
use tokio::{
    sync::{mpsc::channel, Mutex},
    task::JoinHandle,
};
use tracing::{error, warn};
use update::{
    HandleSettingUpdate, HandleSettingUpdatedFunction, HandleValueUpdate,
    HandleValueUpdatedFunction, SettingUpdateKind, ValueUpdateKind,
};

#[derive(Clone, Debug, Hash, Eq, PartialEq)]
struct ObjectOperationPair {
    object_name: String,
    operation_name: String,
}

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

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

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

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

pub struct OperationHandlers<S: Send + Sync + Clone> {
    operations: HashMap<ObjectOperationPair, OperationWrapper<S>>,
    get_object: Vec<OperationWrapper<S>>,
    value_getters: HashMap<ValueGetter, OperationWrapper<S>>,
    settings_getter: HashMap<String, OperationWrapper<S>>,
    settings: HashMap<String, SettingMeta>,
    objects: HashMap<String, ObjectMeta>,
    operations_meta: HashMap<ObjectOperationPair, OperationMeta>,
    value_updated: HashMap<ValueUpdateKind, HandleValueUpdatedFunction>,
    setting_updated: HashMap<SettingUpdateKind, HandleSettingUpdatedFunction>,
}

#[derive(Clone, Debug, Hash, Eq, PartialEq)]
pub struct ObjectValuePair {
    pub object_kind: String,
    pub value_kind: String,
}

impl<S: Send + Sync + Clone> Default for OperationHandlers<S> {
    fn default() -> Self {
        Self {
            operations: HashMap::new(),
            get_object: Vec::new(),
            value_updated: HashMap::default(),
            setting_updated: HashMap::default(),
            value_getters: HashMap::default(),
            settings_getter: HashMap::default(),
            settings: HashMap::default(),
            objects: HashMap::default(),
            operations_meta: HashMap::default(),
        }
    }
}

impl<S: Send + Sync + Clone + 'static> OperationHandlers<S> {
    fn insert_operation<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync + 'static>(
        &mut self,
    ) {
        // let object_name = O::object_name().to_string();
        // let operation_name = D::operation_name().to_string();

        // self.operations_meta.insert(
        //     ObjectOperationPair {
        //         object_name: object_name.clone(),
        //         operation_name: operation_name.clone(),
        //     },
        //     OperationMeta {
        //         name: operation_name,
        //         object_kind: object_name,
        //         deserialize: Box::new(|bytes| {
        //             Ok(Box::new(serde_json::from_slice::<D>(bytes).unwrap())
        //                 as Box<dyn Any + Send + Sync>)
        //         }),
        //         any_is_same: Box::new(|any_box| any_box.is::<D>()),
        //     },
        // );
    }

    pub fn setting<T: Setting>(&mut self) -> &mut Self {
        let setting_meta = SettingMeta {
            name: T::name().to_string(),
            deserialize: Box::new(|slice| {
                Ok(Box::new(serde_json::from_slice(slice)?) as Box<dyn Any>)
            }),
        };

        self.settings.insert(T::name().to_string(), setting_meta);

        self
    }

    pub fn insert<
        A,
        O: GiteratedObject + Send + Sync + 'static,
        D: GiteratedOperation<O> + Send + Sync + 'static,
        H: GiteratedOperationHandler<A, O, D, S> + Send + Sync + 'static + Clone,
    >(
        &mut self,
        handler: H,
    ) -> &mut Self {
        let object_name = handler.object_name().to_string();
        let operation_name = handler.operation_name().to_string();

        let wrapped = OperationWrapper::new(handler);

        let pair = ObjectOperationPair {
            object_name,
            operation_name,
        };

        assert!(self.operations.insert(pair, wrapped).is_none());

        self.insert_operation::<O, D>();

        self
    }

    pub fn object<O: GiteratedObject + Send + Sync + 'static>(&mut self) -> &mut Self {
        // let object_meta = ObjectMeta {
        //     name: O::object_name().to_string(),
        //     from_str: Box::new(|str| Ok(Box::new(O::from_str(&str).map_err(|_| ())?))),

        // };

        // self.objects
        //     .insert(O::object_name().to_string(), object_meta);

        let closure = |_: &Instance, operation: ObjectRequest, _state| {
            async move {
                if O::from_str(&operation.0).is_ok() {
                    Ok(ObjectResponse(operation.0))
                } else {
                    Err(OperationError::Unhandled)
                }
            }
            .boxed()
        };

        let wrapped = OperationWrapper::new(closure);

        self.get_object.push(wrapped);

        self
    }

    pub async fn handle<O: GiteratedObject>(
        &self,
        object: &O,
        operation_name: &str,
        operation: AnyOperation,
        state: S,
        operation_state: &StackOperationState,
    ) -> Result<Vec<u8>, OperationError<Vec<u8>>> {
        // TODO
        let object = object.to_string();
        let object_name = O::object_name().to_string();

        let object_meta = self
            .objects
            .get(&object_name)
            .ok_or_else(|| OperationError::Unhandled)?;

        let object_box = (object_meta.from_str)(&object).map_err(|_| OperationError::Unhandled)?;

        let target_handler = ObjectOperationPair {
            object_name,
            operation_name: operation_name.to_string(),
        };

        let operation_meta = self
            .operations_meta
            .get(&target_handler)
            .ok_or_else(|| OperationError::Unhandled)?;

        let operation_box =
            (operation_meta.deserialize)(&serde_json::to_vec(&operation.0).unwrap())
                .map_err(|_| OperationError::Unhandled)?;

        if let Some(handler) = self.operations.get(&target_handler) {
            handler
                .handle(object_box, operation_box, state.clone(), operation_state)
                .await
        } else {
            Err(OperationError::Unhandled)
        }
    }

    pub async fn resolve_object(
        &self,
        instance: Instance,
        request: ObjectRequest,
        state: S,
        operation_state: &StackOperationState,
    ) -> Result<Vec<u8>, OperationError<Vec<u8>>> {
        for handler in self.get_object.iter() {
            if let Ok(response) = handler
                .handle(
                    Box::new(instance.clone()) as _,
                    Box::new(request.clone()) as _,
                    state.clone(),
                    operation_state,
                )
                .await
            {
                return Ok(response);
            }
        }

        Err(OperationError::Unhandled)
    }

    pub fn insert_value_update_handler<
        H: HandleValueUpdate<O, V> + Send + Sync + Clone + 'static,
        O: GiteratedObject + Send + Sync,
        V: GiteratedObjectValue<Object = O> + Send + Sync,
    >(
        &mut self,
        handler: H,
    ) -> &mut Self {
        let wrapper = HandleValueUpdatedFunction::new(handler, V::value_name());

        assert!(self
            .value_updated
            .insert(wrapper.target.clone(), wrapper)
            .is_none());

        self
    }

    pub fn insert_setting_update_handler<
        H: HandleSettingUpdate<O, T> + Send + Sync + Clone + 'static,
        O: GiteratedObject + Send + Sync,
        T: Setting + Send + Sync,
    >(
        &mut self,
        handler: H,
    ) -> &mut Self {
        let wrapper = HandleSettingUpdatedFunction::new(handler, T::name());

        assert!(self
            .setting_updated
            .insert(wrapper.target.clone(), wrapper)
            .is_none());

        self
    }

    pub fn value_getter<A, O, V, F>(&mut self, handler: F) -> &mut Self
    where
        O: GiteratedObject + Send + Sync + 'static,
        V: GiteratedObjectValue<Object = O> + Send + Sync + 'static,
        F: GiteratedOperationHandler<A, O, GetValue<V>, S> + Send + Sync + Clone + 'static,
    {
        let object_name = handler.object_name().to_string();
        let value_name = V::value_name().to_string();

        let wrapped = OperationWrapper::new(handler);

        assert!(self
            .value_getters
            .insert(
                ValueGetter {
                    object_type: object_name,
                    value_type: value_name
                },
                wrapped
            )
            .is_none());

        self
    }

    pub fn setting_getter<A, O, F>(&mut self, handler: F) -> &mut Self
    where
        O: GiteratedObject + Send + Sync + 'static,
        F: GiteratedOperationHandler<A, O, GetSetting, S> + Send + Sync + Clone + 'static,
    {
        let object_name = handler.object_name().to_string();

        let wrapped = OperationWrapper::new(handler);

        assert!(self.settings_getter.insert(object_name, wrapped).is_none());

        self
    }
}

#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub struct ValueGetter {
    pub object_type: String,
    pub value_type: String,
}

impl Default for ValueGetter {
    fn default() -> Self {
        Self {
            object_type: AnyObject::object_name().to_string(),
            value_type: "any".to_string(),
        }
    }
}

#[async_trait::async_trait]
pub trait GiteratedOperationHandler<
    L,
    O: GiteratedObject,
    D: GiteratedOperation<O>,
    S: Send + Sync + Clone,
>: Send + Sync
{
    fn operation_name(&self) -> &str;
    fn object_name(&self) -> &str;

    async fn handle(
        &self,
        object: &O,
        operation: D,
        state: S,
        operation_state: &StackOperationState,
    ) -> Result<D::Success, OperationError<D::Failure>>;
}

#[async_trait::async_trait]
impl<O, D, F, S> GiteratedOperationHandler<(), O, D, S> for F
where
    F: FnMut(
            &O,
            D,
            S,
        ) -> Pin<
            Box<dyn Future<Output = Result<D::Success, OperationError<D::Failure>>> + Send>,
        > + Send
        + Sync
        + Clone,
    O: GiteratedObject + Send + Sync,
    D: GiteratedOperation<O> + 'static,
    <D as GiteratedOperation<O>>::Failure: Send,
    S: Send + Sync + Clone + 'static,
{
    fn operation_name(&self) -> &str {
        D::operation_name()
    }

    fn object_name(&self) -> &str {
        O::object_name()
    }

    async fn handle(
        &self,
        object: &O,
        operation: D,
        state: S,
        _operation_state: &StackOperationState,
    ) -> Result<D::Success, OperationError<D::Failure>> {
        self.clone()(object, operation, state).await
    }
}

#[async_trait::async_trait]
impl<O, O1, D, F, S> GiteratedOperationHandler<(O1,), O, D, S> for F
where
    F: FnMut(
            &O,
            D,
            S,
            O1,
        ) -> Pin<
            Box<dyn Future<Output = Result<D::Success, OperationError<D::Failure>>> + Send>,
        > + Send
        + Sync
        + Clone,
    O: GiteratedObject + Send + Sync,
    D: GiteratedOperation<O> + 'static + Send + Sync,
    <D as GiteratedOperation<O>>::Failure: Send,
    S: Send + Sync + Clone + 'static,
    O1: FromOperationState<O, D>,
{
    fn operation_name(&self) -> &str {
        D::operation_name()
    }

    fn object_name(&self) -> &str {
        O::object_name()
    }

    async fn handle(
        &self,
        object: &O,
        operation: D,
        state: S,
        operation_state: &StackOperationState,
    ) -> Result<D::Success, OperationError<D::Failure>> {
        let o1 = O1::from_state(object, &operation, operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;
        self.clone()(object, operation, state, o1).await
    }
}

#[async_trait::async_trait]
impl<O, O1, O2, D, F, S> GiteratedOperationHandler<(O1, O2), O, D, S> for F
where
    F: FnMut(
            &O,
            D,
            S,
            O1,
            O2,
        ) -> Pin<
            Box<dyn Future<Output = Result<D::Success, OperationError<D::Failure>>> + Send>,
        > + Send
        + Sync
        + Clone,
    O: GiteratedObject + Send + Sync,
    D: GiteratedOperation<O> + 'static + Send + Sync,
    <D as GiteratedOperation<O>>::Failure: Send,
    S: Send + Sync + Clone + 'static,
    O1: FromOperationState<O, D>,
    O2: FromOperationState<O, D>,
{
    fn operation_name(&self) -> &str {
        D::operation_name()
    }

    fn object_name(&self) -> &str {
        O::object_name()
    }

    async fn handle(
        &self,
        object: &O,
        operation: D,
        state: S,
        operation_state: &StackOperationState,
    ) -> Result<D::Success, OperationError<D::Failure>> {
        let o1 = O1::from_state(object, &operation, operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;
        let o2 = O2::from_state(object, &operation, operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;
        self.clone()(object, operation, state, o1, o2).await
    }
}

#[async_trait::async_trait]
impl<O, O1, O2, O3, D, F, S> GiteratedOperationHandler<(O1, O2, O3), O, D, S> for F
where
    F: FnMut(
            &O,
            D,
            S,
            O1,
            O2,
            O3,
        ) -> Pin<
            Box<dyn Future<Output = Result<D::Success, OperationError<D::Failure>>> + Send>,
        > + Send
        + Sync
        + Clone,
    O: GiteratedObject + Send + Sync,
    D: GiteratedOperation<O> + 'static + Send + Sync,
    <D as GiteratedOperation<O>>::Failure: Send,
    S: Send + Sync + Clone + 'static,
    O1: FromOperationState<O, D>,
    O2: FromOperationState<O, D>,
    O3: FromOperationState<O, D>,
{
    fn operation_name(&self) -> &str {
        D::operation_name()
    }

    fn object_name(&self) -> &str {
        O::object_name()
    }

    async fn handle(
        &self,
        object: &O,
        operation: D,
        state: S,
        operation_state: &StackOperationState,
    ) -> Result<D::Success, OperationError<D::Failure>> {
        let o1 = O1::from_state(object, &operation, operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;
        let o2 = O2::from_state(object, &operation, operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;
        let o3 = O3::from_state(object, &operation, operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;
        self.clone()(object, operation, state, o1, o2, o3).await
    }
}

pub struct OperationWrapper<S: Send + Sync + Clone> {
    func: Box<
        dyn Fn(
                Box<dyn Any + Send + Sync>,
                Box<dyn Any + Send + Sync>,
                S,
                StackOperationState,
            )
                -> Pin<Box<dyn Future<Output = Result<Vec<u8>, OperationError<Vec<u8>>>> + Send>>
            + Send
            + Sync,
    >,
    object_name: String,
}

impl<S: Send + Sync + Clone + 'static> OperationWrapper<S> {
    pub fn new<
        A,
        O: GiteratedObject + Send + Sync + 'static,
        D: GiteratedOperation<O> + 'static,
        F: GiteratedOperationHandler<A, O, D, S> + Send + Sync + 'static + Clone,
    >(
        handler: F,
    ) -> Self {
        let handler = Arc::new(Box::pin(handler));
        Self {
            func: Box::new(move |object, operation, state, operation_state| {
                let handler = handler.clone();
                async move {
                    let handler = handler.clone();
                    let object: Box<O> = object.downcast().unwrap();
                    let operation: Box<D> = operation.downcast().unwrap();

                    let result = handler
                        .handle(&object, *operation, state, &operation_state)
                        .await;
                    result
                        .map(|success| serde_json::to_vec(&success).unwrap())
                        .map_err(|err| match err {
                            OperationError::Operation(err) => {
                                OperationError::Operation(serde_json::to_vec(&err).unwrap())
                            }
                            OperationError::Internal(internal) => {
                                OperationError::Internal(internal)
                            }
                            OperationError::Unhandled => OperationError::Unhandled,
                        })
                }
                .boxed()
            }),
            object_name: O::object_name().to_string(),
        }
    }

    async fn handle(
        &self,
        object: Box<dyn Any + Send + Sync>,
        operation: Box<dyn Any + Send + Sync>,
        state: S,
        operation_state: &StackOperationState,
    ) -> Result<Vec<u8>, OperationError<Vec<u8>>> {
        (self.func)(object, operation, state, operation_state.clone()).await
    }
}

#[async_trait::async_trait]
pub trait FromOperationState<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync>:
    Sized + Clone + Send
{
    type Error: Serialize + DeserializeOwned;

    async fn from_state(
        object: &O,
        operation: &D,
        state: &StackOperationState,
    ) -> Result<Self, OperationError<Self::Error>>;
}

#[async_trait::async_trait]
impl<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync> FromOperationState<O, D>
    for BackendWrapper
{
    type Error = ();

    async fn from_state(
        _object: &O,
        _operation: &D,
        state: &StackOperationState,
    ) -> Result<Self, OperationError<()>> {
        Ok(state.giterated_backend.clone())
    }
}

#[async_trait::async_trait]
impl<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync> FromOperationState<O, D>
    for StackOperationState
{
    type Error = ();

    async fn from_state(
        _object: &O,
        _operation: &D,
        state: &StackOperationState,
    ) -> Result<StackOperationState, OperationError<()>> {
        Ok(state.clone())
    }
}

#[async_trait::async_trait]
impl<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync> FromOperationState<O, D>
    for AuthenticatedUser
{
    type Error = ();

    async fn from_state(
        _object: &O,
        _operation: &D,
        state: &StackOperationState,
    ) -> Result<AuthenticatedUser, OperationError<()>> {
        state
            .user
            .clone()
            .ok_or_else(|| OperationError::Operation(()))
    }
}

#[async_trait::async_trait]
impl<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync> FromOperationState<O, D>
    for AuthenticatedInstance
{
    type Error = ();

    async fn from_state(
        _object: &O,
        _operation: &D,
        state: &StackOperationState,
    ) -> Result<AuthenticatedInstance, OperationError<()>> {
        state
            .instance
            .clone()
            .ok_or_else(|| OperationError::Operation(()))
    }
}

#[async_trait::async_trait]
impl<
        T: FromOperationState<O, D> + Send + Sync,
        O: GiteratedObject + Sync,
        D: GiteratedOperation<O> + Send + Sync,
    > FromOperationState<O, D> for Option<T>
{
    type Error = ();

    async fn from_state(
        object: &O,
        operation: &D,
        state: &StackOperationState,
    ) -> Result<Option<T>, OperationError<()>> {
        Ok(T::from_state(object, operation, state).await.ok())
    }
}

#[derive(Clone)]
pub struct AuthorizedUser(AuthenticatedUser);

#[derive(Clone)]
pub struct AuthorizedInstance(AuthenticatedInstance);

#[async_trait::async_trait]
pub trait AuthorizedOperation<O: GiteratedObject>: GiteratedOperation<O> {
    async fn authorize(
        &self,
        authorize_for: &O,
        state: &StackOperationState,
    ) -> Result<bool, OperationError<()>>;
}

#[async_trait::async_trait]
impl<
        O: GiteratedObject + Send + Sync + Debug,
        V: GiteratedObjectValue<Object = O> + Send + Sync,
    > AuthorizedOperation<O> for GetValue<V>
{
    async fn authorize(
        &self,
        authorize_for: &O,
        operation_state: &StackOperationState,
    ) -> Result<bool, OperationError<()>> {
        Ok(operation_state
            .giterated_backend
            .get_object::<O>(&authorize_for.to_string(), operation_state)
            .await
            .is_ok())
    }
}

#[async_trait::async_trait]
impl AuthorizedOperation<User> for SetSetting {
    async fn authorize(
        &self,
        authorize_for: &User,
        operation_state: &StackOperationState,
    ) -> Result<bool, OperationError<()>> {
        let authenticated_user = operation_state
            .user
            .as_ref()
            .ok_or_else(|| OperationError::Operation(()))?;

        Ok(authorize_for == authenticated_user.deref())
    }
}

#[async_trait::async_trait]
impl AuthorizedOperation<User> for GetSetting {
    async fn authorize(
        &self,
        authorize_for: &User,
        operation_state: &StackOperationState,
    ) -> Result<bool, OperationError<()>> {
        let authenticated_user = operation_state
            .user
            .as_ref()
            .ok_or_else(|| OperationError::Operation(()))?;

        Ok(authorize_for == authenticated_user.deref())
    }
}

#[async_trait::async_trait]
impl AuthorizedOperation<Repository> for SetSetting {
    async fn authorize(
        &self,
        authorize_for: &Repository,
        operation_state: &StackOperationState,
    ) -> Result<bool, OperationError<()>> {
        let authenticated_user = operation_state
            .user
            .as_ref()
            .ok_or_else(|| OperationError::Operation(()))?;

        let mut object = operation_state
            .giterated_backend
            .get_object::<Repository>(&authorize_for.to_string(), operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;

        let access_list = object
            .get_setting::<AccessList>(operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;

        if access_list
            .0
            .iter()
            .find(|user| *user == authenticated_user.deref())
            .is_some()
        {
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

#[async_trait::async_trait]
impl AuthorizedOperation<Repository> for GetSetting {
    async fn authorize(
        &self,
        authorize_for: &Repository,
        operation_state: &StackOperationState,
    ) -> Result<bool, OperationError<()>> {
        let authenticated_user = operation_state
            .user
            .as_ref()
            .ok_or_else(|| OperationError::Operation(()))?;

        let mut object = operation_state
            .giterated_backend
            .get_object::<Repository>(&authorize_for.to_string(), operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;

        let access_list = object
            .get_setting::<AccessList>(operation_state)
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;

        if access_list
            .0
            .iter()
            .find(|user| *user == authenticated_user.deref())
            .is_some()
        {
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

#[async_trait::async_trait]
impl AuthorizedOperation<Instance> for RegisterAccountRequest {
    async fn authorize(
        &self,
        authorize_for: &Instance,
        state: &StackOperationState,
    ) -> Result<bool, OperationError<()>> {
        if state.our_instance == *authorize_for {
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

#[async_trait::async_trait]
impl AuthorizedOperation<Instance> for AuthenticationTokenRequest {
    async fn authorize(
        &self,
        authorize_for: &Instance,
        state: &StackOperationState,
    ) -> Result<bool, OperationError<()>> {
        if state.our_instance == *authorize_for {
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

#[async_trait::async_trait]
impl AuthorizedOperation<Instance> for RepositoryCreateRequest {
    async fn authorize(
        &self,
        authorize_for: &Instance,
        state: &StackOperationState,
    ) -> Result<bool, OperationError<()>> {
        if state.our_instance == *authorize_for {
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

#[async_trait::async_trait]
impl<A: AuthorizedOperation<User> + Send + Sync> FromOperationState<User, A> for AuthorizedUser {
    type Error = ();

    async fn from_state(
        object: &User,
        operation: &A,
        state: &StackOperationState,
    ) -> Result<AuthorizedUser, OperationError<()>> {
        let authenticated = AuthenticatedUser::from_state(object, operation, state).await?;

        match operation.authorize(object, state).await {
            Ok(authorized) => {
                assert!(authorized);
            }
            Err(err) => return Err(OperationError::Internal(err.to_string())),
        };

        Ok(AuthorizedUser(authenticated))
    }
}

#[async_trait::async_trait]
impl<A: AuthorizedOperation<Instance> + Send + Sync> FromOperationState<Instance, A>
    for AuthorizedInstance
{
    type Error = ();

    async fn from_state(
        object: &Instance,
        operation: &A,
        state: &StackOperationState,
    ) -> Result<AuthorizedInstance, OperationError<()>> {
        let authenticated = AuthenticatedInstance::from_state(object, operation, state).await?;

        match operation.authorize(object, state).await {
            Ok(authorized) => {
                assert!(authorized);
            }
            Err(err) => return Err(OperationError::Internal(err.to_string())),
        };

        Ok(AuthorizedInstance(authenticated))
    }
}

// #[async_trait::async_trait> FromOperationState for Option<T> {
//     type Error = ();

//     async fn from_state(state: &StackOperationState) -> Result<Option<T>, OperationError<()>> {
//         Ok(T::from_state(]
// impl<T: FromOperationStatestate).await.ok())
//     }
// }

#[derive(Clone)]
pub struct StackOperationState {
    pub our_instance: Instance,
    pub giterated_backend: BackendWrapper,
    pub instance: Option<AuthenticatedInstance>,
    pub user: Option<AuthenticatedUser>,
}

#[derive(Clone, Debug)]
pub struct AuthenticatedInstance(Instance);

impl AuthenticatedInstance {
    pub fn new(instance: Instance) -> Self {
        AuthenticatedInstance(instance)
    }
}

impl Deref for AuthenticatedInstance {
    type Target = Instance;

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

#[derive(Clone, Debug)]
pub struct AuthenticatedUser(User);

impl AuthenticatedUser {
    pub fn new(user: User) -> Self {
        AuthenticatedUser(user)
    }
}

impl Deref for AuthenticatedUser {
    type Target = User;

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

#[derive(Clone)]
pub struct BackendWrapper {
    sender: tokio::sync::mpsc::Sender<(
        tokio::sync::oneshot::Sender<Result<Value, OperationError<Value>>>,
        WrappedOperation,
    )>,
    task: Arc<JoinHandle<()>>,
}

pub struct WrappedOperation {
    object: AnyObject,
    operation_payload: AnyOperation,
    operation_name: String,
    state: StackOperationState,
}

impl BackendWrapper {
    pub fn new<S: HandlerState>(backend: GiteratedBackend<S>) -> Self {
        // Spawn listener task

        let (send, mut recv) = channel::<(
            tokio::sync::oneshot::Sender<Result<Value, OperationError<Value>>>,
            WrappedOperation,
        )>(1024);

        let task = tokio::spawn(async move {
            while let Some((responder, message)) = recv.recv().await {
                let raw_result = backend
                    .object_operation(
                        message.object,
                        &message.operation_name,
                        message.operation_payload,
                        &message.state,
                    )
                    .await;

                responder.send(raw_result).unwrap();
            }
            error!("Error, thing's dead");
        });

        Self {
            sender: send,
            task: Arc::new(task),
        }
    }

    pub async fn call(&self, operation: WrappedOperation) -> Result<Value, OperationError<Value>> {
        let (sender, response) = tokio::sync::oneshot::channel();

        self.sender
            .send((sender, operation))
            .await
            .map_err(|e| OperationError::Internal(e.to_string()))?;

        match response.await {
            Ok(result) => Ok(result?),
            Err(err) => Err(OperationError::Internal(err.to_string())),
        }
    }
}

use std::fmt::Debug;

#[async_trait::async_trait]
impl ObjectBackend<StackOperationState> for BackendWrapper {
    async fn object_operation<O, D>(
        &self,
        object: O,
        operation: &str,
        payload: D,
        operation_state: &StackOperationState,
    ) -> Result<D::Success, OperationError<D::Failure>>
    where
        O: GiteratedObject + Debug,
        D: GiteratedOperation<O> + Debug,
    {
        let operation = WrappedOperation {
            object: AnyObject(object.to_string()),
            operation_name: operation.to_string(),
            operation_payload: AnyOperation(serde_json::to_value(payload).unwrap()),
            state: operation_state.clone(),
        };

        let raw_result = self.call(operation).await;

        match raw_result {
            Ok(result) => Ok(serde_json::from_value(result)
                .map_err(|e| OperationError::Internal(e.to_string()))?),
            Err(err) => match err {
                OperationError::Internal(internal) => {
                    warn!(
                        "Internal Error: {:?}",
                        OperationError::<()>::Internal(internal.clone())
                    );

                    Err(OperationError::Internal(internal))
                }
                OperationError::Unhandled => Err(OperationError::Unhandled),
                OperationError::Operation(err) => Err(OperationError::Operation(
                    serde_json::from_value(err)
                        .map_err(|e| OperationError::Internal(e.to_string()))?,
                )),
            },
        }
    }

    async fn get_object<O: GiteratedObject + Debug>(
        &self,
        object_str: &str,
        operation_state: &StackOperationState,
    ) -> Result<Object<StackOperationState, O, Self>, OperationError<ObjectRequestError>> {
        let operation = WrappedOperation {
            object: AnyObject(object_str.to_string()),
            operation_name: ObjectRequest::operation_name().to_string(),
            operation_payload: AnyOperation(
                serde_json::to_value(ObjectRequest(object_str.to_string())).unwrap(),
            ),
            state: operation_state.clone(),
        };

        let raw_result = self.call(operation).await;

        let object: ObjectResponse = match raw_result {
            Ok(result) => Ok(serde_json::from_value(result)
                .map_err(|e| OperationError::Internal(e.to_string()))?),
            Err(err) => match err {
                OperationError::Internal(internal) => {
                    warn!(
                        "Internal Error: {:?}",
                        OperationError::<()>::Internal(internal.clone())
                    );

                    Err(OperationError::Internal(internal))
                }
                OperationError::Unhandled => Err(OperationError::Unhandled),
                OperationError::Operation(err) => Err(OperationError::Operation(
                    serde_json::from_value(err)
                        .map_err(|e| OperationError::Internal(e.to_string()))?,
                )),
            },
        }?;

        unsafe {
            Ok(Object::new_unchecked(
                O::from_str(&object.0)
                    .map_err(|_| OperationError::Internal("deserialize failure".to_string()))?,
                self.clone(),
            ))
        }
    }
}