refluxer 0.2.0

use serde::{Deserialize, Serialize};

use crate::error::HttpError;
use crate::http::client::HttpClient;
use crate::http::routing::Route;
use crate::model::emoji::Emoji;
use crate::model::id::GuildId;
use crate::model::sticker::Sticker;

impl HttpClient {
    pub async fn list_guild_emojis(
        &self,
        guild_id: GuildId,
    ) -> Result<ListGuildEmojisResponse, HttpError> {
        self.request_no_body(Route::ListGuildEmojis { guild_id })
            .await
    }

    /// Create a guild emoji. `image` must be a data URI
    /// (`data:image/png;base64,...`) per the Fluxer `Base64ImageType` schema.
    pub async fn create_guild_emoji(
        &self,
        guild_id: GuildId,
        params: &CreateGuildEmoji,
    ) -> Result<Emoji, HttpError> {
        self.request(Route::CreateGuildEmoji { guild_id }, Some(params))
            .await
    }

    pub async fn update_guild_emoji(
        &self,
        guild_id: GuildId,
        emoji_id: impl Into<String>,
        params: &UpdateGuildEmoji,
    ) -> Result<Emoji, HttpError> {
        self.request(
            Route::UpdateGuildEmoji {
                guild_id,
                emoji_id: emoji_id.into(),
            },
            Some(params),
        )
        .await
    }

    pub async fn delete_guild_emoji(
        &self,
        guild_id: GuildId,
        emoji_id: impl Into<String>,
    ) -> Result<(), HttpError> {
        self.request_empty(
            Route::DeleteGuildEmoji {
                guild_id,
                emoji_id: emoji_id.into(),
            },
            None::<&()>,
        )
        .await
    }

    /// Create up to 50 guild emojis in a single request.
    pub async fn bulk_create_guild_emojis(
        &self,
        guild_id: GuildId,
        emojis: &[CreateGuildEmoji],
    ) -> Result<serde_json::Value, HttpError> {
        #[derive(Serialize)]
        struct Body<'a> {
            emojis: &'a [CreateGuildEmoji],
        }
        self.request(
            Route::BulkCreateGuildEmojis { guild_id },
            Some(&Body { emojis }),
        )
        .await
    }

    /// Create up to 50 guild stickers in a single request.
    pub async fn bulk_create_guild_stickers(
        &self,
        guild_id: GuildId,
        stickers: &[CreateGuildSticker],
    ) -> Result<serde_json::Value, HttpError> {
        #[derive(Serialize)]
        struct Body<'a> {
            stickers: &'a [CreateGuildSticker],
        }
        self.request(
            Route::BulkCreateGuildStickers { guild_id },
            Some(&Body { stickers }),
        )
        .await
    }

    pub async fn list_guild_stickers(
        &self,
        guild_id: GuildId,
    ) -> Result<ListGuildStickersResponse, HttpError> {
        self.request_no_body(Route::ListGuildStickers { guild_id })
            .await
    }

    /// Create a guild sticker. `image` is a `Base64ImageType` data URI.
    /// The server accepts this as JSON (not multipart) in the v1 Fluxer API.
    pub async fn create_guild_sticker(
        &self,
        guild_id: GuildId,
        params: &CreateGuildSticker,
    ) -> Result<Sticker, HttpError> {
        self.request(Route::CreateGuildSticker { guild_id }, Some(params))
            .await
    }

    pub async fn update_guild_sticker(
        &self,
        guild_id: GuildId,
        sticker_id: impl Into<String>,
        params: &UpdateGuildSticker,
    ) -> Result<Sticker, HttpError> {
        self.request(
            Route::UpdateGuildSticker {
                guild_id,
                sticker_id: sticker_id.into(),
            },
            Some(params),
        )
        .await
    }

    pub async fn delete_guild_sticker(
        &self,
        guild_id: GuildId,
        sticker_id: impl Into<String>,
    ) -> Result<(), HttpError> {
        self.request_empty(
            Route::DeleteGuildSticker {
                guild_id,
                sticker_id: sticker_id.into(),
            },
            None::<&()>,
        )
        .await
    }
}

#[derive(Debug, Clone, Deserialize)]
pub struct ListGuildEmojisResponse {
    pub guild_id: GuildId,
    pub emojis: Vec<Emoji>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct ListGuildStickersResponse {
    pub guild_id: GuildId,
    pub stickers: Vec<Sticker>,
}

#[derive(Debug, Serialize)]
pub struct CreateGuildEmoji {
    pub name: String,
    /// Base64-encoded image as a data URI, e.g.
    /// `data:image/png;base64,iVBORw0KGgo...`.
    pub image: String,
}

#[derive(Debug, Serialize)]
pub struct UpdateGuildEmoji {
    pub name: String,
}

#[derive(Debug, Serialize)]
pub struct CreateGuildSticker {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub tags: Vec<String>,
    /// Base64-encoded image as a data URI.
    pub image: String,
}

#[derive(Debug, Default, Serialize)]
pub struct UpdateGuildSticker {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub tags: Vec<String>,
}