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

use anyhow::Error;
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, HandlerResolvable,
    IntoGiteratedHandler, MaybeDynamicObject, MaybeDynamicValue, ObjectOperationPair,
    ObjectSettingPair, ObjectValuePair, OperationHandler, OperationState, RuntimeMetadata,
    SettingChange, SettingGetter, StackOperationState, ValueChange, ValueGetter,
};

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

    pub(crate) state: S,
    _marker: PhantomData<OS>,
}

impl<S: GiteratedStackState + 'static, OS> SubstackBuilder<S, OS> {
    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,
            _marker: PhantomData::default(),
        }
    }
}

impl<S: Send + Sync + Clone + 'static, OS: Clone + 'static> SubstackBuilder<S, OS> {
    /// 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, OS, Result<D::Success, OperationError<D::Failure>>>
            + Send
            + Sync
            + 'static,
        O: 'static,
        D: 'static,
        D::Failure: std::fmt::Debug + 'static,
        D::Success: 'static,
        OS: Clone,
    {
        let wrapped = HandlerWrapper::new(self.state.clone(), handler);

        let wrapped = wrapped.map(
            |(any_object, any_operation): &(AnyObject, AnyOperation), _state: &OS| {
                Ok((
                    any_object.downcast_ref::<O>().unwrap().clone(),
                    any_operation.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 [`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 dynamic_value<O, A, F>(&mut self, handler: F) -> &mut Self
    where
        O: MaybeDynamicObject + 'static,
        F: IntoGiteratedHandler<
                (O, String),
                A,
                S,
                OS,
                Result<AnyValue, OperationError<anyhow::Error>>,
            > + Send
            + Sync,
        F: 'static,
    {
        let wrapped = HandlerWrapper::new(self.state.clone(), handler);

        let wrapped = wrapped.map(|(any_object, name): &(AnyObject, String), _state: &OS| {
            Ok((O::from_any(any_object), name.clone()))
        });

        let wrapped = wrapped.map_return(|ret_val, _state| match ret_val {
            Ok(success) => Ok(success.into_any()),
            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 {
                    object_kind: O::object_name(),
                    value_kind: "any"
                },
                wrapped
            )
            .is_none());

        self
    }

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

        let wrapped = wrapped.map(
            |(any_object, any_value): &(AnyObject, AnyValue), _state: &OS| {
                Ok((O::from_any(any_object), V::from_any(any_value)))
            },
        );

        assert!(self
            .value_change
            .insert(
                ObjectValuePair {
                    object_kind: O::object_name(),
                    value_kind: V::value_name()
                },
                wrapped
            )
            .is_none());

        self
    }

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

        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
    where
        GiteratedStack<OS>: HandlerResolvable<(Instance, ObjectRequest), OS>,
        <GiteratedStack<OS> as HandlerResolvable<(Instance, ObjectRequest), OS>>::Error:
            Into<Error>,
    {
        self.metadata.register_object::<O>();

        // Insert handler so ObjectRequest is handled properly

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

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

        self
    }
}

impl<S: Send + Sync + Clone + 'static> SubstackBuilder<S, StackOperationState> {
    /// 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: _,
                      OperationState(operation_state): OperationState<StackOperationState>,
                      stack: GiteratedStack<StackOperationState>| {
                    trace!(
                        "value setting updated {}::{}",
                        O::object_name(),
                        T::value_name()
                    );
                    let object = object.clone();
                    async move {
                        let object = object.downcast_ref::<O>().unwrap();
                        let setting = setting.downcast_ref::<T>().unwrap();
                        stack
                            .value_update(
                                object.clone(),
                                AnyValue::new(setting.clone()),
                                &operation_state,
                            )
                            .await;
                        Ok(())
                    }
                    .boxed_local()
                },
            ),
        );

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

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

        self
    }
}

// Placeholder
impl<S: Send + Sync + Clone + 'static, OS> SubstackBuilder<S, OS> {
    pub fn dynamic_operation<A, H>(&mut self, handler: H) -> &mut Self
    where
        H: IntoGiteratedHandler<
                (AnyObject, AnyOperation),
                A,
                S,
                OS,
                Result<AnySuccess, OperationError<AnyFailure>>,
            > + Send
            + Sync
            + 'static,
        OS: Clone + Send + Sync + 'static,
    {
        let wrapped = HandlerWrapper::new(self.state.clone(), handler);

        self.operation_handlers.insert(
            ObjectOperationPair {
                object_name: "any",
                operation_name: "any",
            },
            wrapped,
        );

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