// use std::{any::Any, pin::Pin, process::Output, sync::Arc};

// use futures_util::{future::LocalBoxFuture, Future, FutureExt};
// use giterated_models::{
//     error::{ExtractorError, OperationError, RepositoryError},
//     object::GiteratedObject,
//     operation::GiteratedOperation,
//     repository::{Repository, RepositoryBranch, RepositoryBranchesRequest},
//     settings::SetSetting,
//     user::{DisplayName, User},
//     value::{GetValue, GiteratedObjectValue},
// };
// use giterated_stack::{
//     AuthorizedUser, FromOperationState, GiteratedStack, MissingValue, StackOperationState,
// };

// use crate::CacheSubstack;

// async fn value_update(
//     object: AnyObject<'_>,
//     value: AnyValue<'_>,
//     cache: CacheSubstack,
//     stack: Arc<GiteratedStack>,
// ) -> Result<(), anyhow::Error> {
//     todo!()
// }

// pub struct AnyObject<'o>(&'o (dyn Any + Send + Sync));

// pub struct AnyValue<'v>(&'v (dyn Any + Send + Sync));

// #[async_trait::async_trait(?Send)]
// pub trait GiteratedHandler<RequiredParameters, AdditionalParameters, State, OperationState, Output>
// {
//     async fn handle(
//         &self,
//         parameters: RequiredParameters,
//         additional_parameters: AdditionalParameters,
//         state: Arc<State>,
//         operation_state: &OperationState,
//     ) -> Output;
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, S, O, Output, F, Fut> GiteratedHandler<(R1,), (), S, O, Output> for F
// where
//     F: FnMut(R1, S, &O) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
// {
//     async fn handle(
//         &self,
//         parameters: (R1,),
//         additional_parameters: (),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, A1, S, O, Output, F, Fut> GiteratedHandler<(R1,), (A1,), S, O, Output> for F
// where
//     F: FnMut(R1, S, &O, A1) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
//     A1: 'static + HandlerResolvable<(R1,), O, A1>,
// {
//     async fn handle(
//         &self,
//         parameters: (R1,),
//         additional_parameters: (A1,),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, A1, A2, S, O, Output, F, Fut> GiteratedHandler<(R1,), (A1, A2), S, O, Output> for F
// where
//     F: FnMut(R1, S, &O, A1, A2) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
//     A1: 'static + HandlerResolvable<(R1,), O, A1>,
//     A2: 'static + HandlerResolvable<(R1,), O, A2>,
// {
//     async fn handle(
//         &self,
//         parameters: (R1,),
//         additional_parameters: (A1, A2),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, A1, A2, A3, S, O, Output, F, Fut> GiteratedHandler<(R1,), (A1, A2, A3), S, O, Output> for F
// where
//     F: FnMut(R1, S, &O, A1, A2, A3) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
//     A1: 'static + HandlerResolvable<(R1,), O, A1>,
//     A2: 'static + HandlerResolvable<(R1,), O, A2>,
//     A3: 'static + HandlerResolvable<(R1,), O, A3>,
// {
//     async fn handle(
//         &self,
//         parameters: (R1,),
//         additional_parameters: (A1, A2, A3),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, R2, S, O, Output, F, Fut> GiteratedHandler<(R1, R2), (), S, O, Output> for F
// where
//     F: FnMut(R1, R2, S, &O) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
//     R2: 'static,
// {
//     async fn handle(
//         &self,
//         parameters: (R1, R2),
//         additional_parameters: (),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, R2, A1, S, O, Output, F, Fut> GiteratedHandler<(R1, R2), (A1,), S, O, Output> for F
// where
//     F: FnMut(R1, R2, S, &O, A1) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
//     R2: 'static,
//     A1: 'static + HandlerResolvable<(R1, R2), O, A1>,
// {
//     async fn handle(
//         &self,
//         parameters: (R1, R2),
//         additional_parameters: (A1,),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, R2, A1, A2, S, O, Output, F, Fut> GiteratedHandler<(R1, R2), (A1, A2), S, O, Output> for F
// where
//     F: FnMut(R1, R2, S, &O, A1, A2) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
//     R2: 'static,
//     A1: 'static + HandlerResolvable<(R1, R2), O, A1>,
//     A2: 'static + HandlerResolvable<(R1, R2), O, A2>,
// {
//     async fn handle(
//         &self,
//         parameters: (R1, R2),
//         additional_parameters: (A1, A2),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, R2, A1, A2, A3, S, O, Output, F, Fut>
//     GiteratedHandler<(R1, R2), (A1, A2, A3), S, O, Output> for F
// where
//     F: FnMut(R1, R2, S, &O, A1, A2, A3) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
//     R2: 'static,
//     A1: 'static + HandlerResolvable<(R1, R2), O, A1>,
//     A2: 'static + HandlerResolvable<(R1, R2), O, A2>,
//     A3: 'static + HandlerResolvable<(R1, R2), O, A3>,
// {
//     async fn handle(
//         &self,
//         parameters: (R1, R2),
//         additional_parameters: (A1, A2, A3),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<R1, R2, R3, S, O, Output, F, Fut> GiteratedHandler<(R1, R2, R3), (), S, O, Output> for F
// where
//     F: FnMut(R1, R2, R3, S, &O) -> Fut,
//     Fut: Future<Output = Output>,
//     S: 'static,
//     R1: 'static,
//     R2: 'static,
//     R3: 'static,
// {
//     async fn handle(
//         &self,
//         parameters: (R1, R2, R3),
//         additional_parameters: (),
//         state: Arc<S>,
//         operation_state: &O,
//     ) -> Output {
//         todo!()
//     }
// }

// fn test_fn<O, A, S, V, F>(handler: F)
// where
//     F: GiteratedHandler<(O, V), A, S, StackOperationState, Result<(), anyhow::Error>>,
//     O: GiteratedObject,
//     V: GiteratedObjectValue<Object = O>,
// {
// }

// fn other_fn() {
//     let a = String::from("a");
//     let test = move |object: User,
//                      value: GetValue,
//                      state: (),
//                      operation_state: &StackOperationState,
//                      authorized_user: AuthorizedUser| { async move { () } };

//     let wrapper = HandlerWrapper::<(User, GetValue), _>::new((), test);
// }

// pub struct HandlerWrapper<P, O> {
//     func: Box<dyn Fn(P, StackOperationState) -> LocalBoxFuture<'static, O>>,
//     state: Arc<dyn Any + Send + Sync>,
// }

// impl<P, O> HandlerWrapper<P, O> {
//     pub fn new<S, F, A>(state: S, handler: F) -> Self
//     where
//         F: GiteratedHandler<P, A, S, StackOperationState, O>,
//         S: Send + Sync + 'static,
//         A: HandlerResolvableGroup<P>,
//     {
//         let state = Arc::new(state);

//         let func = |required: P, operation_state: StackOperationState| {
//             // async move { handler.handle(required, (), state, &operation_state) }.boxed_local()
//             todo!()
//         };

//         Self {
//             func: Box::new(func),
//             state,
//         }
//     }
// }

// #[async_trait::async_trait(?Send)]
// pub trait HandlerResolvable<RequiredParameters, OperationState, Output> {
//     async fn from_handler_state(
//         required_parameters: &RequiredParameters,
//         operation_state: &OperationState,
//     ) -> Output;
// }

// #[async_trait::async_trait(?Send)]
// impl HandlerResolvable<(User, GetValue), StackOperationState, Self> for Arc<GiteratedStack> {
//     async fn from_handler_state(
//         required_parameters: &(User, GetValue),
//         operation_state: &StackOperationState,
//     ) -> Self {
//         todo!()
//     }
// }

// // #[async_trait::async_trait(?Send)]
// // impl<O, D, T> HandlerResolvable<(O, D), StackOperationState, T> for T
// // where
// //     O: GiteratedObject,
// //     D: GiteratedOperation<O>,
// //     T: FromOperationState<O, D>,
// // {
// //     async fn from_handler_state(
// //         required_parameters: &(O, D),
// //         operation_state: &StackOperationState,
// //     ) -> T {
// //         todo!()
// //     }
// // }

// #[async_trait::async_trait(?Send)]
// pub trait HandlerResolvableGroup<RequiredParameters> {
//     async fn group_from_handler_state(
//         required_parameters: &RequiredParameters,
//         operation_state: &StackOperationState,
//     ) -> Self;
// }

// #[async_trait::async_trait(?Send)]
// impl<RequiredParameters, A1> HandlerResolvableGroup<RequiredParameters> for (A1,)
// where
//     A1: HandlerResolvable<RequiredParameters, StackOperationState, A1>,
// {
//     async fn group_from_handler_state(
//         required_parameters: &RequiredParameters,
//         operation_state: &StackOperationState,
//     ) -> (A1,) {
//         (A1::from_handler_state(required_parameters, operation_state).await,)
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl<RequiredParameters, A1, A2> HandlerResolvableGroup<RequiredParameters> for (A1, A2)
// where
//     A1: HandlerResolvable<RequiredParameters, StackOperationState, A1>,
//     A2: HandlerResolvable<RequiredParameters, StackOperationState, A2>,
// {
//     async fn group_from_handler_state(
//         required_parameters: &RequiredParameters,
//         operation_state: &StackOperationState,
//     ) -> (A1, A2) {
//         (
//             A1::from_handler_state(required_parameters, operation_state).await,
//             A2::from_handler_state(required_parameters, operation_state).await,
//         )
//     }
// }