use giterated_abi::{
    callback::{Callback, CallbackPtr},
    result::FfiResult,
    value_ex::FfiValueUntyped,
    vtable::{operation::Operation, Object},
    FfiValueMut, FfiValueRef,
};
use giterated_models::{
    error::OperationError,
    object::GiteratedObject,
    operation::{GiteratedOperation, OperationState},
};

use crate::{
    future::{RuntimeFuture, RuntimeFuturesExt},
    new_stack::{handle::RuntimeHandle, PluginState},
    state::{FromState, State, StateUUID},
};

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

use super::RuntimeState;

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>,
    ) -> RuntimeFuture<
        FfiResult<FfiValueUntyped, OperationError<FfiValueUntyped>>,
    >;
}

impl OperationHandlerCallback {
    // pub fn new<
    //     S,
    //     O: GiteratedObject,
    //     D: GiteratedOperation<O>,
    //     A,
    //     T: IntoPluginOperationHandler<S, O, D, A>,
    // >(
    //     handler: T,
    // ) -> Self {
    //     OperationHandlerCallback(unsafe { CallbackPtr::from_raw(&handler, T::handle as _) })
    // }
}

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

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<OperationHandlerCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        operation: FfiValueRef<Operation>,
    ) -> RuntimeFuture<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, 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<OperationHandlerCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        operation: FfiValueRef<Operation>,
    ) -> RuntimeFuture<FfiResult<FfiValueUntyped, OperationError<FfiValueUntyped>>> {
        todo!()
    }

    fn callback_ptr(&self) -> CallbackPtr<OperationHandlerCallback> {
        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<OperationHandlerCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        operation: FfiValueRef<Operation>,
    ) -> RuntimeFuture<FfiResult<FfiValueUntyped, OperationError<FfiValueUntyped>>> {
        todo!()
    }

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

pub trait FromOperationState<O, D>: Sized {
    fn from_operation_state(
        state: &mut State,
        object: &O,
        operation: &D,
    ) -> Result<Self, OperationError<anyhow::Error>>;
}

pub struct StateExtractor<T>(T);

impl<T: FromState> FromState for StateExtractor<T> {
    fn from_state(state: &mut State) -> Result<Self, anyhow::Error> {
        todo!()
    }
}

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

// impl<O, D> FromOperationState<O, D> for RuntimeHandle {
//     fn from_operation_state(
//         _operation_state: &OperationState,
//         state: &mut State,
//         _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,
//         state: &mut State,
//         object: &O,
//         operation: &D,
//     ) -> Result<Self, OperationError<anyhow::Error>> {
//         Ok(T::from_operation_state(operation_state, runtime_state, object, operation).ok())
//     }
// }