use super::*;
use crate::mapper::*;
use crate::module_bindings::claim_puzzle_work_point_incentive_procedure::claim_puzzle_work_point_incentive;
use crate::module_bindings::delete_puzzle_work_procedure::delete_puzzle_work;
use crate::module_bindings::record_puzzle_work_like_procedure::record_puzzle_work_like;
use crate::module_bindings::remix_puzzle_work_procedure::remix_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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .and_then(map_puzzle_agent_session_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn save_puzzle_form_draft(
        &self,
        input: PuzzleFormDraftSaveRecordInput,
    ) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = PuzzleFormDraftSaveInput {
            session_id: input.session_id,
            owner_user_id: input.owner_user_id,
            seed_text: input.seed_text,
            saved_at_micros: input.saved_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().save_puzzle_form_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 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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .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,
            level_id: input.level_id,
            levels_json: input.levels_json,
            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(SpacetimeClientError::from_sdk_error)
                        .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,
            level_id: input.level_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(SpacetimeClientError::from_sdk_error)
                        .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,
            work_title: input.work_title,
            work_description: input.work_description,
            level_name: input.level_name,
            summary: input.summary,
            theme_tags: input.theme_tags,
            levels_json: input.levels_json,
            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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .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,
            work_title: input.work_title,
            work_description: input.work_description,
            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,
            levels_json: input.levels_json,
            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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .and_then(map_puzzle_works_procedure_result);
                    send_once(&sender, mapped);
                });
        })
        .await
    }

    pub async fn claim_puzzle_work_point_incentive(
        &self,
        input: PuzzleWorkPointIncentiveClaimRecordInput,
    ) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = PuzzleWorkPointIncentiveClaimInput {
            profile_id: input.profile_id,
            owner_user_id: input.owner_user_id,
            claimed_at_micros: input.claimed_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .claim_puzzle_work_point_incentive_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_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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .and_then(map_puzzle_work_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn record_puzzle_work_like(
        &self,
        input: PuzzleWorkLikeReportRecordInput,
    ) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
        let procedure_input = PuzzleWorkLikeRecordInput {
            profile_id: input.profile_id,
            user_id: input.user_id,
            liked_at_micros: input.liked_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().record_puzzle_work_like_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 remix_puzzle_work(
        &self,
        input: PuzzleWorkRemixRecordInput,
    ) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
        let procedure_input = PuzzleWorkRemixInput {
            source_profile_id: input.source_profile_id,
            target_owner_user_id: input.target_owner_user_id,
            target_session_id: input.target_session_id,
            target_profile_id: input.target_profile_id,
            target_work_id: input.target_work_id,
            author_display_name: input.author_display_name,
            welcome_message_id: input.welcome_message_id,
            remixed_at_micros: input.remixed_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection
                .procedures()
                .remix_puzzle_work_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 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,
            level_id: input.level_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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .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(SpacetimeClientError::from_sdk_error)
                        .and_then(map_puzzle_run_procedure_result);
                    send_once(&sender, mapped);
                },
            );
        })
        .await
    }

    pub async fn update_puzzle_run_pause(
        &self,
        input: PuzzleRunPauseRecordInput,
    ) -> Result<PuzzleRunRecord, SpacetimeClientError> {
        let procedure_input = PuzzleRunPauseInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            paused: input.paused,
            updated_at_micros: input.updated_at_micros,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().update_puzzle_run_pause_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 use_puzzle_runtime_prop(
        &self,
        input: PuzzleRunPropRecordInput,
    ) -> Result<PuzzleRunRecord, SpacetimeClientError> {
        let procedure_input = PuzzleRunPropInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            prop_kind: input.prop_kind,
            used_at_micros: input.used_at_micros,
            spent_points: input.spent_points,
        };

        self.call_after_connect(move |connection, sender| {
            connection.procedures().use_puzzle_runtime_prop_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 submit_puzzle_leaderboard_entry(
        &self,
        input: PuzzleLeaderboardSubmitRecordInput,
    ) -> Result<PuzzleRunRecord, SpacetimeClientError> {
        let procedure_input = PuzzleLeaderboardSubmitInput {
            run_id: input.run_id,
            owner_user_id: input.owner_user_id,
            profile_id: input.profile_id,
            grid_size: input.grid_size,
            elapsed_ms: input.elapsed_ms,
            nickname: input.nickname,
            submitted_at_micros: input.submitted_at_micros,
        };

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