use giterated_models::{
    error::OperationError,
    object::{GiteratedObject, ObjectRequestError},
    object_backend::ObjectBackend,
    operation::{GiteratedOperation, OperationState},
};

use crate::{
    result::{FfiError, FfiResult},
    state::State,
    value_ex::FfiValueUntyped,
    FfiFuture, FfiSliceRef, FfiValueMut,
};

use core::fmt::Debug;

use super::{Object, ObjectABI};

#[derive(Clone)]
pub struct RuntimeHandle;

impl ObjectABI for RuntimeHandle {
    type VTable = RuntimeVTable;
}

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

    pub async fn handle_typed<O, D>(
        &self,
        object: O,
        operation: D,
    ) -> Result<D::Success, OperationError<D::Failure>>
    where
        O: GiteratedObject,
        D: GiteratedOperation<O>,
    {
        todo!()
    }

    pub async fn inner_get_object(
        &self,
        object_str: &str,
    ) -> Result<Object, OperationError<ObjectRequestError>> {
        todo!()
    }
}

#[derive(Clone, Copy)]
pub struct RuntimeVTable {
    pub(crate) handle_fn: unsafe extern "C" fn(
        FfiSliceRef<str>,
        FfiSliceRef<str>,
        FfiSliceRef<str>,
        FfiSliceRef<[u8]>,
        FfiSliceRef<[u8]>,
    ) -> FfiFuture<
        FfiResult<FfiValueUntyped, OperationError<FfiError>>,
    >,
    pub(crate) get_object:
        unsafe extern "C" fn(
            &str,
            state: FfiValueMut<State>,
        ) -> FfiResult<Object, OperationError<ObjectRequestError>>,
}

unsafe impl Send for RuntimeVTable {}
unsafe impl Sync for RuntimeVTable {}

pub trait IntoRuntimeVtable {
    unsafe extern "C" fn handle(
        object_kind: FfiSliceRef<str>,
        operation_name: FfiSliceRef<str>,
        object: FfiSliceRef<str>,
        operation_payload: FfiSliceRef<[u8]>,
        operation_state: FfiSliceRef<[u8]>,
    ) -> FfiFuture<FfiResult<FfiValueUntyped, OperationError<FfiError>>>;

    unsafe extern "C" fn get_object(
        object_str: &str,
        operation_state: FfiValueMut<State>,
    ) -> FfiResult<Object, OperationError<ObjectRequestError>>;
}

#[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<giterated_models::object::Object<O, Self>, OperationError<ObjectRequestError>> {
        todo!()
    }
}