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

use super::*;
use crate::mapper::{
    VisualNovelAgentMessageFinalizeRecordInput, VisualNovelAgentMessageSubmitRecordInput,
    VisualNovelAgentSessionCreateRecordInput, VisualNovelAgentSessionRecord,
    VisualNovelHistoryEntryRecord, VisualNovelHistoryEntryRecordInput, VisualNovelRunRecord,
    VisualNovelRunSnapshotRecordInput, VisualNovelRunStartRecordInput,
    VisualNovelRuntimeEventRecord, VisualNovelWorkCompileRecordInput, VisualNovelWorkProfileRecord,
    VisualNovelWorkUpdateRecordInput, map_visual_novel_agent_session_procedure_result,
    map_visual_novel_gallery_view_row, map_visual_novel_history_procedure_result,
    map_visual_novel_run_procedure_result, map_visual_novel_runtime_event_procedure_result,
    map_visual_novel_work_procedure_result, map_visual_novel_works_procedure_result,
};

impl SpacetimeClient {
    pub async fn create_visual_novel_agent_session(
        &self,
        input: VisualNovelAgentSessionCreateRecordInput,
    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelAgentSessionCreateInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            source_mode: input.source_mode,
            seed_text: input.seed_text,
            source_asset_ids_json: input.source_asset_ids_json,
            welcome_message_id: input.welcome_message_id,
            welcome_message_text: input.welcome_message_text,
            draft_json: input.draft_json,
            created_at_micros: input.created_at_micros,
        };

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

    pub async fn get_visual_novel_agent_session(
        &self,
        session_id: String,
        owner_user_id: String,
    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelAgentSessionGetInput {
            session_id,
            owner_user_id,
        };

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

    pub async fn submit_visual_novel_agent_message(
        &self,
        input: VisualNovelAgentMessageSubmitRecordInput,
    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelAgentMessageSubmitInput {
            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,
            submitted_at_micros: input.submitted_at_micros,
        };

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

    pub async fn finalize_visual_novel_agent_message(
        &self,
        input: VisualNovelAgentMessageFinalizeRecordInput,
    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelAgentMessageFinalizeInput {
            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,
            draft_json: input.draft_json,
            pending_action_json: input.pending_action_json,
            status: input.status,
            progress_percent: input.progress_percent,
            updated_at_micros: input.updated_at_micros,
            error_message: input.error_message,
        };

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

    pub async fn compile_visual_novel_work_profile(
        &self,
        input: VisualNovelWorkCompileRecordInput,
    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelWorkCompileInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            profile_id: input.profile_id,
            work_id: input.work_id,
            author_display_name: input.author_display_name,
            work_title: input.work_title,
            work_description: input.work_description,
            tags_json: input.tags_json,
            cover_image_src: input.cover_image_src,
            compiled_at_micros: input.compiled_at_micros,
        };

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

    pub async fn update_visual_novel_work(
        &self,
        input: VisualNovelWorkUpdateRecordInput,
    ) -> Result<VisualNovelWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelWorkUpdateInput {
            profile_id: input.profile_id,
            owner_user_id: input.owner_user_id,
            work_title: input.work_title,
            work_description: input.work_description,
            tags_json: input.tags_json,
            cover_image_src: input.cover_image_src,
            source_asset_ids_json: input.source_asset_ids_json,
            draft_json: input.draft_json,
            publish_ready: input.publish_ready,
            updated_at_micros: input.updated_at_micros,
        };

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

    pub async fn publish_visual_novel_work(
        &self,
        profile_id: String,
        owner_user_id: String,
        published_at_micros: i64,
    ) -> Result<VisualNovelWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelWorkPublishInput {
            profile_id,
            owner_user_id,
            published_at_micros,
        };

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

    pub async fn list_visual_novel_works(
        &self,
        owner_user_id: String,
    ) -> Result<Vec<VisualNovelWorkProfileRecord>, SpacetimeClientError> {
        self.list_visual_novel_works_with_input(VisualNovelWorksListInput {
            owner_user_id,
            published_only: false,
        })
        .await
    }

    pub async fn list_visual_novel_gallery(
        &self,
    ) -> Result<Vec<VisualNovelWorkProfileRecord>, SpacetimeClientError> {
        self.read_after_connect("list_visual_novel_gallery", move |connection| {
            let mut items = connection
                .db()
                .visual_novel_gallery_view()
                .iter()
                .collect::<Vec<_>>();
            items.sort_by(|left, right| {
                right
                    .updated_at_micros
                    .cmp(&left.updated_at_micros)
                    .then_with(|| left.profile_id.cmp(&right.profile_id))
            });
            Ok(items
                .into_iter()
                .map(map_visual_novel_gallery_view_row)
                .collect())
        })
        .await
    }

    async fn list_visual_novel_works_with_input(
        &self,
        procedure_input: VisualNovelWorksListInput,
    ) -> Result<Vec<VisualNovelWorkProfileRecord>, SpacetimeClientError> {
        self.call_after_connect("list_visual_novel_works", move |connection, sender| {
            connection.procedures().list_visual_novel_works_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_visual_novel_works_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn get_visual_novel_work_detail(
        &self,
        profile_id: String,
        owner_user_id: String,
    ) -> Result<VisualNovelWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelWorkGetInput {
            profile_id,
            owner_user_id,
        };

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

    pub async fn delete_visual_novel_work(
        &self,
        profile_id: String,
        owner_user_id: String,
    ) -> Result<Vec<VisualNovelWorkProfileRecord>, SpacetimeClientError> {
        let procedure_input = VisualNovelWorkDeleteInput {
            profile_id,
            owner_user_id,
        };

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

    pub async fn start_visual_novel_run(
        &self,
        input: VisualNovelRunStartRecordInput,
    ) -> Result<VisualNovelRunRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelRunStartInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            profile_id: input.profile_id,
            mode: input.mode,
            snapshot_json: input.snapshot_json,
            started_at_micros: input.started_at_micros,
        };

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

    pub async fn get_visual_novel_run(
        &self,
        run_id: String,
        owner_user_id: String,
    ) -> Result<VisualNovelRunRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelRunGetInput {
            run_id,
            owner_user_id,
        };

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

    pub async fn upsert_visual_novel_run_snapshot(
        &self,
        input: VisualNovelRunSnapshotRecordInput,
    ) -> Result<VisualNovelRunRecord, SpacetimeClientError> {
        let procedure_input = VisualNovelRunSnapshotUpsertInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            status: input.status,
            current_scene_id: input.current_scene_id,
            current_phase_id: input.current_phase_id,
            visible_character_ids_json: input.visible_character_ids_json,
            flags_json: input.flags_json,
            metrics_json: input.metrics_json,
            available_choices_json: input.available_choices_json,
            text_mode_enabled: input.text_mode_enabled,
            snapshot_json: input.snapshot_json,
            updated_at_micros: input.updated_at_micros,
        };

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

    pub async fn append_visual_novel_runtime_history_entry(
        &self,
        input: VisualNovelHistoryEntryRecordInput,
    ) -> Result<Vec<VisualNovelHistoryEntryRecord>, SpacetimeClientError> {
        let procedure_input = VisualNovelRuntimeHistoryAppendInput {
            entry_id: input.entry_id,
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            turn_index: input.turn_index,
            source: input.source,
            action_text: input.action_text,
            steps_json: input.steps_json,
            snapshot_before_hash: input.snapshot_before_hash,
            snapshot_after_hash: input.snapshot_after_hash,
            created_at_micros: input.created_at_micros,
        };

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

    pub async fn list_visual_novel_runtime_history(
        &self,
        run_id: String,
        owner_user_id: String,
    ) -> Result<Vec<VisualNovelHistoryEntryRecord>, SpacetimeClientError> {
        let procedure_input = VisualNovelRuntimeHistoryListInput {
            run_id,
            owner_user_id,
        };

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

    pub async fn record_visual_novel_runtime_event(
        &self,
        input: crate::mapper::VisualNovelRuntimeEventRecordInput,
    ) -> Result<VisualNovelRuntimeEventRecord, SpacetimeClientError> {
        let procedure_input = crate::module_bindings::VisualNovelRuntimeEventRecordInput {
            event_id: input.event_id,
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            profile_id: input.profile_id,
            event_kind: input.event_kind,
            client_event_id: input.client_event_id,
            history_entry_id: input.history_entry_id,
            payload_json: input.payload_json,
            occurred_at_micros: input.occurred_at_micros,
        };

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