use std::future::Future;

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

use crate::{
    state::{FromState, State},
    value_ex::FfiValueUntyped,
    vtable::{Object, Setting},
    FfiFuture, FfiValueMut, FfiValueRef,
};

use super::{Callback, CallbackPtr};

pub struct SettingGetterCallback(FfiValueUntyped);

impl Callback for SettingGetterCallback {
    type CallbackFunc = unsafe extern "C" fn(
        CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
    ) -> FfiFuture<Result<Setting, ()>>;
}

pub trait IntoPluginSettingGetter<O, OS, A> {
    unsafe extern "C" fn get_setting(
        callback_ptr: CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
    ) -> FfiFuture<Result<Setting, ()>>;

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

impl<F, O, OS, Fut> IntoPluginSettingGetter<O, OS, ()> for F
where
    Fut: Future<Output = Result<OS, OperationError<anyhow::Error>>> + Send + Sync + 'static,
    O: GiteratedObject + Send + Sync + 'static,
    OS: giterated_models::settings::Setting + Send + Sync + 'static,
    F: Fn(O) -> Fut + Send + Sync + 'static,
{
    unsafe extern "C" fn get_setting(
        callback: CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        mut object: FfiValueRef<Object>,
    ) -> FfiFuture<Result<Setting, ()>> {
        // let _guard = trace_span!(
        //     "get_setting handler",
        //     object = O::object_name(),
        //     setting = OS::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(NewAnySetting::new(success)) },
        //     Err(err) => match err {
        //         OperationError::Operation(_) => todo!(),
        //         OperationError::Internal(_) => todo!(),
        //         OperationError::Unhandled => todo!(),
        //     },
        // }

        todo!()
        // })
    }
}

impl<F, O, OS, Fut, A1> IntoPluginSettingGetter<O, OS, (A1,)> for F
where
    Fut: Future<Output = Result<OS, OperationError<anyhow::Error>>> + Send + Sync + 'static,
    O: GiteratedObject + Send + Sync + 'static,
    OS: giterated_models::settings::Setting + Send + Sync + 'static,
    F: Fn(O, A1) -> Fut + Send + Sync + 'static,
    A1: FromState,
{
    unsafe extern "C" fn get_setting(
        callback: CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        mut object: FfiValueRef<Object>,
    ) -> FfiFuture<Result<Setting, ()>> {
        todo!()
    }
}

pub trait IntoPluginSettingSetter<O, OS, A> {
    unsafe extern "C" fn set_setting(
        callback_ptr: CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        setting: Setting,
    ) -> FfiFuture<Result<(), ()>>;

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

impl<F, O, OS, Fut> IntoPluginSettingSetter<O, OS, ()> for F
where
    Fut: Future<Output = Result<(), OperationError<anyhow::Error>>>,
    O: GiteratedObject,
    OS: giterated_models::settings::Setting,
    F: Fn(O, OS) -> Fut,
{
    unsafe extern "C" fn set_setting(
        callback: CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        mut object: FfiValueRef<Object>,
        _setting: Setting,
    ) -> FfiFuture<Result<(), ()>> {
        // let _guard = trace_span!(
        //     "get_setting handler",
        //     object = O::object_name(),
        //     setting = OS::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 result = callback(state.clone(), *object);

        // match result {
        //     Ok(setting) => Ok(NewAnySetting::new(setting)),
        //     Err(_) => todo!(),
        // }
        todo!()
    }
}

impl<F, O, OS, Fut, A1> IntoPluginSettingSetter<O, OS, (A1,)> for F
where
    Fut: Future<Output = Result<(), OperationError<anyhow::Error>>> + Send + Sync + 'static,
    O: GiteratedObject + Send + Sync + 'static,
    OS: giterated_models::settings::Setting + Send + Sync + 'static,
    F: Fn(O, OS, A1) -> Fut + Send + Sync + 'static,
    A1: FromState,
{
    unsafe extern "C" fn set_setting(
        callback: CallbackPtr<SettingGetterCallback>,
        state: FfiValueMut<State>,
        mut object: FfiValueRef<Object>,
        _setting: Setting,
    ) -> FfiFuture<Result<(), ()>> {
        todo!()
    }
}

pub struct SettingChangeCallback(FfiValueUntyped);

impl Callback for SettingChangeCallback {
    type CallbackFunc = unsafe extern "C" fn(
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        setting_name: &str,
        new_setting: Setting,
    );
}

pub trait IntoSettingChangeCallback<S, O> {
    unsafe extern "C" fn setting_changed(
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
        setting_name: &str,
        new_setting: Setting,
    );
}

impl<F, S, O> IntoSettingChangeCallback<S, O> for F {
    unsafe extern "C" fn setting_changed(
        state: FfiValueMut<State>,
        _object: FfiValueRef<Object>,
        _setting_name: &str,
        _new_setting: Setting,
    ) {
        todo!()
    }
}