use giterated_models::{
    error::OperationError,
    object::{GiteratedObject, Object, ObjectRequestError},
    object_backend::ObjectBackend,
    operation::GiteratedOperation,
};
use std::fmt::Debug;

use crate::vtable::RuntimeVTable;

use super::OperationState;

#[derive(Clone)]
pub struct RuntimeHandle {
    runtime_vtable: RuntimeVTable,
}

impl RuntimeHandle {
    pub async fn handle_serialized(
        &self,
        _object: &str,
        _operation_name: &str,
        _payload: &[u8],
    ) -> Result<Vec<u8>, OperationError<Vec<u8>>> {
        todo!()
    }
}

impl RuntimeHandle {
    pub(crate) unsafe fn from_vtable(runtime_vtable: RuntimeVTable) -> Self {
        Self { runtime_vtable }
    }
}

#[async_trait::async_trait(?Send)]
impl ObjectBackend for RuntimeHandle {
    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!()
    }
}