use super::*;
use crate::mapper::*;

impl SpacetimeClient {
    pub async fn enqueue_external_generation_job(
        &self,
        input: ExternalGenerationJobEnqueueRecordInput,
    ) -> Result<ExternalGenerationJobRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "enqueue_external_generation_job_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .enqueue_external_generation_job_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_external_generation_job_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn claim_external_generation_jobs(
        &self,
        input: ExternalGenerationJobClaimRecordInput,
    ) -> Result<Vec<ExternalGenerationJobRecord>, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "claim_external_generation_jobs_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .claim_external_generation_jobs_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_external_generation_job_claim_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn complete_external_generation_job(
        &self,
        input: ExternalGenerationJobCompleteRecordInput,
    ) -> Result<ExternalGenerationJobRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "complete_external_generation_job_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .complete_external_generation_job_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_external_generation_job_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn renew_external_generation_job_lease(
        &self,
        input: ExternalGenerationJobRenewLeaseRecordInput,
    ) -> Result<ExternalGenerationJobRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "renew_external_generation_job_lease_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .renew_external_generation_job_lease_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_external_generation_job_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn fail_external_generation_job(
        &self,
        input: ExternalGenerationJobFailRecordInput,
    ) -> Result<ExternalGenerationJobRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "fail_external_generation_job_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .fail_external_generation_job_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_external_generation_job_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn get_external_generation_queue_stats(
        &self,
    ) -> Result<ExternalGenerationQueueStatsRecord, SpacetimeClientError> {
        self.call_after_connect(
            "get_external_generation_queue_stats_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .get_external_generation_queue_stats_and_return_then(move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_external_generation_queue_stats_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }
}