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

//! 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);
        });
    }

    fn list_raw_transactions<'a>(
        &'a self,
        query: &'a ksp_store_api::RawTransactionQuery,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawTransactionReference>>> {
        let _ = query;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(ksp_store_api::RawPage::new(std::vec::Vec::new(), 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,
        mode: ksp_store_api::RawTransactionAcquisitionMode,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawAcquisitionWriteOutcome>> {
        let _ = transaction;
        let _ = observation;
        let _ = mode;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(ksp_store_api::RawAcquisitionWriteOutcome::new(
                ksp_store_api::RawEntityWriteOutcome::Inserted,
                ksp_store_api::RawObservationWriteOutcome::Inserted,
            ));
        });
    }
}

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<ksp_store_api::RawObservationWriteOutcome>> {
        let _ = observation;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(ksp_store_api::RawObservationWriteOutcome::Inserted);
        });
    }
}

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

    fn list_raw_account_states<'a>(
        &'a self,
        query: &'a ksp_store_api::RawAccountStateQuery,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawAccountStateReference>>> {
        let _ = query;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(ksp_store_api::RawPage::new(std::vec::Vec::new(), 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<ksp_store_api::RawAcquisitionWriteOutcome>> {
        let _ = state;
        let _ = observation;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(ksp_store_api::RawAcquisitionWriteOutcome::new(
                ksp_store_api::RawEntityWriteOutcome::Inserted,
                ksp_store_api::RawObservationWriteOutcome::Inserted,
            ));
        });
    }
}

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<ksp_store_api::RawObservationWriteOutcome>> {
        let _ = observation;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(ksp_store_api::RawObservationWriteOutcome::Inserted);
        });
    }
}

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

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

impl ksp_store_api::RawTransactionRetentionWrite for ExternalMemoryBackend {
    fn transition_raw_transaction_retention<'a>(
        &'a self,
        transition: ksp_store_api::RawTransactionRetentionTransition,
    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawRetentionWriteOutcome>> {
        let _ = transition;
        return std::boxed::Box::pin(async {
            return std::result::Result::Ok(ksp_store_api::RawRetentionWriteOutcome::Applied);
        });
    }
}

#[test]
fn pre_006_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 retention_read: &dyn ksp_store_api::RawTransactionRetentionRead = &backend;
    let retention_write: &dyn ksp_store_api::RawTransactionRetentionWrite = &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;
    let _ = retention_read;
    let _ = retention_write;
    return;
}