// file: crates/ksp-store-api/tests/external_backend.rs
// version: 1

//! External-implementation canary for object-safe Store API capabilities.

struct ExternalMemoryBackend;

impl ksp_store_api::RawTransactionRead for ExternalMemoryBackend {
    fn get_raw_transaction<'a>(
        &'a self,
        reference: &'a ksp_store_api::RawTransactionReference,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransaction>>> {
        let _ = reference;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(std::option::Option::None);
        });
    }
}

impl ksp_store_api::RawTransactionWrite for ExternalMemoryBackend {
    fn persist_raw_transaction_acquisition<'a>(
        &'a self,
        transaction: ksp_store_api::RawTransaction,
        observation: ksp_store_api::RawTransactionObservation,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<()>> {
        let _ = transaction;
        let _ = observation;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(());
        });
    }
}

impl ksp_store_api::RawTransactionObservationRead for ExternalMemoryBackend {
    fn get_raw_transaction_observation<'a>(
        &'a self,
        observation_key: &'a ksp_store_api::RawObservationKey,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransactionObservation>>> {
        let _ = observation_key;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(std::option::Option::None);
        });
    }
}

impl ksp_store_api::RawTransactionObservationWrite for ExternalMemoryBackend {
    fn record_raw_transaction_observation<'a>(
        &'a self,
        observation: ksp_store_api::RawTransactionObservation,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<()>> {
        let _ = observation;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(());
        });
    }
}

impl ksp_store_api::RawAccountStateRead for ExternalMemoryBackend {
    fn get_raw_account_state<'a>(
        &'a self,
        reference: &'a ksp_store_api::RawAccountStateReference,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawAccountState>>> {
        let _ = reference;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(std::option::Option::None);
        });
    }
}

impl ksp_store_api::RawAccountStateWrite for ExternalMemoryBackend {
    fn persist_raw_account_acquisition<'a>(
        &'a self,
        state: ksp_store_api::RawAccountState,
        observation: ksp_store_api::RawAccountObservation,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<()>> {
        let _ = state;
        let _ = observation;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(());
        });
    }
}

impl ksp_store_api::RawAccountObservationRead for ExternalMemoryBackend {
    fn get_raw_account_observation<'a>(
        &'a self,
        observation_key: &'a ksp_store_api::RawObservationKey,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawAccountObservation>>> {
        let _ = observation_key;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(std::option::Option::None);
        });
    }
}

impl ksp_store_api::RawAccountObservationWrite for ExternalMemoryBackend {
    fn record_raw_account_observation<'a>(
        &'a self,
        observation: ksp_store_api::RawAccountObservation,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<()>> {
        let _ = observation;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(());
        });
    }
}

#[test]
fn pre_005_external_backend_implements_each_capability_without_store_runtime_crate() {
    let backend = ExternalMemoryBackend;
    let transaction_read: &dyn ksp_store_api::RawTransactionRead = &backend;
    let transaction_write: &dyn ksp_store_api::RawTransactionWrite = &backend;
    let transaction_observation_read: &dyn ksp_store_api::RawTransactionObservationRead = &backend;
    let transaction_observation_write: &dyn ksp_store_api::RawTransactionObservationWrite = &backend;
    let account_read: &dyn ksp_store_api::RawAccountStateRead = &backend;
    let account_write: &dyn ksp_store_api::RawAccountStateWrite = &backend;
    let account_observation_read: &dyn ksp_store_api::RawAccountObservationRead = &backend;
    let account_observation_write: &dyn ksp_store_api::RawAccountObservationWrite = &backend;
    let _ = transaction_read;
    let _ = transaction_write;
    let _ = transaction_observation_read;
    let _ = transaction_observation_write;
    let _ = account_read;
    let _ = account_write;
    let _ = account_observation_read;
    let _ = account_observation_write;
    return;
}