use std::sync::OnceLock;

use giterated_models::{
    object::GiteratedObject, operation::GiteratedOperation, settings::Setting,
    value::GiteratedObjectValue,
};
use giterated_plugin::{
    callback::{
        CallbackPtr, IntoPluginOperationHandler, IntoPluginSettingGetter, IntoPluginSettingSetter,
        IntoPluginValueGetter, OperationHandlerCallback, SettingGetterCallback,
        ValueGetterCallback,
    },
    handle::PluginInitializationState,
    new_stack::PluginState,
    vtable::{
        InitializationVTable, IntoObjectVTable, IntoOperationVTable, IntoSettingVTable,
        IntoValueVTable, ObjectVtable, OperationVTable, SettingVtable, ValueVTable,
    },
    AnyObject, NewAnyValue,
};
use tracing::trace_span;

pub struct PluginStackBuilder<'init, S> {
    init_state: *mut PluginInitializationState,
    vtable: &'init InitializationVTable,
    state: S,
}

impl<'init, S> PluginStackBuilder<'init, S> {
    pub fn new(
        plugin_state: S,
        state: *mut PluginInitializationState,
        vtable: &'init InitializationVTable,
    ) -> Self {
        Self {
            init_state: state,
            vtable,
            state: plugin_state,
        }
    }

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

        let func = self.vtable.register_object;

        unsafe { func(self.init_state, O::object_name(), ObjectVtable::new::<O>()) };

        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();

        unsafe {
            (self.vtable.register_operation)(
                self.init_state,
                O::object_name(),
                D::operation_name(),
                OperationVTable::new::<O, D>(),
            )
        }

        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<S, O, OS>,
        HS: IntoPluginSettingSetter<S, O, OS>,
    {
        let _guard = trace_span!("register setting").entered();

        unsafe {
            (self.vtable.register_setting)(
                self.init_state,
                O::object_name(),
                OS::name(),
                SettingVtable::new::<OS>(),
            )
        }

        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();

        unsafe {
            (self.vtable.register_setting)(
                self.init_state,
                O::object_name(),
                OS::name(),
                SettingVtable::new::<OS>(),
            )
        }

        self
    }

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

        unsafe {
            (self.vtable.register_value)(
                self.init_state,
                O::object_name(),
                V::value_name(),
                ValueVTable::new::<O, V>(),
            )
        }

        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<
        DS,
        DF,
        A,
        O: GiteratedObject + IntoObjectVTable,
        D: IntoOperationVTable<O> + GiteratedOperation<O>,
        T: IntoPluginOperationHandler<S, O, D, DS, DF, 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, DS, DF, 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<S, 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>();
    //     // self.setting::<O, OS>();

    //     self
    // }
}

pub trait ValueSettingExt<PS> {
    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<O> + Setting + IntoSettingVTable,
        HG: IntoPluginSettingGetter<PS, O, VS>,
        HS: IntoPluginSettingSetter<PS, O, VS>;
}

impl<PS> ValueSettingExt<PS> for PluginStackBuilder<'_, PS> {
    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<O> + Setting + IntoSettingVTable,
        HG: IntoPluginSettingGetter<PS, O, VS>,
        HS: IntoPluginSettingSetter<PS, O, VS>,
    {
        self
    }
}

pub trait ValueSettingGetter<S, O, V> {
    unsafe extern "C" fn get_value(
        callback: CallbackPtr,
        state: &PluginState,
        object: AnyObject,
    ) -> Result<NewAnyValue, ()>;

    fn callback_ptr(&self) -> CallbackPtr;
}

impl<S, O, VS, HG> ValueSettingGetter<S, O, VS> for HG
where
    O: GiteratedObject,
    VS: GiteratedObjectValue<Object = O>,
    HG: IntoPluginSettingGetter<S, O, VS>,
{
    unsafe extern "C" fn get_value(
        callback: CallbackPtr,
        state: &PluginState,
        object: AnyObject,
    ) -> Result<NewAnyValue, ()> {
        let result = HG::get_setting(callback, state, object)?;

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

        Ok(NewAnyValue::new(setting))
    }

    fn callback_ptr(&self) -> CallbackPtr {
        self.callback_ptr()
    }
}