Genarrative/server-rs/crates/spacetime-client/src/big_fish.rs

use super::*;
use crate::mapper::*;
use crate::module_bindings::delete_big_fish_work_procedure::delete_big_fish_work;

impl SpacetimeClient {
    pub async fn create_big_fish_session(
        &self,
        input: BigFishSessionCreateRecordInput,
    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
        let procedure_input = BigFishSessionCreateInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            seed_text: input.seed_text,
            welcome_message_id: input.welcome_message_id,
            welcome_message_text: input.welcome_message_text,
            created_at_micros: input.created_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().create_big_fish_session_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_session_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn get_big_fish_session(
        &self,
        session_id: String,
        owner_user_id: String,
    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
        let procedure_input = BigFishSessionGetInput {
            session_id,
            owner_user_id,
        };

        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .get_big_fish_session_then(procedure_input, move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_session_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }

    pub async fn list_big_fish_works(
        &self,
        owner_user_id: String,
    ) -> Result<Vec<BigFishWorkSummaryRecord>, SpacetimeClientError> {
        let procedure_input = BigFishWorksListInput {
            owner_user_id,
            published_only: false,
        };

        self.list_big_fish_works_with_input(procedure_input).await
    }

    pub async fn list_big_fish_gallery(
        &self,
    ) -> Result<Vec<BigFishWorkSummaryRecord>, SpacetimeClientError> {
        self.list_big_fish_works_with_input(BigFishWorksListInput {
            owner_user_id: String::new(),
            published_only: true,
        })
        .await
    }

    async fn list_big_fish_works_with_input(
        &self,
        procedure_input: BigFishWorksListInput,
    ) -> Result<Vec<BigFishWorkSummaryRecord>, SpacetimeClientError> {
        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .list_big_fish_works_then(procedure_input, move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_works_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }

    pub async fn delete_big_fish_work(
        &self,
        session_id: String,
        owner_user_id: String,
    ) -> Result<Vec<BigFishWorkSummaryRecord>, SpacetimeClientError> {
        let procedure_input = BigFishWorkDeleteInput {
            session_id,
            owner_user_id,
        };

        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .delete_big_fish_work_then(procedure_input, move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_works_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }

    pub async fn submit_big_fish_message(
        &self,
        input: BigFishMessageSubmitRecordInput,
    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
        let procedure_input = BigFishMessageSubmitInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            user_message_id: input.user_message_id,
            user_message_text: input.user_message_text,
            assistant_message_id: input.assistant_message_id,
            submitted_at_micros: input.submitted_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().submit_big_fish_message_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_session_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn finalize_big_fish_agent_message(
        &self,
        input: BigFishMessageFinalizeRecordInput,
    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
        let procedure_input = BigFishMessageFinalizeInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            assistant_message_id: input.assistant_message_id,
            assistant_reply_text: input.assistant_reply_text,
            stage: parse_big_fish_creation_stage(&input.stage)?,
            progress_percent: input.progress_percent,
            anchor_pack_json: input.anchor_pack_json,
            error_message: input.error_message,
            updated_at_micros: input.updated_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .finalize_big_fish_agent_message_turn_then(procedure_input, move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_session_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }

    pub async fn compile_big_fish_draft(
        &self,
        session_id: String,
        owner_user_id: String,
        compiled_at_micros: i64,
    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
        let procedure_input = BigFishDraftCompileInput {
            session_id,
            owner_user_id,
            compiled_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().compile_big_fish_draft_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_session_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn generate_big_fish_asset(
        &self,
        input: BigFishAssetGenerateRecordInput,
    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
        let procedure_input = BigFishAssetGenerateInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            asset_kind: input.asset_kind.as_str().try_into()?,
            level: input.level,
            motion_key: input.motion_key,
            asset_url: input.asset_url,
            generated_at_micros: input.generated_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().generate_big_fish_asset_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_session_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn publish_big_fish_game(
        &self,
        session_id: String,
        owner_user_id: String,
        published_at_micros: i64,
    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
        let procedure_input = BigFishPublishInput {
            session_id,
            owner_user_id,
            published_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().publish_big_fish_game_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_session_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn start_big_fish_run(
        &self,
        input: BigFishRunStartRecordInput,
    ) -> Result<BigFishRuntimeRecord, SpacetimeClientError> {
        let procedure_input = BigFishRunStartInput {
            run_id: input.run_id,
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            started_at_micros: input.started_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .start_big_fish_run_then(procedure_input, move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_run_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }

    pub async fn submit_big_fish_input(
        &self,
        input: BigFishRunInputSubmitRecordInput,
    ) -> Result<BigFishRuntimeRecord, SpacetimeClientError> {
        let procedure_input = BigFishRunInputSubmitInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            input_x: input.input_x,
            input_y: input.input_y,
            submitted_at_micros: input.submitted_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().submit_big_fish_input_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_run_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn get_big_fish_run(
        &self,
        run_id: String,
        owner_user_id: String,
    ) -> Result<BigFishRuntimeRecord, SpacetimeClientError> {
        let procedure_input = BigFishRunGetInput {
            run_id,
            owner_user_id,
        };

        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .get_big_fish_run_then(procedure_input, move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_big_fish_run_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }
}