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::guild::Role;
use crate::model::id::{GuildId, RoleId, UserId};
use crate::model::permissions::Permissions;
use crate::model::user::User;

// ---------------------------------------------------------------------------
// Bans
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Deserialize)]
pub struct Ban {
    pub user: User,
    pub reason: Option<String>,
}

#[derive(Debug, Default, Serialize)]
pub struct CreateBan {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delete_message_seconds: Option<u32>,
}

impl CreateBan {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn reason(mut self, reason: impl Into<String>) -> Self {
        self.reason = Some(reason.into());
        self
    }

    pub fn delete_message_seconds(mut self, seconds: u32) -> Self {
        self.delete_message_seconds = Some(seconds);
        self
    }
}

impl HttpClient {
    pub async fn get_guild_bans(&self, guild_id: GuildId) -> Result<Vec<Ban>, HttpError> {
        self.request_no_body(Route::GetGuildBans { guild_id }).await
    }

    pub async fn get_guild_ban(
        &self,
        guild_id: GuildId,
        user_id: UserId,
    ) -> Result<Ban, HttpError> {
        self.request_no_body(Route::GetGuildBan { guild_id, user_id })
            .await
    }

    pub async fn create_guild_ban(
        &self,
        guild_id: GuildId,
        user_id: UserId,
        params: &CreateBan,
    ) -> Result<(), HttpError> {
        self.request_empty(Route::CreateGuildBan { guild_id, user_id }, Some(params))
            .await
    }

    pub async fn remove_guild_ban(
        &self,
        guild_id: GuildId,
        user_id: UserId,
    ) -> Result<(), HttpError> {
        self.request_empty(Route::RemoveGuildBan { guild_id, user_id }, None::<&()>)
            .await
    }

    /// Kick a member from the guild.
    pub async fn remove_guild_member(
        &self,
        guild_id: GuildId,
        user_id: UserId,
    ) -> Result<(), HttpError> {
        self.request_empty(Route::RemoveGuildMember { guild_id, user_id }, None::<&()>)
            .await
    }
}

// ---------------------------------------------------------------------------
// Roles
// ---------------------------------------------------------------------------

#[derive(Debug, Default, Serialize)]
pub struct CreateRole {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub permissions: Option<Permissions>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub color: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hoist: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mentionable: Option<bool>,
}

impl CreateRole {
    pub fn new(name: impl Into<String>) -> Self {
        Self {
            name: Some(name.into()),
            ..Default::default()
        }
    }

    pub fn permissions(mut self, permissions: Permissions) -> Self {
        self.permissions = Some(permissions);
        self
    }

    pub fn color(mut self, color: i32) -> Self {
        self.color = Some(color);
        self
    }

    pub fn hoist(mut self, hoist: bool) -> Self {
        self.hoist = Some(hoist);
        self
    }

    pub fn mentionable(mut self, mentionable: bool) -> Self {
        self.mentionable = Some(mentionable);
        self
    }
}

#[derive(Debug, Default, Serialize)]
pub struct ModifyRole {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub permissions: Option<Permissions>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub color: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hoist: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mentionable: Option<bool>,
}

impl ModifyRole {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn name(mut self, name: impl Into<String>) -> Self {
        self.name = Some(name.into());
        self
    }

    pub fn permissions(mut self, permissions: Permissions) -> Self {
        self.permissions = Some(permissions);
        self
    }

    pub fn color(mut self, color: i32) -> Self {
        self.color = Some(color);
        self
    }

    pub fn hoist(mut self, hoist: bool) -> Self {
        self.hoist = Some(hoist);
        self
    }

    pub fn mentionable(mut self, mentionable: bool) -> Self {
        self.mentionable = Some(mentionable);
        self
    }
}

impl HttpClient {
    pub async fn get_guild_roles(&self, guild_id: GuildId) -> Result<Vec<Role>, HttpError> {
        self.request_no_body(Route::GetGuildRoles { guild_id })
            .await
    }

    pub async fn create_guild_role(
        &self,
        guild_id: GuildId,
        params: &CreateRole,
    ) -> Result<Role, HttpError> {
        self.request(Route::CreateGuildRole { guild_id }, Some(params))
            .await
    }

    pub async fn modify_guild_role(
        &self,
        guild_id: GuildId,
        role_id: RoleId,
        params: &ModifyRole,
    ) -> Result<Role, HttpError> {
        self.request(Route::ModifyGuildRole { guild_id, role_id }, Some(params))
            .await
    }

    pub async fn delete_guild_role(
        &self,
        guild_id: GuildId,
        role_id: RoleId,
    ) -> Result<(), HttpError> {
        self.request_empty(Route::DeleteGuildRole { guild_id, role_id }, None::<&()>)
            .await
    }

    pub async fn add_guild_member_role(
        &self,
        guild_id: GuildId,
        user_id: UserId,
        role_id: RoleId,
    ) -> Result<(), HttpError> {
        self.request_empty(
            Route::AddGuildMemberRole {
                guild_id,
                user_id,
                role_id,
            },
            None::<&()>,
        )
        .await
    }

    pub async fn remove_guild_member_role(
        &self,
        guild_id: GuildId,
        user_id: UserId,
        role_id: RoleId,
    ) -> Result<(), HttpError> {
        self.request_empty(
            Route::RemoveGuildMemberRole {
                guild_id,
                user_id,
                role_id,
            },
            None::<&()>,
        )
        .await
    }
}