use giterated_abi::{
    callback::{
        operation::IntoPluginOperationHandler,
        setting::{IntoPluginSettingGetter, IntoPluginSettingSetter},
        value::IntoPluginValueGetter,
        Callback, CallbackPtr,
    },
    result::FfiError,
    state::{State, StateUUID},
    value_ex::FfiValueUntyped,
    vtable::{
        operation::{IntoOperationVTable, OperationVTable},
        plugin_initialization::InitializationVTable,
        IntoObjectVTable, IntoSettingVTable, IntoValueVTable, Object, ObjectVTable, SettingVTable,
        VTable, ValueVTable,
    },
    FfiValueMut, FfiValueRef,
};
use giterated_models::{
    object::GiteratedObject, operation::GiteratedOperation, settings::Setting,
    value::GiteratedObjectValue,
};

use tracing::trace_span;

pub struct PluginStackBuilder {
    init_state: FfiValueUntyped,
    vtable: &'static VTable<InitializationVTable>,
}

impl PluginStackBuilder {
    pub fn new(// state: FfiValueUntyped,
        // vtable: &'static VTable<InitializationVTable>,
    ) -> PluginStackBuilder {
        todo!()
        // PluginStackBuilder {
        //     init_state: state,
        //     vtable
        // }
    }

    pub fn insert_state<S: StateUUID>(&mut self, state: S) -> &mut Self {
        todo!()
    }

    pub fn object<O: IntoObjectVTable + GiteratedObject>(&mut self) -> &mut Self {
        let _guard = trace_span!("register object").entered();

        let func = self.vtable.register_object;

        let mut init_state = self.init_state.pin();

        unsafe {
            func(
                unsafe { init_state.grant_mut() },
                O::object_name(),
                O::VTABLE,
            )
        };

        self
    }

    pub fn register_operation<O, D>(&mut self) -> &mut Self
    where
        D: IntoOperationVTable<O> + GiteratedOperation<O>,
        O: GiteratedObject,
    {
        let _guard = trace_span!("register operation").entered();

        let mut init_state = self.init_state.pin();

        unsafe {
            (self.vtable.register_operation)(
                unsafe { init_state.grant_mut() },
                O::object_name(),
                D::operation_name(),
                <D as IntoOperationVTable<O>>::VTABLE,
            )
        }

        self
    }

    pub fn object_setting<O, OS, HG, HS>(&mut self, _get: HG, _set: HS) -> &mut Self
    where
        O: GiteratedObject,
        OS: IntoSettingVTable + Setting,
        HG: IntoPluginSettingGetter<O, OS>,
        HS: IntoPluginSettingSetter<O, OS>,
    {
        let _guard = trace_span!("register setting").entered();

        let mut init_state = self.init_state.pin();

        unsafe {
            (self.vtable.register_setting)(
                unsafe { init_state.grant_mut() },
                O::object_name(),
                OS::name(),
                OS::VTABLE,
            )
        }

        self
    }

    pub fn object_user_setting<O, OS>(&mut self) -> &mut Self
    where
        O: GiteratedObject,
        OS: IntoSettingVTable + Setting,
    {
        let _guard = trace_span!("register setting").entered();

        let mut init_state = self.init_state.pin();

        unsafe {
            (self.vtable.register_setting)(
                unsafe { init_state.grant_mut() },
                O::object_name(),
                OS::name(),
                OS::VTABLE,
            )
        }

        self
    }

    pub fn value<O, V, T>(&mut self, handler: T) -> &mut Self
    where
        O: GiteratedObject,
        V: IntoValueVTable + GiteratedObjectValue<Object = O>,
        T: IntoPluginValueGetter<O, V>,
    {
        let _guard = trace_span!("register value").entered();

        let mut init_state = self.init_state.pin();

        unsafe {
            (self.vtable.register_value)(
                unsafe { init_state.grant_mut() },
                O::object_name(),
                V::value_name(),
                V::VTABLE,
            )
        }

        // unsafe {
        //     (self.vtable.value_getter)(
        //         self.init_state,
        //         O::object_name(),
        //         V::value_name(),
        //         ValueGetterCallback::new::<S, O, V, T>(handler),
        //     )
        // }

        self
    }

    pub fn operation<
        A,
        O: GiteratedObject + IntoObjectVTable,
        D: IntoOperationVTable<O> + GiteratedOperation<O>,
        T: IntoPluginOperationHandler<O, D, A>,
    >(
        &mut self,
        handler: T,
    ) -> &mut Self {
        let _guard = trace_span!("register operation handler").entered();

        // unsafe {
        //     (self.vtable.operation_handler)(
        //         self.init_state,
        //         O::object_name(),
        //         D::operation_name(),
        //         OperationHandlerCallback::new::<S, O, D, A, T>(handler),
        //     )
        // }

        // TODO: Yikes?
        self.object::<O>();

        self.register_operation::<O, D>();

        self
    }

    // pub fn value_getter<O, V, T>(&mut self, handler: T) -> &mut Self
    // where
    //     O: GiteratedObject + IntoObjectVTable,
    //     V: GiteratedObjectValue<Object = O> + IntoValueVTable<O>,
    //     T: IntoPluginValueGetter<S, O, V>,
    // {
    //     let _guard = trace_span!("register value_getter handler").entered();

    //     unsafe {
    //         (self.vtable.value_getter)(
    //             self.init_state,
    //             O::object_name(),
    //             V::value_name(),
    //             ValueGetterCallback::new::<S, O, V, T>(handler),
    //         )
    //     }

    //     // TODO: Yikes?
    //     self.object::<O>();
    //     self.value::<O, V>();

    //     self
    // }

    pub fn setting_getter<O, OS, T>(&mut self, handler: T) -> &mut Self
    where
        O: GiteratedObject + IntoObjectVTable,
        OS: Setting + IntoSettingVTable,
        T: IntoPluginSettingGetter<O, OS>,
    {
        let _guard = trace_span!("register setting_getter handler").entered();

        // unsafe {
        //     (self.vtable.setting_getter)(
        //         self.init_state,
        //         O::object_name(),
        //         OS::name(),
        //         SettingGetterCallback::new::<S, O, OS, T>(handler),
        //     )
        // }

        self.object::<O>();

        let mut init_state = self.init_state.pin();

        unsafe {
            (self.vtable.register_setting)(
                unsafe { init_state.grant_mut() },
                O::object_name(),
                OS::name(),
                OS::VTABLE,
            )
        };

        self
    }
}

pub trait ValueSettingExt {
    fn value_setting<O, VS, HG, HS>(&mut self, get: HG, set: HS) -> &mut Self
    where
        O: GiteratedObject + IntoObjectVTable + 'static,
        VS: GiteratedObjectValue<Object = O> + IntoValueVTable + Setting + IntoSettingVTable,
        HG: IntoPluginSettingGetter<O, VS>,
        HS: IntoPluginSettingSetter<O, VS>;
}

impl ValueSettingExt for PluginStackBuilder {
    fn value_setting<O, VS, HG, HS>(&mut self, _get: HG, _set: HS) -> &mut Self
    where
        O: GiteratedObject + IntoObjectVTable + 'static,
        VS: GiteratedObjectValue<Object = O> + IntoValueVTable + Setting + IntoSettingVTable,
        HG: IntoPluginSettingGetter<O, VS>,
        HS: IntoPluginSettingSetter<O, VS>,
    {
        self
    }
}

#[derive(Clone, Copy)]
pub struct ValueSettingGetterCallback;

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

pub trait ValueSettingGetter<O, V> {
    unsafe extern "C" fn get_value(
        callback: CallbackPtr<ValueSettingGetterCallback>,
        state: FfiValueMut<State>,
        object: FfiValueRef<Object>,
    ) -> Result<FfiValueUntyped, FfiError>;

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

impl<O, VS, HG> ValueSettingGetter<O, VS> for HG
where
    O: GiteratedObject,
    VS: GiteratedObjectValue<Object = O>,
    HG: IntoPluginSettingGetter<O, VS>,
{
    unsafe extern "C" fn get_value(
        _callback: CallbackPtr<ValueSettingGetterCallback>,
        _state: FfiValueMut<State>,
        _object: FfiValueRef<Object>,
    ) -> Result<FfiValueUntyped, FfiError> {
        // let result = HG::get_setting(callback, state, object)?;

        // let setting = *result.transmute_owned::<VS>();

        todo!();

        // Ok(NewAnyValue::new(setting))
    }

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