use giterated_models::{
    error::OperationError,
    object::GiteratedObject,
    operation::{GiteratedOperation, OperationState},
};

use crate::{
    future::{RuntimeFuture, RuntimeFuturesExt},
    new_stack::{handle::RuntimeHandle, PluginState},
    vtable::OperationVTable,
    AnyFailure, AnyObject, AnyOperation, AnySuccess, FFIBox,
};

use std::{any::type_name, fmt::Debug, future::Future};

use super::{CallbackPtr, RuntimeState};

#[derive(Clone, Copy)]
pub struct OperationHandlerCallback {
    pub callback_ptr: CallbackPtr,
    pub func: unsafe extern "C" fn(
        CallbackPtr,
        &RuntimeState,
        &PluginState,
        object: AnyObject,
        operation: AnyOperation,
    )
        -> RuntimeFuture<Result<AnySuccess, OperationError<AnyFailure>>>,
}

impl OperationHandlerCallback {
    pub fn new<
        S,
        O: GiteratedObject,
        D: GiteratedOperation<O>,
        A,
        T: IntoPluginOperationHandler<S, O, D, A>,
    >(
        handler: T,
    ) -> Self {
        OperationHandlerCallback {
            func: T::handle,
            callback_ptr: T::callback_ptr(&handler),
        }
    }
}

pub trait IntoPluginOperationHandler<S, O: GiteratedObject, D: GiteratedOperation<O>, A> {
    unsafe extern "C" fn handle(
        callback_ptr: CallbackPtr,
        runtime_state: &RuntimeState,
        state: &PluginState,
        object: AnyObject,
        operation: AnyOperation,
    ) -> RuntimeFuture<Result<AnySuccess, OperationError<AnyFailure>>>;
    fn callback_ptr(&self) -> CallbackPtr;
}

impl<F, S, O, D, Fut> IntoPluginOperationHandler<S, O, D, ()> for F
where
    Fut: Future<Output = Result<D::Success, OperationError<D::Failure>>> + Send + Sync,
    F: Fn(S, O, D) -> Fut + Send + Sync + 'static,
    S: Clone + Debug + Send + Sync + 'static,
    O: Debug + GiteratedObject + 'static,
    D: Debug + GiteratedOperation<O> + 'static,
{
    unsafe extern "C" fn handle(
        callback: CallbackPtr,
        runtime_state: &RuntimeState,
        state: &PluginState,
        mut object: AnyObject,
        mut operation: AnyOperation,
    ) -> RuntimeFuture<Result<AnySuccess, OperationError<AnyFailure>>> {
        let _guard = trace_span!(
            "operation handler",
            object = type_name::<O>(),
            operation = type_name::<D>()
        )
        .entered();
        let state = unsafe { state.transmute_ref::<S>() };

        // Since this is Rust code, we know that the AnyObject and AnyOperation are just boxes
        let object = unsafe { object.transmute_owned::<O>() };
        let operation = unsafe { operation.transmute_owned::<D>() };

        // Cast the callback ptr to ourselves
        let callback: *const F = std::mem::transmute(callback.0);
        let callback = callback.as_ref().unwrap();

        let state = state.clone();
        runtime_state.spawn_future(async move {
            let result = callback(state, *object, *operation).await;

            match result {
                Ok(success) => unsafe {
                    Ok(AnySuccess::from_raw(
                        FFIBox::from_box(Box::new(success)).untyped(),
                        OperationVTable::new::<O, D>(),
                    ))
                },
                Err(err) => match err {
                    OperationError::Operation(_) => todo!(),
                    OperationError::Internal(_) => todo!(),
                    OperationError::Unhandled => todo!(),
                },
            }
        })
    }

    fn callback_ptr(&self) -> CallbackPtr {
        unsafe { CallbackPtr::from_raw(self as *const _ as *const ()) }
    }
}

impl<F, S, O, D, Fut, A1> IntoPluginOperationHandler<S, O, D, (A1,)> for F
where
    Fut: Future<Output = Result<D::Success, OperationError<D::Failure>>>,
    F: Fn(S, O, D, A1) -> Fut,
    S: Clone + Debug,
    O: Debug + GiteratedObject,
    D: Debug + GiteratedOperation<O>,
{
    unsafe extern "C" fn handle(
        _callback_ptr: CallbackPtr,
        _runtime_state: &RuntimeState,
        _state: &PluginState,
        _object: AnyObject,
        _operation: AnyOperation,
    ) -> RuntimeFuture<Result<AnySuccess, OperationError<AnyFailure>>> {
        todo!()
    }

    fn callback_ptr(&self) -> CallbackPtr {
        todo!()
    }
}

impl<F, S, O, D, Fut, A1, A2> IntoPluginOperationHandler<S, O, D, (A1, A2)> for F
where
    Fut: Future<Output = Result<D::Success, OperationError<D::Failure>>>,
    F: Fn(S, O, D, A1, A2) -> Fut,
    S: Clone + Debug,
    O: Debug + GiteratedObject,
    D: Debug + GiteratedOperation<O>,
{
    unsafe extern "C" fn handle(
        _callback_ptr: CallbackPtr,
        _runtime_state: &RuntimeState,
        _state: &PluginState,
        _object: AnyObject,
        _operation: AnyOperation,
    ) -> RuntimeFuture<Result<AnySuccess, OperationError<AnyFailure>>> {
        todo!()
    }

    fn callback_ptr(&self) -> CallbackPtr {
        todo!()
    }
}

pub trait FromOperationState<O, D>: Sized {
    fn from_operation_state(
        operation_state: &OperationState,
        runtime_state: &RuntimeState,
        object: &O,
        operation: &D,
    ) -> Result<Self, OperationError<anyhow::Error>>;
}

impl<O, D> FromOperationState<O, D> for RuntimeHandle {
    fn from_operation_state(
        _operation_state: &OperationState,
        runtime_state: &RuntimeState,
        _object: &O,
        _operation: &D,
    ) -> Result<Self, OperationError<anyhow::Error>> {
        Ok(unsafe { RuntimeHandle::from_vtable(runtime_state.vtable) })
    }
}

impl<O, D, T> FromOperationState<O, D> for Option<T>
where
    T: FromOperationState<O, D>,
{
    fn from_operation_state(
        operation_state: &OperationState,
        runtime_state: &RuntimeState,
        object: &O,
        operation: &D,
    ) -> Result<Self, OperationError<anyhow::Error>> {
        Ok(T::from_operation_state(operation_state, runtime_state, object, operation).ok())
    }
}