use giterated_models::error::OperationError;

use crate::{
    new_stack::{PluginState, Runtime, State},
    AnyObject, AnyOperation,
};

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

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,
    ),
}

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

pub trait IntoPluginOperationHandler<S, O, D, DS, DF, A> {
    unsafe extern "C" fn handle(
        callback_ptr: CallbackPtr,
        runtime_state: &RuntimeState,
        state: &PluginState,
        object: AnyObject,
        operation: AnyOperation,
    );
    fn callback_ptr(&self) -> CallbackPtr;
}

impl<F, S, O, D, DS, DF, Fut> IntoPluginOperationHandler<S, O, D, DS, DF, ()> for F
where
    Fut: Future<Output = Result<DS, OperationError<DF>>>,
    F: Fn(S, O, D) -> Fut,
    S: Clone + Debug,
    O: Debug,
    D: Debug,
{
    unsafe extern "C" fn handle(
        callback: CallbackPtr,
        runtime_state: &RuntimeState,
        state: &PluginState,
        mut object: AnyObject,
        mut operation: AnyOperation,
    ) {
        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();

        // callback(state.clone(), *object, *operation)

        todo!()
    }

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

impl<F, S, O, D, DS, DF, Fut, A1> IntoPluginOperationHandler<S, O, D, DS, DF, (A1,)> for F
where
    Fut: Future<Output = Result<DS, OperationError<DF>>>,
    F: Fn(S, O, D, A1) -> Fut,
    S: Clone + Debug,
    O: Debug,
    D: Debug,
{
    unsafe extern "C" fn handle(
        callback_ptr: CallbackPtr,
        runtime_state: &RuntimeState,
        state: &PluginState,
        object: AnyObject,
        operation: AnyOperation,
    ) {
        todo!()
    }

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

impl<F, S, O, D, DS, DF, Fut, A1, A2> IntoPluginOperationHandler<S, O, D, DS, DF, (A1, A2)> for F
where
    Fut: Future<Output = Result<DS, OperationError<DF>>>,
    F: Fn(S, O, D, A1, A2) -> Fut,
    S: Clone + Debug,
    O: Debug,
    D: Debug,
{
    unsafe extern "C" fn handle(
        callback_ptr: CallbackPtr,
        runtime_state: &RuntimeState,
        state: &PluginState,
        object: AnyObject,
        operation: AnyOperation,
    ) {
        todo!()
    }

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

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

impl<S, O, D> FromOperationState<S, O, D> for Arc<Runtime> {
    fn from_operation_state(
        state: &S,
        runtime_state: &RuntimeState,
        object: &O,
        operation: &D,
    ) -> Result<Self, OperationError<anyhow::Error>> {
        Ok(runtime_state.runtime.clone())
    }
}

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

impl<S, O, D, OS: Clone> FromOperationState<S, O, D> for State<OS> {
    fn from_operation_state(
        state: &S,
        runtime_state: &RuntimeState,
        object: &O,
        operation: &D,
    ) -> Result<Self, OperationError<anyhow::Error>> {
        Ok(unsafe { State(runtime_state.operation_state.transmute_ref::<OS>().clone()) })
    }
}