use std::{collections::HashMap, sync::Arc};

use futures_util::FutureExt;
use giterated_models::{
    error::OperationError,
    instance::Instance,
    object::{GiteratedObject, ObjectRequest, ObjectResponse},
    operation::GiteratedOperation,
    settings::Setting,
    value::GiteratedObjectValue,
};
use tracing::{info, trace};

use crate::{
    handler::HandlerWrapper, provider::MetadataProvider, AnyFailure, AnyObject, AnyOperation,
    AnySetting, AnySuccess, AnyValue, GiteratedStack, GiteratedStackState, IntoGiteratedHandler,
    ObjectOperationPair, ObjectSettingPair, ObjectValuePair, OperationHandler, RuntimeMetadata,
    SettingChange, SettingGetter, StackOperationState, ValueChange, ValueGetter,
};

pub struct SubstackBuilder<S: GiteratedStackState> {
    pub(crate) operation_handlers: HashMap<ObjectOperationPair<'static>, OperationHandler>,
    pub(crate) value_getters: HashMap<ObjectValuePair<'static>, ValueGetter>,
    pub(crate) setting_getters: HashMap<&'static str, SettingGetter>,
    pub(crate) metadata: RuntimeMetadata,
    pub(crate) value_change: HashMap<ObjectValuePair<'static>, ValueChange>,
    pub(crate) metadata_providers: Vec<Box<dyn MetadataProvider>>,
    pub(crate) setting_change: HashMap<ObjectSettingPair<'static>, SettingChange>,

    pub(crate) state: S,
}

impl<S: GiteratedStackState + 'static> SubstackBuilder<S> {
    pub fn new(state: S) -> Self {
        Self {
            operation_handlers: Default::default(),
            value_getters: Default::default(),
            setting_getters: Default::default(),
            metadata: Default::default(),
            value_change: Default::default(),
            metadata_providers: Default::default(),
            setting_change: Default::default(),
            state,
        }
    }
}

impl<S: Send + Sync + Clone + 'static> SubstackBuilder<S> {
    /// Insert an operation handler into the runtime builder.
    ///
    /// # Type Registration
    /// Inserting the handler will automatically, if required, register the operation type of the
    /// handler. It will **not** register the object type automatically.
    pub fn operation<O, D, A, H>(&mut self, handler: H) -> &mut Self
    where
        O: GiteratedObject + Clone,
        D: GiteratedOperation<O> + Clone,
        H: IntoGiteratedHandler<
                (O, D),
                A,
                S,
                StackOperationState,
                Result<D::Success, OperationError<D::Failure>>,
            > + Send
            + Sync
            + 'static,
        O: 'static,
        D: 'static,
        D::Failure: std::fmt::Debug + 'static,
        D::Success: 'static,
    {
        let wrapped = HandlerWrapper::new(self.state.clone(), handler);

        let wrapped = wrapped.map(
            |(any_object, any_operation): &(AnyObject, AnyOperation),
             _state: &StackOperationState| {
                Ok((
                    any_object.0.downcast_ref::<O>().unwrap().clone(),
                    any_operation.0.downcast_ref::<D>().unwrap().clone(),
                ))
            },
        );

        let wrapped = wrapped.map_return(|ret_val, _state| match ret_val {
            Ok(success) => Ok(AnySuccess(Arc::new(success))),
            Err(err) => Err(match err {
                OperationError::Operation(failure) => {
                    OperationError::Operation(AnyFailure(Arc::new(failure)))
                }
                OperationError::Internal(err) => OperationError::Internal(err),
                OperationError::Unhandled => OperationError::Unhandled,
            }),
        });

        let pair = ObjectOperationPair::from_types::<O, D>();

        self.operation_handlers.insert(pair, wrapped);

        self.metadata.register_operation::<O, D>();

        self
    }

    /// Register a [`GiteratedObject`] type with the runtime.
    ///
    /// # Type Registration
    /// This will register the provided object type.
    pub fn object<O: GiteratedObject + 'static>(&mut self) -> &mut Self {
        self.metadata.register_object::<O>();

        // Insert handler so ObjectRequest is handled properly

        self.operation(
            move |_object: Instance,
                  operation: ObjectRequest,
                  _state: S,
                  _operation_state: StackOperationState,
                  stack: Arc<GiteratedStack>| {
                let operation = operation.clone();
                async move {
                    for (_object_name, object_meta) in stack.metadata.objects.iter() {
                        if (object_meta.from_str)(&operation.0).is_ok() {
                            return Ok(ObjectResponse(operation.0.clone()));
                        }
                    }

                    Err(OperationError::Unhandled)
                }
                .boxed_local()
            },
        );

        self
    }

    /// Register a [`Setting`] type with the runtime.
    ///
    /// # Type Registration
    /// This will register the provided setting type.
    pub fn setting<O: GiteratedObject + 'static, T: Setting + 'static + Clone>(
        &mut self,
    ) -> &mut Self {
        self.metadata.register_setting::<O, T>();

        self
    }

    /// Register a [`GiteratedObjectValue`] that is also a [`Setting`], which
    /// allows for automatic value updates.
    pub fn value_setting<
        O: GiteratedObject + 'static + Clone,
        T: GiteratedObjectValue<Object = O> + Setting + 'static + Clone,
    >(
        &mut self,
    ) -> &mut Self {
        self.metadata.register_setting::<O, T>();
        self.metadata.register_value::<O, T>();

        self.setting_change.insert(
            ObjectSettingPair::from_types::<O, T>(),
            HandlerWrapper::new(
                (),
                move |object: AnyObject,
                      setting: AnySetting,
                      _state: (),
                      operation_state: StackOperationState,
                      stack: Arc<GiteratedStack>| {
                    trace!(
                        "value setting updated {}::{}",
                        O::object_name(),
                        T::value_name()
                    );
                    let object = object.clone();
                    async move {
                        let object = object.0.downcast_ref::<O>().unwrap();
                        let setting = setting.0.downcast_ref::<T>().unwrap();
                        stack
                            .value_update(object.clone(), setting.clone(), &operation_state)
                            .await;
                        Ok(())
                    }
                    .boxed_local()
                },
            ),
        );

        let wrapped = HandlerWrapper::new(
            self.state.clone(),
            |object: AnyObject,
             _state: _,
             _operation_state: StackOperationState,
             stack: Arc<GiteratedStack>| {
                info!("a setting handler called");
                let object = object.clone();
                async move {
                    match stack
                        .new_get_setting::<O, T>(object.0.downcast_ref().unwrap())
                        .await
                    {
                        Ok(setting) => Ok(AnyValue(Arc::new(setting))),
                        Err(err) => {
                            panic!("Error: {:?}", err);
                        }
                    }
                }
                .boxed_local()
            },
        );

        self.value_getters
            .insert(ObjectValuePair::from_types::<O, T>(), wrapped);

        self
    }

    /// Register a [`GiteratedObjectValue<O>`] type with the runtime, providing
    /// its associated handler for [`GetValue`].
    ///
    /// # Type Registration
    /// This will register the provided [`GiteratedObjectValue`] type for its matching / specified
    /// object type. It will **not** register the object type automatically.
    pub fn value<O, V, A, F, E>(&mut self, handler: F) -> &mut Self
    where
        O: GiteratedObject + 'static,
        V: GiteratedObjectValue<Object = O> + 'static + Clone,
        F: IntoGiteratedHandler<(O,), A, S, StackOperationState, Result<V, OperationError<E>>>
            + Send
            + Sync,
        E: Into<anyhow::Error> + 'static + std::fmt::Debug + Clone,
        F: 'static,
    {
        let wrapped = HandlerWrapper::new(self.state.clone(), handler);

        let wrapped = wrapped.map(
            |(any_object,): &(AnyObject,), _state: &StackOperationState| {
                Ok((any_object
                    .0
                    .downcast_ref::<O>()
                    .ok_or_else(|| OperationError::Internal(DowncastError.into()))?
                    .clone(),))
            },
        );

        let wrapped = wrapped.map_return(|ret_val, _state| match ret_val {
            Ok(success) => Ok(AnyValue(Arc::new(success))),
            Err(err) => Err(match err {
                OperationError::Operation(failure) => OperationError::Internal(failure.into()),
                OperationError::Internal(err) => OperationError::Internal(err),
                OperationError::Unhandled => OperationError::Unhandled,
            }),
        });

        assert!(self
            .value_getters
            .insert(ObjectValuePair::from_types::<O, V>(), wrapped)
            .is_none());

        self.metadata.register_value::<O, V>();

        self
    }

    pub fn value_change<O, A, F, V>(&mut self, handler: F) -> &mut Self
    where
        O: GiteratedObject + 'static,
        F: IntoGiteratedHandler<
                (O, V),
                A,
                S,
                StackOperationState,
                Result<(), OperationError<anyhow::Error>>,
            > + Send
            + Sync,
        V: GiteratedObjectValue<Object = O> + Clone + 'static,
        O: 'static,
        V: 'static,
        F: 'static,
    {
        let wrapped = HandlerWrapper::new(self.state.clone(), handler);

        let wrapped = wrapped.map(
            |(any_object, any_value): &(AnyObject, AnyValue), _state: &StackOperationState| {
                Ok((
                    any_object
                        .0
                        .downcast_ref::<O>()
                        .ok_or_else(|| OperationError::Internal(DowncastError.into()))?
                        .clone(),
                    any_value
                        .0
                        .downcast_ref::<V>()
                        .ok_or_else(|| OperationError::Internal(DowncastError.into()))?
                        .clone(),
                ))
            },
        );

        assert!(self
            .value_change
            .insert(ObjectValuePair::from_types::<O, V>(), wrapped)
            .is_none());

        self
    }

    pub fn object_metadata_provider(&mut self, provider: Box<dyn MetadataProvider>) -> &mut Self {
        self.metadata_providers.push(provider);

        self
    }
}

#[derive(Debug, Clone, thiserror::Error)]
#[error("downcast error")]
pub struct DowncastError;