steam-user 0.1.0

//! Profile settings types.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use steamid::SteamID;

/// Privacy state for profile elements.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
#[repr(i32)]
#[derive(Default)]
pub enum PrivacyState {
    /// Only visible to the user.
    Private = 1,
    /// Visible to friends only.
    FriendsOnly = 2,
    /// Visible to everyone.
    #[default]
    Public = 3,
}

impl From<i32> for PrivacyState {
    fn from(value: i32) -> Self {
        match value {
            1 => Self::Private,
            2 => Self::FriendsOnly,
            3 => Self::Public,
            _ => Self::Public,
        }
    }
}

/// Profile editing settings.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ProfileSettings {
    /// Display name.
    pub name: Option<String>,
    /// Real name.
    pub real_name: Option<String>,
    /// Profile summary/bio.
    pub summary: Option<String>,
    /// Country code.
    pub country: Option<String>,
    /// State/province code.
    pub state: Option<String>,
    /// City code.
    pub city: Option<String>,
    /// Custom URL (vanity URL).
    pub custom_url: Option<String>,
    /// Primary group SteamID.
    pub primary_group: Option<u64>,
}

/// Privacy settings for profile elements.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct PrivacySettings {
    /// Profile visibility.
    pub profile: Option<PrivacyState>,
    /// Comment permissions (uses different values: 0=friends, 1=anyone,
    /// 2=private).
    pub comments: Option<i32>,
    /// Inventory visibility.
    pub inventory: Option<PrivacyState>,
    /// Gift inventory visibility.
    pub inventory_gifts: Option<PrivacyState>,
    /// Game details visibility.
    pub game_details: Option<PrivacyState>,
    /// Playtime visibility.
    pub playtime: Option<PrivacyState>,
    /// Friends list visibility.
    pub friends_list: Option<PrivacyState>,
}

impl PrivacySettings {
    /// Convert to the JSON format Steam expects.
    pub fn to_steam_format(&self) -> serde_json::Value {
        serde_json::json!({
            "PrivacyProfile": self.profile.unwrap_or_default() as i32,
            "PrivacyInventory": self.inventory.unwrap_or_default() as i32,
            "PrivacyInventoryGifts": self.inventory_gifts.map(|s| s as i32).unwrap_or(3),
            "PrivacyOwnedGames": self.game_details.unwrap_or_default() as i32,
            "PrivacyPlaytime": self.playtime.map(|s| s as i32).unwrap_or(3),
            "PrivacyFriendsList": self.friends_list.unwrap_or_default() as i32,
        })
    }

    /// Parse from Steam's internal response format.
    pub fn from_steam_json(json: &serde_json::Value) -> Option<Self> {
        let privacy = json.get("PrivacySettings").or_else(|| json.get("Privacy")?.get("PrivacySettings"))?;

        let comments = json.get("eCommentPermission").or_else(|| json.get("Privacy")?.get("eCommentPermission"))?.as_i64().map(|v| v as i32);

        Some(Self {
            profile: privacy.get("PrivacyProfile").and_then(|v| v.as_i64()).map(|v| PrivacyState::from(v as i32)),
            comments,
            inventory: privacy.get("PrivacyInventory").and_then(|v| v.as_i64()).map(|v| PrivacyState::from(v as i32)),
            inventory_gifts: privacy.get("PrivacyInventoryGifts").and_then(|v| v.as_i64()).map(|v| PrivacyState::from(v as i32)),
            game_details: privacy.get("PrivacyOwnedGames").and_then(|v| v.as_i64()).map(|v| PrivacyState::from(v as i32)),
            playtime: privacy.get("PrivacyPlaytime").and_then(|v| v.as_i64()).map(|v| PrivacyState::from(v as i32)),
            friends_list: privacy.get("PrivacyFriendsList").and_then(|v| v.as_i64()).map(|v| PrivacyState::from(v as i32)),
        })
    }

    /// Merge settings from another instance, keeping Some values.
    pub fn merge(&mut self, other: PrivacySettings) {
        if other.profile.is_some() {
            self.profile = other.profile;
        }
        if other.comments.is_some() {
            self.comments = other.comments;
        }
        if other.inventory.is_some() {
            self.inventory = other.inventory;
        }
        if other.inventory_gifts.is_some() {
            self.inventory_gifts = other.inventory_gifts;
        }
        if other.game_details.is_some() {
            self.game_details = other.game_details;
        }
        if other.playtime.is_some() {
            self.playtime = other.playtime;
        }
        if other.friends_list.is_some() {
            self.friends_list = other.friends_list;
        }
    }
}

/// Parsed profile information.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SteamProfile {
    pub name: String,
    pub real_name: String,
    pub online_state: String,
    pub steam_id: SteamID,
    pub avatar_hash: String,
    pub avatar_frame: Option<String>,
    pub custom_url: String,
    pub location: String,
    pub summary: Option<String>,
    pub not_yet_setup: bool,
    pub profile_private_info: Option<String>,
    pub lobby_link: Option<String>,
    pub add_friend_enable: bool,
    pub is_private: bool,
    pub url: String,
    pub nickname: Option<String>,
    pub level: Option<u32>,
    pub day_last_ban: Option<i64>,
    pub game_ban: Option<GameBanData>,
    pub state_message_game: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct GameBanData {
    #[serde(default)]
    pub is_vac_ban: BanStatus,
    #[serde(default)]
    pub is_game_ban: BanStatus,
    #[serde(default)]
    pub is_trade_ban: bool,
    pub days_since_last_ban: Option<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
#[non_exhaustive]
pub enum BanStatus {
    #[default]
    None,
    Single,
    Multiple,
}

impl From<i32> for BanStatus {
    fn from(v: i32) -> Self {
        match v {
            1 => BanStatus::Single,
            _ => BanStatus::None,
        }
    }
}

/// Response from an avatar upload.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AvatarUploadResponse {
    /// The full URL of the uploaded avatar.
    pub url: String,
    /// The SHA hash of the uploaded avatar.
    pub hash: String,
}

/// Lightweight profile information returned by `resolve_users`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SteamUserProfile {
    #[serde(rename = "steamId")]
    pub steam_id: SteamID,
    #[serde(rename = "accountId")]
    pub account_id: u32,
    #[serde(rename = "persona_name")]
    pub name: String,
    #[serde(rename = "real_name")]
    pub real_name: String,
    #[serde(rename = "avatar_url")]
    pub avatar_hash: String,
    #[serde(rename = "profile_url")]
    pub custom_url: String,
    #[serde(rename = "persona_state")]
    pub persona_state: i32,
    pub city: String,
    pub state: String,
    pub country: String,
    #[serde(rename = "is_friend")]
    pub is_friend: bool,
    #[serde(rename = "friends_in_common")]
    pub friends_in_common: u32,
}

/// Entry in a user's avatar history.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AvatarHistoryEntry {
    /// The SHA1 hash of the avatar.
    pub avatar_sha1: String,
    /// Whether the avatar was uploaded by the user.
    pub user_uploaded: bool,
    /// The timestamp when the avatar was used.
    pub timestamp: u32,
}

/// User summary from XML profile endpoint (`/profiles/{steamid}/?xml=1`).
///
/// This represents the parsed data from Steam's XML profile format.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserSummaryXml {
    /// Display name (persona name).
    pub name: String,
    /// Real name if provided.
    pub real_name: Option<String>,
    /// 64-bit Steam ID.
    pub steam_id: SteamID,
    /// Online state: "offline", "online", "in-game".
    pub online_state: String,
    /// Parsed state message: "offline", "online", "in-game".
    pub state_message: String,
    /// Game name if in-game (Steam game).
    pub state_message_game: Option<String>,
    /// Game name if in non-Steam game.
    pub state_message_non_steam_game: Option<String>,
    /// Privacy state: "public", "private", "friendsonly".
    pub privacy_state: String,
    /// Visibility state: 1 (private), 2 (friends only), 3 (public).
    pub visibility_state: Option<i32>,
    /// Avatar hash (hash portion of avatar URL).
    pub avatar_hash: String,
    /// VAC ban status: 0 = no ban, 1+ = banned.
    pub vac_banned: Option<i32>,
    /// Trade ban state: "None" or ban description.
    pub trade_ban_state: Option<String>,
    /// Whether this is a limited account.
    pub is_limited_account: Option<bool>,
    /// Custom URL (vanity URL path).
    pub custom_url: Option<String>,
    /// Member since timestamp (Unix milliseconds).
    pub member_since: Option<i64>,
    /// Steam rating.
    pub steam_rating: Option<String>,
    /// Location string.
    pub location: Option<String>,
    /// Profile summary/bio.
    pub summary: Option<String>,
    /// Privacy message if profile is private.
    pub privacy_message: Option<String>,
    /// Whether profile has not been set up yet.
    pub not_yet_setup: bool,
}

/// User summary from HTML profile page (parsed).
///
/// This represents the parsed data from Steam's HTML profile page.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserSummaryProfile {
    /// Display name (persona name).
    pub name: String,
    /// Real name if provided.
    pub real_name: String,
    /// Online state: "offline", "online", "in-game".
    pub online_state: String,
    /// 64-bit Steam ID.
    pub steam_id: SteamID,
    /// Avatar hash.
    pub avatar_hash: String,
    /// Avatar frame URL if equipped.
    pub avatar_frame: Option<String>,
    /// Custom URL (vanity path).
    pub custom_url: String,
    /// Country location code.
    pub location: String,
    /// Profile summary/bio.
    pub summary: Option<String>,
    /// Whether profile has not been set up yet.
    pub not_yet_setup: bool,
    /// Private profile info message.
    pub profile_private_info: Option<String>,
    /// Steam lobby link if in a joinable lobby.
    pub lobby_link: Option<String>,
    /// Whether the "Add Friend" button is visible.
    pub add_friend_enable: bool,
    /// Whether the profile is private.
    pub is_private: bool,
    /// Full profile URL.
    pub url: String,
    /// Nickname set by the viewer for this user.
    pub nickname: Option<String>,
    /// Steam level.
    pub level: Option<u32>,
    /// Timestamp of last ban (Unix milliseconds).
    pub day_last_ban: Option<i64>,
    /// Game ban information.
    pub game_ban: Option<GameBanData>,
    /// Current game name if in-game.
    pub state_message_game: Option<String>,
}

/// Steam Community online state, as reported by the public profile XML.
///
/// `Other` covers any state Valve adds in the future without breaking
/// downstream code (Snooze, Looking to Trade, etc.).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OnlineState {
    Online,
    Offline,
    InGame,
    Snooze,
    Busy,
    Away,
    LookingToTrade,
    LookingToPlay,
    Other(String),
}

impl OnlineState {
    pub(crate) fn from_xml(s: &str) -> Self {
        match s {
            "online" => Self::Online,
            "offline" => Self::Offline,
            "in-game" => Self::InGame,
            "snooze" => Self::Snooze,
            "busy" => Self::Busy,
            "away" => Self::Away,
            "looking to trade" => Self::LookingToTrade,
            "looking to play" => Self::LookingToPlay,
            other => Self::Other(other.to_owned()),
        }
    }
}

/// Trade-ban status reported by Steam.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TradeBanState {
    None,
    Probation,
    Banned,
    Other(String),
}

impl TradeBanState {
    pub(crate) fn from_xml(s: &str) -> Self {
        match s {
            "None" => Self::None,
            "Probation" => Self::Probation,
            "Banned" => Self::Banned,
            other => Self::Other(other.to_owned()),
        }
    }
}

/// Snapshot of a Steam profile as returned by the public
/// `steamcommunity.com/id/{vanity}/?xml=1` (or `/profiles/{id}/?xml=1`) feed.
///
/// Anonymous; no API key required. Field availability depends on the
/// profile's privacy setting — fields wrapped in `Option` are populated only
/// for profiles where the corresponding section is public.
#[derive(Debug, Clone)]
pub struct PublicProfileSummary {
    /// 64-bit Steam ID.
    pub steam_id: SteamID,
    /// Display name (`<steamID>` in XML — confusingly named by Valve).
    pub persona_name: String,
    /// Online status (online / offline / in-game / …).
    pub online_state: OnlineState,
    /// Free-form status text (e.g. `"Last Online 3 days ago"`).
    pub state_message: String,
    /// Profile visibility — collapses Steam's redundant `<privacyState>`
    /// (string) and `<visibilityState>` (1/2/3) tags into one value.
    pub privacy_state: PrivacyState,
    /// Small (32x32) avatar URL.
    pub avatar_icon: String,
    /// Medium (64x64) avatar URL.
    pub avatar_medium: String,
    /// Full (184x184) avatar URL.
    pub avatar_full: String,
    /// VAC banned at least once.
    pub vac_banned: bool,
    /// Trade-ban state.
    pub trade_ban_state: TradeBanState,
    /// Limited account (no purchase activation, etc.).
    pub is_limited_account: bool,
    /// Custom URL slug (only for profiles that set one).
    pub custom_url: Option<String>,
    /// Account creation date. Steam serves this localized; the client pins
    /// `l=english`, so parsing as `"%B %d, %Y"` is stable. Stored as a
    /// `DateTime<Utc>` at midnight UTC (Steam reports day granularity only).
    /// `None` if absent or unparseable.
    pub member_since: Option<DateTime<Utc>>,
    /// Profile headline.
    pub headline: Option<String>,
    /// User-supplied location.
    pub location: Option<String>,
    /// Real name.
    pub real_name: Option<String>,
    /// Profile summary (HTML).
    pub summary: Option<String>,
    /// Hours played in last 2 weeks across all games.
    pub hours_played_2wk: Option<f32>,
}