use giterated_abi::vtable::{runtime::RuntimeHandle, VTable};
use giterated_models::{
    error::OperationError,
    object::{GiteratedObject, Object, ObjectRequestError},
    object_backend::ObjectBackend,
    operation::{GiteratedOperation, OperationState},
};
use std::fmt::Debug;

pub mod types;

#[derive(Clone)]
#[repr(C)]
pub struct RuntimeState {
    pub vtable: &'static VTable<RuntimeHandle>,
}

#[async_trait::async_trait(?Send)]
impl ObjectBackend for RuntimeState {
    async fn object_operation<O, D>(
        &self,
        object: O,
        operation: &str,
        payload: D,
        operation_state: &OperationState,
    ) -> Result<D::Success, OperationError<D::Failure>>
    where
        O: GiteratedObject + Debug + 'static,
        D: GiteratedOperation<O> + Debug + 'static,
        D::Success: Clone,
        D::Failure: Clone,
    {
        todo!()
    }

    async fn get_object<O: GiteratedObject + Debug + 'static>(
        &self,
        object_str: &str,
        operation_state: &OperationState,
    ) -> Result<Object<O, Self>, OperationError<ObjectRequestError>> {
        todo!()
    }
}

// impl RuntimeState {
//     pub unsafe fn from_static() -> Self {
//         let runtime = giterated_static_runtime::get_runtime_reference();

//         let runtime = runtime.cast::<Box<Runtime>>().as_ref();

//         runtime.state()
//     }

//     pub unsafe fn runtime_state() -> PluginState {
//         let runtime = giterated_static_runtime::get_runtime_reference();

//         PluginState::from_raw_ptr(giterated_static_runtime::get_runtime_reference().as_ptr())
//     }
// }

// #[async_trait::async_trait(?Send)]
// impl ObjectBackend for RuntimeState {
//     async fn object_operation<O, D>(
//         &self,
//         object: O,
//         _operation: &str,
//         payload: D,
//         _operation_state: &OperationState,
//     ) -> Result<D::Success, OperationError<D::Failure>>
//     where
//         O: GiteratedObject + Debug + 'static,
//         D: GiteratedOperation<O> + Debug + 'static,
//         D::Success: Clone,
//         D::Failure: Clone,
//     {
//         // let _object = AnyObject::new(object);
//         // let _operation = AnyOperation::new(payload);

//         todo!()
//     }

//     async fn get_object<O: GiteratedObject + Debug + 'static>(
//         &self,
//         object_str: &str,
//         operation_state: &OperationState,
//     ) -> Result<Object<O, Self>, OperationError<ObjectRequestError>> {
//         // let object = unsafe {
//         //     (self.vtable.get_object)(
//         //         Self::runtime_state(),
//         //         object_str,
//         //         &mut operation_state.clone(),
//         //     )
//         // }?;

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

//         panic!("object casted");

//         // Ok(unsafe { Object::new_unchecked(object, self.clone()) })

//         todo!()
//     }
// }