discordipc 0.1.1

// SPDX-License-Identifier: MIT OR Apache-2.0

use serde::Serialize;
use serde_with::skip_serializing_none;
use std::time::{SystemTime, UNIX_EPOCH};

#[skip_serializing_none]
#[derive(Clone, Debug, Default, Serialize)]
pub struct Activity {
    #[serde(rename = "type")]
    pub kind: ActivityType,
    pub details: Option<String>,
    pub state: Option<String>,

    pub timestamps: Option<Timestamps>,
    pub assets: Assets,
    pub buttons: Option<Vec<Button>>,

    pub party: Option<Party>,
    pub secrets: Option<Secrets>,

    pub instance: bool,
}
impl Activity {
    /// Creates a new instance of an `Activity`.
    ///
    /// This method initializes a default `Activity` object, which can be further customized
    /// using chained methods. It is the starting point for building an activity.
    ///
    /// ## Examples
    ///
    /// Basic usage:
    ///
    /// ```rust
    /// use discordipc::activity::{Activity, ActivityType};
    ///
    /// let activity = Activity::new()
    ///     .kind(ActivityType::Playing)
    ///     .details("Ranked")
    ///     .state("In Lobby");
    /// ```
    ///
    /// Or:
    /// ```rust
    /// use discordipc::activity::{Activity, ActivityType, Button, Party, Timestamps};
    ///
    /// let activity = Activity::new()
    ///     .kind(ActivityType::Watching)
    ///     .details("song_name")
    ///     .state("In a Watch Party")
    ///     .timestamps(Timestamps::new().start_now())
    ///     .button(Button::new("Join", "https://example.com/join"))
    ///     .party(Party::new().id("party_id").size([5, 8])); // 5/8 members
    /// ```
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the activity type.
    ///
    /// ## Options
    /// - `ActivityType::Playing`
    /// - `ActivityType::Listening`
    /// - `ActivityType::Watching`
    /// - `ActivityType::Competing`
    pub fn kind(mut self, kind: ActivityType) -> Self {
        self.kind = kind;
        self
    }

    /// Sets the details of the activity.
    /// ## Parameters
    /// - `details`: The details to be shown.
    ///
    pub fn details(mut self, details: impl Into<String>) -> Self {
        self.details = Some(details.into());
        self
    }

    /// Sets the state of the activity.
    ///
    /// ## Parameters
    /// - `state`: The state to be shown.
    ///
    pub fn state(mut self, state: impl Into<String>) -> Self {
        self.state = Some(state.into());
        self
    }

    /// Adds timestamps to the activity.
    ///
    /// ## Parameters
    /// - `timestamps`: The timestamps to be added.
    pub fn timestamps(mut self, timestamps: Timestamps) -> Self {
        self.timestamps = Some(timestamps);
        self
    }

    /// Adds assets (images) to the activity.
    ///
    /// You can set both a **large image** and a **small image**.  
    /// Each image can optionally have a tooltip text that appears when hovered.
    ///
    /// ## Parameters
    /// - `assets`: The [Assets] to be added to the activity.
    ///
    /// ## Examples
    ///  Small image:
    /// ```rust
    /// use discordipc::activity::{Activity, Assets};
    ///
    /// let activity = Activity::new()
    ///     .details("Assets example")
    ///     .assets(Assets::new()
    ///         // Without large image, it uses the app logo by default.
    ///         .small_image("small_image_key", Some("Small Image Tooltip")));
    /// ```
    ///
    /// Both:
    /// ```rust
    /// use discordipc::activity::{Activity, Assets};
    ///
    /// let activity = Activity::new()
    ///     .details("Assets example")
    ///     .assets(Assets::new()
    ///         .large_image("large_image_key", Some("Large Image Tooltip"))
    ///         .small_image("small_image_key", None));  // `None` for no tooltip.
    /// ```
    pub fn assets(mut self, assets: Assets) -> Self {
        self.assets = assets;
        self
    }

    /// Adds a button to the activity.
    ///
    /// ## Note
    /// Discord allows up to two buttons to show in the activity, adding a third button wouldn't do anything.
    ///
    /// Additionally, any existing secrets will be cleared, as secrets cannot currently be sent with buttons.
    ///
    /// ## Parameters
    /// - `button`: The [Button] to be added.
    ///
    /// ## Example
    /// ```rust
    /// use discordipc::activity::{Activity, Button};
    ///
    /// let activity = Activity::new()
    ///     .details("Click one of these!")
    ///     .button(Button::new("First Button", "https://example.com"))
    ///     .button(Button::new("Second Button", "https://example.com"));
    /// ```
    pub fn button(mut self, button: Button) -> Self {
        if let Some(ref mut buttons) = self.buttons {
            // there can only be up to 2 buttons
            if buttons.len() < 2 {
                buttons.push(button);
            }
        } else {
            self.buttons = Some(vec![button]);
        }

        self.secrets = None; // secrets cannot currently be sent with buttons
        self
    }

    /// Adds a party to the activity.
    ///
    /// An activity with a party can have multiple users participating in it.
    ///
    /// ### Note  
    /// When a party is added, the `state` field of the activity will be used as the party's title.  
    ///
    /// - If `state` is `None`, no title will be displayed.  
    /// - If **both** `state` and the party size are `None`, the party will not be shown at all.
    ///
    /// ## Parameters
    /// - `party`: The party to be added to the activity.
    ///
    /// ## Example:
    /// ```rust
    /// use discordipc::activity::{Activity, Party};
    ///
    /// let activity = Activity::new()
    ///     .details("Some details")
    ///     .state("In Game")
    ///     .party(Party::new().id("some_id").size([1, 5])); // 1 of 5 members
    /// ```
    pub fn party(mut self, party: Party) -> Self {
        self.party = Some(party);
        self
    }

    /// Adds secrets to the activity.  
    ///
    /// Secrets are unique, randomly generated strings used for **joining or spectating**  
    /// a multiplayer session through Discord Rich Presence.  
    ///
    /// - The **join secret** allows others to request to join the activity.  
    /// - The **spectate secret** lets users watch the session if the game supports it.  
    /// - The **match secret** identifies a specific game session.  
    ///
    ///
    /// ### Note  
    /// Any existing buttons will be **cleared**, as secrets cannot currently be sent with buttons.  
    ///
    /// ## Parameters  
    /// - `secrets`: The secrets to be added to the activity.   
    ///
    /// ## Example  
    /// ```rust
    /// use discordipc::activity::{Activity, Party, Secrets};
    ///
    /// let secrets = Secrets::new()
    ///     .join("join_secret123")
    ///     .spectate("spectate_secret456");
    ///
    /// let activity = Activity::new()
    ///     .instance(true)
    ///     .party(Party::new().size([1, 5]))
    ///     .secrets(secrets);
    /// ```
    pub fn secrets(mut self, secrets: Secrets) -> Self {
        self.secrets = Some(secrets);
        self.buttons = None; // secrets cannot currently be sent with buttons
        self
    }

    /// Sets whether the activity is an instance.  
    ///
    /// When an activity is marked as an **instance**, it means that it represents  
    /// a **specific session** rather than a general activity.  
    ///
    /// For example, a multiplayer game session would be considered an
    /// instance, whereas simply "Playing a Game" would not.  
    ///
    ///
    /// **Setting this to `true` allows features like:**  
    /// - Joining or spectating the session (if supported).  
    /// - Improved party-related features in Discord Rich Presence.  
    ///
    /// ## Parameters  
    /// - `instance`: `true` if this activity should be considered an instance, `false` otherwise.  
    ///
    /// ## Example  
    /// ```rust
    /// use discordipc::activity::{Activity, Party, Secrets};
    ///
    /// let activity = Activity::new()
    ///     .instance(true)
    ///     .party(Party::new().size([1, 5]))
    ///     .secrets(Secrets::new());
    /// ```
    pub fn instance(mut self, instance: bool) -> Self {
        self.instance = instance;
        self
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize)]
#[serde(into = "u8")]
#[repr(u8)]
pub enum ActivityType {
    #[default]
    Playing = 0,
    Listening = 2,
    Watching = 3,
    Competing = 5,
}
impl From<ActivityType> for u8 {
    fn from(value: ActivityType) -> Self {
        value as u8
    }
}

#[skip_serializing_none]
#[derive(Clone, Debug, Default, Serialize)]
pub struct Timestamps {
    pub start: Option<i64>,
    pub end: Option<i64>,
}
impl Timestamps {
    pub fn new() -> Self {
        Self::default()
    }

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

    pub fn start_now(mut self) -> Self {
        self.start = Some(Self::now());
        self
    }

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

    pub fn end_now(mut self) -> Self {
        self.end = Some(Self::now());
        self
    }

    fn now() -> i64 {
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs() as i64
    }
}

#[skip_serializing_none]
#[derive(Clone, Debug, Default, Serialize)]
pub struct Assets {
    pub large_image: Option<String>,
    pub large_text: Option<String>,

    pub small_image: Option<String>,
    pub small_text: Option<String>,
}
impl Assets {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn large_image<S: Into<String>>(mut self, image_key: S, text: Option<S>) -> Self {
        self.large_image = Some(image_key.into());
        self.large_text = text.map(|text| text.into());
        self
    }

    pub fn small_image<S: Into<String>>(mut self, image_key: S, text: Option<S>) -> Self {
        self.small_image = Some(image_key.into());
        self.small_text = text.map(|text| text.into());
        self
    }
}

#[skip_serializing_none]
#[derive(Clone, Debug, Serialize)]
pub struct Button {
    pub label: String,
    pub url: String,
}
impl Button {
    pub fn new(label: impl Into<String>, url: impl Into<String>) -> Self {
        Button {
            label: label.into(),
            url: url.into(),
        }
    }
}

#[skip_serializing_none]
#[derive(Clone, Debug, Default, Serialize)]
pub struct Party {
    pub id: Option<String>,
    pub size: Option<[u32; 2]>,
}
impl Party {
    pub fn new() -> Self {
        Self::default()
    }

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

    pub fn size(mut self, size: [u32; 2]) -> Self {
        self.size = Some(size);
        self
    }

    pub fn current_size(mut self, current_size: u32) -> Self {
        if let Some(mut size) = self.size {
            size[0] = current_size.max(1);
        } else {
            self.size = Some([current_size.max(1), 0])
        }
        self
    }

    pub fn max_size(mut self, max_size: u32) -> Self {
        if let Some(mut size) = self.size {
            size[1] = max_size.max(1);
        } else {
            self.size = Some([0, max_size.max(1)])
        }
        self
    }
}

#[skip_serializing_none]
#[derive(Clone, Debug, Default, Serialize)]
pub struct Secrets {
    pub join: Option<String>,
    pub spectate: Option<String>,
    #[serde(rename = "match")]
    pub match_: Option<String>,
}
impl Secrets {
    pub fn new() -> Self {
        Self::default()
    }

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

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

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