use std::future::Future;

use giterated_abi::{
    callback::{Callback, CallbackPtr},
    result::{FfiError, FfiResult},
    vtable::{Object, Value},
    FfiSliceRef, FfiValueMut, FfiValueRef,
};
use giterated_models::{
    error::OperationError, object::GiteratedObject, value::GiteratedObjectValue,
};

use crate::{future::RuntimeFuture, new_stack::PluginState, state::State};

use super::{RuntimeState, SettingGetterCallback};

#[derive(Copy, Clone)]
pub struct ValueGetterCallback(CallbackPtr<ValueGetterCallback>);

impl Callback for ValueGetterCallback {
    type CallbackFunc = unsafe extern "C" fn(
        CallbackPtr<ValueGetterCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
    ) -> RuntimeFuture<FfiResult<Value, FfiError>>;
}

impl ValueGetterCallback {
    // pub fn new<S, O, V, T: IntoPluginValueGetter<S, O, V>>(handler: T) -> Self {
    //     Self {
    //         func: T::get_value,
    //         callback_ptr: handler.callback_ptr(),
    //     }
    // }
}

pub trait IntoPluginValueGetter<S, O, V> {
    unsafe extern "C" fn get_value(
        callback: CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
    ) -> RuntimeFuture<FfiResult<Value, FfiError>>;

    fn callback_ptr(&self) -> CallbackPtr<SettingGetterCallback>;
}

impl<F, S, O, V, Fut> IntoPluginValueGetter<S, O, V> for F
where
    Fut: Future<Output = Result<V, OperationError<anyhow::Error>>> + Send + Sync,
    S: Clone + Send + Sync + 'static,
    O: GiteratedObject + 'static,
    V: GiteratedObjectValue<Object = O> + Send + Sync + 'static,
    F: Fn(S, O) -> Fut + Send + Sync + 'static,
{
    unsafe extern "C" fn get_value(
        callback: CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        mut object: FfiValueRef<Object>,
    ) -> RuntimeFuture<FfiResult<Value, FfiError>> {
        // let _guard = trace_span!(
        //     "get_value handler",
        //     object = O::object_name(),
        //     value = V::value_name()
        // )
        // .entered();
        // let state = unsafe { state.transmute_ref::<S>() };

        // let object = unsafe { object.transmute_owned::<O>() };

        // // 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).await;

        //     match result {
        //         Ok(success) => unsafe { Ok(NewAnyValue::new(success)) },
        //         Err(err) => match err {
        //             OperationError::Operation(_) => todo!(),
        //             OperationError::Internal(_) => todo!(),
        //             OperationError::Unhandled => todo!(),
        //         },
        //     }
        // })

        todo!()
    }

    fn callback_ptr(&self) -> CallbackPtr<SettingGetterCallback> {
        todo!()
        // unsafe { CallbackPtr::from_raw(self as *const _ as *const ()) }
    }
}

pub struct ValueChangeCallback(CallbackPtr<ValueChangeCallback>);

impl Callback for ValueChangeCallback {
    type CallbackFunc = unsafe extern "C" fn(
        &PluginState,
        object: FfiValueRef<Object>,
        value_name: FfiSliceRef<str>,
        new_value: Value,
    ) -> RuntimeFuture<()>;
}

pub trait IntoValueChangeCallback<S, O> {
    unsafe extern "C" fn value_changed(
        callback: CallbackPtr<ValueChangeCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        value_name: FfiSliceRef<str>,
        new_value: Value,
    ) -> RuntimeFuture<()>;
}

impl<F, S, O> IntoValueChangeCallback<S, O> for F {
    unsafe extern "C" fn value_changed(
        callback: CallbackPtr<ValueChangeCallback>,
        state: FfiValueMut<State>,
        _object: FfiValueRef<Object>,
        _value_name: FfiSliceRef<str>,
        _new_value: Value,
    ) -> RuntimeFuture<()> {
        todo!()
    }
}

impl ValueChangeCallback {
    // pub fn new<S, O, T: IntoValueChangeCallback<S, O>>() -> Self {
    //     Self {
    //         func: T::value_changed,
    //     }
    // }
}