twitch_highway 0.2.1

use serde::Serialize;

use crate::types::BroadcasterId;

define_request!(
    #[derive(Serialize)]
    SendChatMessageRequest<'a> {
        req: {
            broadcaster_id: &'a BroadcasterId,
            sender_id: &'a str,
            message: &'a str
        },
        opts: {
            #[serde(skip_serializing_if = "Option::is_none")]
            for_source_only: bool,
            #[serde(skip_serializing_if = "Option::is_none")]
            reply_parent_message_id: &'a str | into
        };
        into_json
    }
);

define_request!(
    /// <https://dev.twitch.tv/docs/api/reference/#update-chat-settings>
    #[derive(Default, Serialize)]
    UpdateChatSettingsRequest {
        opts: {
            #[serde(skip_serializing_if = "Option::is_none")]
            emote_mode: bool,
            #[serde(skip_serializing_if = "Option::is_none")]
            follower_mode: bool,
            #[serde(skip_serializing_if = "Option::is_none")]
            follower_mode_duration: u64,
            #[serde(skip_serializing_if = "Option::is_none")]
            non_moderator_chat_delay: bool,
            #[serde(skip_serializing_if = "Option::is_none")]
            non_moderator_chat_delay_duration: u64,
            #[serde(skip_serializing_if = "Option::is_none")]
            slow_mode: bool,
            #[serde(skip_serializing_if = "Option::is_none")]
            slow_mode_wait_time: u64,
            #[serde(skip_serializing_if = "Option::is_none")]
            subscriber_mode: bool,
            #[serde(skip_serializing_if = "Option::is_none")]
            unique_chat_mode: bool,
        };
        into_json
    }
);

#[derive(Debug, Serialize)]
pub enum ChatColor {
    Blue,
    BlueViolet,
    CadetBlue,
    Chocolate,
    Coral,
    DodgerBlue,
    Firebrick,
    GoldenRod,
    Green,
    HotPink,
    OrangeRed,
    Red,
    SeaGreen,
    SpringGreen,
    YellowGreen,
}

impl ChatColor {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Blue => "blue",
            Self::BlueViolet => "blue_violet",
            Self::CadetBlue => "cadet_blue",
            Self::Chocolate => "chocolate",
            Self::Coral => "coral",
            Self::DodgerBlue => "dodger_blue",
            Self::Firebrick => "firebrick",
            Self::GoldenRod => "golden_rod",
            Self::Green => "green",
            Self::HotPink => "hot_pink",
            Self::OrangeRed => "orange_red",
            Self::Red => "red",
            Self::SeaGreen => "sea_green",
            Self::SpringGreen => "spring_green",
            Self::YellowGreen => "yellow_green",
        }
    }
}

define_request!(
    #[derive(Serialize)]
    ChatAnnouncementBody<'a> {
        req: {
            message: &'a str,
            color: Option<AnnouncementColor>
        };
        into_json
    }
);

#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum AnnouncementColor {
    Blue,
    Green,
    Orange,
    Purple,
    Primary,
}

impl AnnouncementColor {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Blue => "blue",
            Self::Green => "green",
            Self::Orange => "orange",
            Self::Purple => "purple",
            Self::Primary => "primary",
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::chat::request::{AnnouncementColor, ChatColor};

    #[test]
    fn chat_color_enum() {
        let colors = vec![
            (ChatColor::Blue, "blue"),
            (ChatColor::BlueViolet, "blue_violet"),
            (ChatColor::CadetBlue, "cadet_blue"),
            (ChatColor::Chocolate, "chocolate"),
            (ChatColor::Coral, "coral"),
            (ChatColor::DodgerBlue, "dodger_blue"),
            (ChatColor::Firebrick, "firebrick"),
            (ChatColor::GoldenRod, "golden_rod"),
            (ChatColor::Green, "green"),
            (ChatColor::HotPink, "hot_pink"),
            (ChatColor::OrangeRed, "orange_red"),
            (ChatColor::Red, "red"),
            (ChatColor::SeaGreen, "sea_green"),
            (ChatColor::SpringGreen, "spring_green"),
            (ChatColor::YellowGreen, "yellow_green"),
        ];

        for (color, expected_str) in colors {
            assert_eq!(color.as_str(), expected_str);
        }
    }

    #[test]
    fn announcement_color_enum() {
        let colors = vec![
            (AnnouncementColor::Blue, "blue"),
            (AnnouncementColor::Green, "green"),
            (AnnouncementColor::Orange, "orange"),
            (AnnouncementColor::Purple, "purple"),
            (AnnouncementColor::Primary, "primary"),
        ];

        for (color, expected_str) in colors {
            assert_eq!(color.as_str(), expected_str);
        }

        let color = AnnouncementColor::Purple;
        let serialized = serde_json::to_string(&color).unwrap();
        assert_eq!(serialized, "\"purple\"");
    }
}