use super::*;

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

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

    pub async fn get_recent_editor_project(
        &self,
        owner_user_id: String,
    ) -> Result<Option<EditorProjectRecord>, SpacetimeClientError> {
        let procedure_input = EditorProjectGetRecentInput { owner_user_id };

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

    pub async fn get_editor_project(
        &self,
        input: EditorProjectGetRecordInput,
    ) -> Result<EditorProjectRecord, SpacetimeClientError> {
        let procedure_input = input.into();

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

    pub async fn save_editor_project_layout(
        &self,
        input: EditorProjectLayoutSaveRecordInput,
    ) -> Result<EditorProjectRecord, SpacetimeClientError> {
        let procedure_input = input.into();

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

    pub async fn create_editor_project_resource(
        &self,
        input: EditorProjectResourceCreateRecordInput,
    ) -> Result<EditorProjectResourceRecord, SpacetimeClientError> {
        let procedure_input = input.into();

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