use super::*;
use crate::mapper::*;
use crate::module_bindings::delete_puzzle_work_procedure::delete_puzzle_work;

impl SpacetimeClient {
    pub async fn create_puzzle_agent_session(
        &self,
        input: PuzzleAgentSessionCreateRecordInput,
    ) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = PuzzleAgentSessionCreateInput {
            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_puzzle_agent_session_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_puzzle_agent_session_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn get_puzzle_agent_session(
        &self,
        session_id: String,
        owner_user_id: String,
    ) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = PuzzleAgentSessionGetInput {
            session_id,
            owner_user_id,
        };

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

    pub async fn submit_puzzle_agent_message(
        &self,
        input: PuzzleAgentMessageSubmitRecordInput,
    ) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = PuzzleAgentMessageSubmitInput {
            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(move |connection, sender| {
            connection.procedures().submit_puzzle_agent_message_then(
                procedure_input,
                move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_puzzle_agent_session_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn finalize_puzzle_agent_message(
        &self,
        input: PuzzleAgentMessageFinalizeRecordInput,
    ) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = PuzzleAgentMessageFinalizeInput {
            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_puzzle_agent_stage_record(input.stage.as_str())?,
            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_puzzle_agent_message_turn_then(procedure_input, move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_puzzle_agent_session_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }

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

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

    pub async fn save_puzzle_generated_images(
        &self,
        input: PuzzleGeneratedImagesSaveRecordInput,
    ) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = PuzzleGeneratedImagesSaveInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            candidates_json: input.candidates_json,
            saved_at_micros: input.saved_at_micros,
        };

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

    pub async fn select_puzzle_cover_image(
        &self,
        input: PuzzleSelectCoverImageRecordInput,
    ) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = PuzzleSelectCoverImageInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            candidate_id: input.candidate_id,
            selected_at_micros: input.selected_at_micros,
        };

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

    pub async fn publish_puzzle_work(
        &self,
        input: PuzzlePublishRecordInput,
    ) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = PuzzlePublishInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            work_id: input.work_id,
            profile_id: input.profile_id,
            author_display_name: input.author_display_name,
            level_name: input.level_name,
            summary: input.summary,
            theme_tags: input.theme_tags,
            published_at_micros: input.published_at_micros,
        };

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

    pub async fn list_puzzle_works(
        &self,
        owner_user_id: String,
    ) -> Result<Vec<PuzzleWorkProfileRecord>, SpacetimeClientError> {
        let procedure_input = PuzzleWorksListInput { owner_user_id };

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

    pub async fn get_puzzle_work_detail(
        &self,
        profile_id: String,
    ) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = PuzzleWorkGetInput { profile_id };

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

    pub async fn update_puzzle_work(
        &self,
        input: PuzzleWorkUpsertRecordInput,
    ) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = PuzzleWorkUpsertInput {
            profile_id: input.profile_id,
            owner_user_id: input.owner_user_id,
            level_name: input.level_name,
            summary: input.summary,
            theme_tags: input.theme_tags,
            cover_image_src: input.cover_image_src,
            cover_asset_id: input.cover_asset_id,
            updated_at_micros: input.updated_at_micros,
        };

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

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

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

    pub async fn list_puzzle_gallery(
        &self,
    ) -> Result<Vec<PuzzleWorkProfileRecord>, SpacetimeClientError> {
        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .list_puzzle_gallery_then(move |_, result| {
                    let mapped = result
                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
                        .and_then(map_puzzle_works_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }

    pub async fn get_puzzle_gallery_detail(
        &self,
        profile_id: String,
    ) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = PuzzleWorkGetInput { profile_id };

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

    pub async fn start_puzzle_run(
        &self,
        input: PuzzleRunStartRecordInput,
    ) -> Result<PuzzleRunRecord, SpacetimeClientError> {
        let procedure_input = PuzzleRunStartInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            profile_id: input.profile_id,
            started_at_micros: input.started_at_micros,
        };

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

    pub async fn get_puzzle_run(
        &self,
        run_id: String,
        owner_user_id: String,
    ) -> Result<PuzzleRunRecord, SpacetimeClientError> {
        let procedure_input = PuzzleRunGetInput {
            run_id,
            owner_user_id,
        };

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

    pub async fn swap_puzzle_pieces(
        &self,
        input: PuzzleRunSwapRecordInput,
    ) -> Result<PuzzleRunRecord, SpacetimeClientError> {
        let procedure_input = PuzzleRunSwapInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            first_piece_id: input.first_piece_id,
            second_piece_id: input.second_piece_id,
            swapped_at_micros: input.swapped_at_micros,
        };

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

    pub async fn drag_puzzle_piece_or_group(
        &self,
        input: PuzzleRunDragRecordInput,
    ) -> Result<PuzzleRunRecord, SpacetimeClientError> {
        let procedure_input = PuzzleRunDragInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            piece_id: input.piece_id,
            target_row: input.target_row,
            target_col: input.target_col,
            dragged_at_micros: input.dragged_at_micros,
        };

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

    pub async fn advance_puzzle_next_level(
        &self,
        input: PuzzleRunNextLevelRecordInput,
    ) -> Result<PuzzleRunRecord, SpacetimeClientError> {
        let procedure_input = PuzzleRunNextLevelInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            advanced_at_micros: input.advanced_at_micros,
        };

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