use std::future::Future;

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

use crate::{
    result::FfiResult,
    state::State,
    value_ex::FfiValueUntyped,
    vtable::{operation::Operation, Object},
    FfiFuture, FfiValueMut, FfiValueRef,
};

use super::{Callback, CallbackPtr};

use std::fmt::Debug;

pub struct OperationHandlerCallback(FfiValueUntyped);

impl Callback for OperationHandlerCallback {
    type CallbackFunc = unsafe extern "C" fn(
        CallbackPtr<OperationHandlerCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        operation: FfiValueRef<Operation>,
    ) -> FfiFuture<
        FfiResult<FfiValueUntyped, OperationError<FfiValueUntyped>>,
    >;
}

pub trait IntoPluginOperationHandler<O: GiteratedObject, D: GiteratedOperation<O>, A> {
    unsafe extern "C" fn handle(
        callback_ptr: CallbackPtr<OperationHandlerCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        operation: FfiValueRef<Operation>,
    ) -> FfiFuture<FfiResult<FfiValueUntyped, OperationError<FfiValueUntyped>>>;
    fn callback_ptr(&self) -> CallbackPtr<OperationHandlerCallback>;
}

impl<F, O, D, Fut> IntoPluginOperationHandler<O, D, ()> for F
where
    Fut: Future<Output = Result<D::Success, OperationError<D::Failure>>> + Send + Sync,
    F: Fn(O, D) -> Fut + Send + Sync + 'static,
    O: Debug + GiteratedObject + 'static,
    D: Debug + GiteratedOperation<O> + 'static,
{
    unsafe extern "C" fn handle(
        callback: CallbackPtr<OperationHandlerCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        operation: FfiValueRef<Operation>,
    ) -> FfiFuture<FfiResult<FfiValueUntyped, OperationError<FfiValueUntyped>>> {
        todo!()
        // 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 {
        //             todo!()
        //             // 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<OperationHandlerCallback> {
        // unsafe { CallbackPtr::from_raw(self as *const _ as *const ()) }

        todo!()
    }
}

impl<F, O, D, Fut, A1> IntoPluginOperationHandler<O, D, (A1,)> for F
where
    Fut: Future<Output = Result<D::Success, OperationError<D::Failure>>>,
    F: Fn(O, D, A1) -> Fut,
    O: Debug + GiteratedObject,
    D: Debug + GiteratedOperation<O>,
{
    unsafe extern "C" fn handle(
        _callback_ptr: CallbackPtr<OperationHandlerCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        operation: FfiValueRef<Operation>,
    ) -> FfiFuture<FfiResult<FfiValueUntyped, OperationError<FfiValueUntyped>>> {
        todo!()
    }

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

impl<F, O, D, Fut, A1, A2> IntoPluginOperationHandler<O, D, (A1, A2)> for F
where
    Fut: Future<Output = Result<D::Success, OperationError<D::Failure>>>,
    F: Fn(O, D, A1, A2) -> Fut,
    O: Debug + GiteratedObject,
    D: Debug + GiteratedOperation<O>,
{
    unsafe extern "C" fn handle(
        _callback_ptr: CallbackPtr<OperationHandlerCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        operation: FfiValueRef<Operation>,
    ) -> FfiFuture<FfiResult<FfiValueUntyped, OperationError<FfiValueUntyped>>> {
        todo!()
    }

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