use std::{any::Any, sync::Arc};
pub mod handler_impl;
use futures_util::{future::LocalBoxFuture, Future, FutureExt};
use giterated_models::error::OperationError;

use crate::{
    AuthenticatedInstance, AuthenticatedUser, GiteratedStack, MissingValue, StackOperationState,
};

#[async_trait::async_trait(?Send)]
pub trait IntoGiteratedHandler<Params, AdditionalParams, State, OState, Output>
where
    // Output cannot have non-static references
    Output: 'static,
{
    type Future: Future<Output = Output>;

    async fn handle(&self, parameters: Params, state: State, operation_state: OState) -> Output;
}

pub struct HandlerTree<Kind> {
    elements: Vec<Kind>,
}

impl<Kind> Default for HandlerTree<Kind> {
    fn default() -> Self {
        Self {
            elements: Default::default(),
        }
    }
}

impl<'fut: 'o + 'p, 'p, 'o, P, O, E> HandlerTree<HandlerWrapper<P, O, E>>
where
    P: Clone,
{
    pub fn push(&mut self, handler: HandlerWrapper<P, O, E>) {
        self.elements.push(handler);
    }
    pub async fn handle(
        &self,
        parameters: P,
        operation_state: StackOperationState,
    ) -> Result<O, OperationError<E>> {
        for handler in self.elements.iter() {
            match handler
                .handle(parameters.clone(), operation_state.clone())
                .await
            {
                Ok(handled) => return Ok(handled),
                Err(err) => match err {
                    OperationError::Internal(err) => return Err(OperationError::Internal(err)),
                    OperationError::Operation(err) => return Err(OperationError::Operation(err)),
                    OperationError::Unhandled => continue,
                },
            }
        }

        Err(OperationError::Unhandled)
    }
}

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

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

        let handler_func = Arc::new(handler);
        let state_two = state.clone();
        HandlerWrapper {
            func: Arc::new(
                move |args: P,
                      state: Arc<dyn Any + Send + Sync>,
                      operation_state: StackOperationState| {
                    let handler = handler_func.clone();
                    let operation_state = operation_state.clone();
                    let state = state.downcast_ref::<S>().unwrap();
                    let state = state.clone();
                    async move {
                        let handler = handler.clone();
                        let operation_state = operation_state;
                        handler.handle(args, state, operation_state).await
                    }
                    .boxed_local()
                },
            ),
            state: state_two,
        }
    }

    pub async fn handle(
        &self,
        required: P,
        operation_state: StackOperationState,
    ) -> Result<O, OperationError<E>> {
        (self.func)(required, self.state.clone(), operation_state).await
    }

    pub fn map<F, N, R>(self, predicate: F) -> HandlerWrapper<N, O, R>
    where
        F: Fn(&N, &StackOperationState) -> Result<P, OperationError<R>> + Clone + Send + Sync,
        R: std::fmt::Debug + 'static,
        E: Into<OperationError<R>> + 'static,
        F: 'static,
        N: 'static,
        P: 'static,
        O: 'static,
    {
        let func = Arc::new(self.func);
        let predicate = Arc::new(predicate);
        HandlerWrapper {
            func: Arc::new(
                move |args: N,
                      state: Arc<dyn Any + Send + Sync>,
                      operation_state: StackOperationState| {
                    let predicate_output = predicate(&args, &operation_state);
                    let func = func.clone();
                    let operation_state: StackOperationState = operation_state.clone();
                    async move {
                        let predicate_output = predicate_output?;
                        let operation_state = operation_state;
                        match (func)(predicate_output, state, operation_state).await {
                            Ok(success) => Ok(success),
                            Err(_) => todo!(),
                        }
                    }
                    .boxed_local()
                },
            ),
            state: self.state,
        }
    }

    pub fn map_return<F, NR, NE>(self, predicate: F) -> HandlerWrapper<P, NR, NE>
    where
        F: Fn(Result<O, OperationError<E>>, &StackOperationState) -> Result<NR, OperationError<NE>>
            + Clone
            + Send
            + Sync,
        O: 'static,
        F: 'static,
        E: 'static,
        P: 'static,
    {
        let predicate = Arc::new(predicate);
        let func = self.func;
        HandlerWrapper {
            func: Arc::new(
                move |args: P,
                      state: Arc<dyn Any + Send + Sync>,
                      operation_state: StackOperationState| {
                    let clone = predicate.clone();
                    let func = func.clone();
                    let _statoperation_statee = operation_state.clone();

                    async move {
                        let func = func.clone();
                        let clone = clone;
                        let operation_state = operation_state;
                        clone(
                            (func)(args, state, operation_state.clone()).await,
                            &operation_state,
                        )
                    }
                    .boxed_local()
                },
            ),
            state: self.state,
        }
    }
}

#[async_trait::async_trait(?Send)]
pub trait HandlerResolvable<RequiredParameters, OperationState>: Sized {
    type Error;

    async fn from_handler_state(
        required_parameters: &RequiredParameters,
        operation_state: &OperationState,
    ) -> Result<Self, Self::Error>;
}

#[async_trait::async_trait(?Send)]
impl<R> HandlerResolvable<R, StackOperationState> for Arc<GiteratedStack> {
    type Error = MissingValue;

    async fn from_handler_state(
        _required_parameters: &R,
        operation_state: &StackOperationState,
    ) -> Result<Self, Self::Error> {
        Ok(operation_state.runtime.clone())
    }
}

#[async_trait::async_trait(?Send)]
impl<R> HandlerResolvable<R, StackOperationState> for AuthenticatedUser {
    type Error = MissingValue;

    async fn from_handler_state(
        _required_parameters: &R,
        operation_state: &StackOperationState,
    ) -> Result<Self, Self::Error> {
        operation_state.user.clone().ok_or_else(|| MissingValue)
    }
}

#[async_trait::async_trait(?Send)]
impl<R> HandlerResolvable<R, StackOperationState> for AuthenticatedInstance {
    type Error = MissingValue;

    async fn from_handler_state(
        _required_parameters: &R,
        operation_state: &StackOperationState,
    ) -> Result<Self, Self::Error> {
        operation_state.instance.clone().ok_or_else(|| MissingValue)
    }
}