steam-user 0.1.0

//! Account related types.

use std::collections::HashMap;

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

/// Transaction ID wrapper
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct TransactionId(pub String);

/// Response from adding a phone number.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AddPhoneNumberResponse {
    pub success: bool,
    #[serde(rename = "showResend")]
    pub show_resend: bool,
    pub state: String,
    #[serde(rename = "errorText")]
    pub error_text: String,
    pub token: String,
    #[serde(rename = "phoneNumber")]
    pub phone_number: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConfirmPhoneCodeResponse {
    pub success: bool,
    #[serde(rename = "showResend")]
    pub show_resend: bool,
    pub state: serde_json::Value, // Can be string or bool in JS example
    #[serde(rename = "errorText")]
    pub error_text: String,
    pub token: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RemovePhoneResult {
    pub success: bool,
    pub method: Option<i32>,
    #[serde(rename = "type")]
    pub confirm_type: Option<String>,
    pub link: Option<String>,
    pub wizard_param: Option<serde_json::Value>,
}

/// Wallet balance information.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WalletBalance {
    #[serde(rename = "mainBalance")]
    pub main_balance: Option<String>,
    pub pending: Option<String>,
    pub currency: Option<String>,
}

impl WalletBalance {
    /// Parse [`main_balance`](Self::main_balance) into a float.
    ///
    /// Expects VNĐ format (`"35.016,48₫"` or `"132.500₫"`).
    /// Returns `None` if the field is absent or unparseable.
    pub fn parse_main_balance(&self) -> Option<f64> {
        crate::utils::parse_steam_balance(self.main_balance.as_deref()?)
    }

    /// Parse [`pending`](Self::pending) into a float.
    pub fn parse_pending(&self) -> Option<f64> {
        crate::utils::parse_steam_balance(self.pending.as_deref()?)
    }
}

/// A single purchase history item from the Steam account history.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PurchaseHistoryItem {
    /// The date of the purchase (e.g., "Jan 10, 2024"). Stored as a
    /// `DateTime<Utc>` at midnight UTC (Steam reports day granularity only).
    pub date: DateTime<Utc>,
    /// The type of transaction (e.g., "Purchase", "Refund", "Gift Purchase")
    #[serde(rename = "type")]
    pub transaction_type: String,
    /// List of items involved in the transaction
    pub items: Vec<String>,
    /// The total amount of the transaction
    pub total: String,
    /// The base price before taxes/discounts
    pub base_price: Option<String>,
    /// Tax applied
    pub tax: Option<String>,
    /// Shipping cost
    pub shipping: Option<String>,
    /// Amount wallet balance changed
    pub wallet_change: Option<String>,
    /// The payment method used (e.g., "Visa", "Wallet")
    pub payment_method: Option<String>,
    /// The current wallet balance after this transaction
    pub wallet_balance: Option<String>,
    /// A unique transaction ID if available
    pub transaction_id: Option<TransactionId>,
}

/// Response from redeeming a Steam wallet code.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RedeemWalletCodeResponse {
    /// Whether the redemption was successful (1 = success)
    pub success: i32,
    /// Detail code for errors (0 = no error)
    pub detail: i32,
    /// The wallet balance after redemption
    #[serde(rename = "formattednewwalletbalance")]
    pub formatted_new_wallet_balance: Option<String>,
}

// ── Authorized Devices Page ────────────────────────────────────────────────

/// IPv4/v6 address for a device location entry.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeviceIp {
    pub v4: Option<u64>,
    pub v6: Option<serde_json::Value>,
}

/// Geographic + time info for a device first/last-seen event.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeviceLocation {
    pub time: Option<u64>,
    pub ip: Option<DeviceIp>,
    pub locale: Option<String>,
    pub country: Option<String>,
    pub state: Option<String>,
    pub city: Option<String>,
}

/// A single authorized Steam device / active session.
///
/// Returned in both `active_devices` and `revoked_devices` lists from
/// `https://store.steampowered.com/account/authorizeddevices`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthorizedDevice {
    /// Unique token identifier (u64 serialized as string by Steam).
    pub token_id: String,
    /// Human-readable description (e.g. user-agent string or device name).
    pub token_description: String,
    /// Unix timestamp of the last token update.
    pub time_updated: u64,
    /// Steam platform type (2 = browser/web, 3 = mobile, 7 = Steam client).
    pub platform_type: i32,
    /// Whether the session is currently logged in (1) or not (0).
    pub logged_in: i32,
    /// OS platform code (2 = Windows, 8 = Android, etc.).
    pub os_platform: i32,
    /// Auth type code (2 = credentials, 3 = QR, 4 = token refresh, …).
    pub auth_type: i32,
    /// Gaming device subtype (e.g. 528 = Samsung Galaxy; null for non-gaming).
    pub gaming_device_type: Option<i32>,
    /// Where and when the session was first established.
    pub first_seen: Option<DeviceLocation>,
    /// Where and when the session was last active.
    pub last_seen: Option<DeviceLocation>,
    /// Detailed OS type integer returned by Steam.
    pub os_type: i32,
    /// How authentication was performed (1 = new login, 2 = token refresh, …).
    pub authentication_type: i32,
    /// Token state: 3 = active, 99 = revoked/expired.
    pub effective_token_state: i32,
}

/// A single two-factor authenticator usage record.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TwoFactorUsage {
    pub time: u64,
    pub usage_type: i32,
    pub confirmation_type: i32,
    pub confirmation_action: i32,
}

/// Two-factor / Steam Guard status for the account.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TwoFactorStatus {
    /// Guard state: 0 = email guard active, 1 = authenticator active.
    pub state: i32,
    pub inactivation_reason: Option<serde_json::Value>,
    pub authenticator_type: Option<i32>,
    pub authenticator_allowed: Option<i32>,
    pub steamguard_scheme: Option<i32>,
    pub token_gid: Option<String>,
    pub email_validated: Option<i32>,
    pub device_identifier: Option<String>,
    pub time_created: Option<u64>,
    pub revocation_attempts_remaining: Option<i32>,
    pub classified_agent: Option<String>,
    pub allow_external_authenticator: Option<bool>,
    pub time_transferred: Option<u64>,
    pub version: Option<i32>,
    pub last_seen_auth_token_id: Option<String>,
    pub usages: Option<Vec<TwoFactorUsage>>,
    /// EResult from the underlying Steam API call.
    pub success: Option<i32>,
    /// Internal result code (`rwgrsn`).
    pub rwgrsn: Option<i32>,
}

/// Basic account / session info embedded in every Steam Store page.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PageUserInfo {
    pub logged_in: bool,
    pub country_code: Option<String>,
    #[serde(default)]
    pub excluded_content_descriptors: Vec<i32>,
    pub steamid: Option<String>,
    pub accountid: Option<u64>,
    pub account_name: Option<String>,
    pub is_support: Option<bool>,
    pub is_limited: Option<bool>,
    pub is_partner_member: Option<bool>,
    pub is_valve_email: Option<bool>,
}

/// Hardware / client-type flags embedded in the page.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PageHwInfo {
    #[serde(rename = "bSteamOS")]
    pub steam_os: bool,
    #[serde(rename = "bSteamDeck")]
    pub steam_deck: bool,
}

/// Store page configuration block (`data-config`).
///
/// Contains CDN base URLs, build metadata, and runtime flags.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PageConfig {
    #[serde(rename = "EUNIVERSE")]
    pub euniverse: Option<i32>,
    #[serde(rename = "WEB_UNIVERSE")]
    pub web_universe: Option<String>,
    #[serde(rename = "LANGUAGE")]
    pub language: Option<String>,
    #[serde(rename = "COUNTRY")]
    pub country: Option<String>,
    #[serde(rename = "PLATFORM")]
    pub platform: Option<String>,
    #[serde(rename = "WEBSITE_ID")]
    pub website_id: Option<String>,
    #[serde(rename = "BUILD_TIMESTAMP")]
    pub build_timestamp: Option<u64>,
    #[serde(rename = "PAGE_TIMESTAMP")]
    pub page_timestamp: Option<u64>,
    #[serde(rename = "NOW")]
    pub now: Option<u64>,
    #[serde(rename = "EREALM")]
    pub erealm: Option<i32>,
    #[serde(rename = "SNR")]
    pub snr: Option<String>,
    #[serde(rename = "IN_CLIENT")]
    pub in_client: Option<bool>,
    #[serde(rename = "IN_TENFOOT")]
    pub in_tenfoot: Option<bool>,
    #[serde(rename = "IN_GAMEPADUI")]
    pub in_gamepadui: Option<bool>,
    #[serde(rename = "IN_CHROMEOS")]
    pub in_chromeos: Option<bool>,
    #[serde(rename = "IN_MOBILE_WEBVIEW")]
    pub in_mobile_webview: Option<bool>,
    #[serde(rename = "FROM_WEB")]
    pub from_web: Option<bool>,
    #[serde(rename = "USE_POPUPS")]
    pub use_popups: Option<bool>,
    #[serde(rename = "COMMUNITY_BASE_URL")]
    pub community_base_url: Option<String>,
    #[serde(rename = "STORE_BASE_URL")]
    pub store_base_url: Option<String>,
    #[serde(rename = "STORE_CHECKOUT_BASE_URL")]
    pub store_checkout_base_url: Option<String>,
    #[serde(rename = "HELP_BASE_URL")]
    pub help_base_url: Option<String>,
    #[serde(rename = "WEBAPI_BASE_URL")]
    pub webapi_base_url: Option<String>,
    #[serde(rename = "AVATAR_BASE_URL")]
    pub avatar_base_url: Option<String>,
    #[serde(rename = "LOGIN_BASE_URL")]
    pub login_base_url: Option<String>,
    #[serde(rename = "MEDIA_CDN_URL")]
    pub media_cdn_url: Option<String>,
    #[serde(rename = "MEDIA_CDN_COMMUNITY_URL")]
    pub media_cdn_community_url: Option<String>,
    #[serde(rename = "COMMUNITY_CDN_URL")]
    pub community_cdn_url: Option<String>,
    #[serde(rename = "COMMUNITY_CDN_ASSET_URL")]
    pub community_cdn_asset_url: Option<String>,
    #[serde(rename = "STORE_CDN_URL")]
    pub store_cdn_url: Option<String>,
    #[serde(rename = "STORE_ICON_BASE_URL")]
    pub store_icon_base_url: Option<String>,
    #[serde(rename = "STORE_ITEM_BASE_URL")]
    pub store_item_base_url: Option<String>,
    #[serde(rename = "VIDEO_CDN_URL")]
    pub video_cdn_url: Option<String>,
    #[serde(rename = "TOKEN_URL")]
    pub token_url: Option<String>,
    #[serde(rename = "STEAMTV_BASE_URL")]
    pub steamtv_base_url: Option<String>,
    #[serde(rename = "PARTNER_BASE_URL")]
    pub partner_base_url: Option<String>,
    #[serde(rename = "SUPPORT_BASE_URL")]
    pub support_base_url: Option<String>,
    #[serde(rename = "CHAT_BASE_URL")]
    pub chat_base_url: Option<String>,
    #[serde(rename = "PUBLIC_SHARED_URL")]
    pub public_shared_url: Option<String>,
    #[serde(rename = "BASE_URL_SHARED_CDN")]
    pub base_url_shared_cdn: Option<String>,
    #[serde(rename = "BASE_URL_STORE_CDN_ASSETS")]
    pub base_url_store_cdn_assets: Option<String>,
    #[serde(rename = "COMMUNITY_ASSETS_BASE_URL")]
    pub community_assets_base_url: Option<String>,
    #[serde(rename = "CLAN_CDN_ASSET_URL")]
    pub clan_cdn_asset_url: Option<String>,
}

/// Store-side user config block (`data-store_user_config`).
///
/// Contains the short-lived WebAPI JWT token for the current browser session.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct StoreUserConfig {
    /// Short-lived WebAPI JWT (`webapi_token`). Valid for ~2 hours.
    pub webapi_token: Option<String>,
    /// Any remaining fields returned by Steam.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// A single Steam notification embedded in the page.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PageNotification {
    pub notification_id: String,
    /// Bitmask of targets (store / community / …).
    pub notification_targets: i32,
    /// Notification type code (3 = forum reply, etc.).
    pub notification_type: i32,
    /// Inner JSON payload; content depends on `notification_type`.
    pub body_data: String,
    /// 0 = unread, 1 = read.
    pub read: i32,
    pub timestamp: u64,
    pub hidden: i32,
    pub expiry: u64,
    pub viewed: Option<u64>,
}

/// Notification list and pending-count data from `data-steam_notifications`.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PageNotifications {
    #[serde(default)]
    pub notifications: Vec<PageNotification>,
    pub pending_gift_count: Option<i32>,
    pub pending_friend_count: Option<i32>,
}

/// Broadcast status for the logged-in user (`data-broadcastuser`).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BroadcastUser {
    pub success: i32,
    #[serde(rename = "bHideStoreBroadcast")]
    pub hide_store_broadcast: i32,
}

/// Full account details parsed from `https://store.steampowered.com/account/authorizeddevices`.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct AccountDetails {
    /// Steam account name (`data-accountName`).
    pub account_name: Option<String>,
    /// Account email address (`data-email`).
    pub email: Option<String>,
    /// Masked phone number hint, empty string if none (`data-phone_hint`).
    pub phone_hint: Option<String>,
    /// Latest Steam Android app version string
    /// (`data-latest_android_app_version`).
    pub latest_android_app_version: Option<String>,
    /// Token ID of the session currently browsing the page
    /// (`data-requesting_token_id`).
    pub requesting_token_id: Option<String>,
    /// Sessions that are currently active / not revoked.
    pub active_devices: Vec<AuthorizedDevice>,
    /// Sessions that were previously revoked.
    pub revoked_devices: Vec<AuthorizedDevice>,
    /// Steam Guard / two-factor authenticator status.
    pub two_factor_status: Option<TwoFactorStatus>,
    /// Basic account info embedded in every Store page.
    pub user_info: Option<PageUserInfo>,
    /// Hardware / platform flags.
    pub hw_info: Option<PageHwInfo>,
    /// Page-level configuration (CDN URLs, build info, etc.).
    pub page_config: Option<PageConfig>,
    /// Store user config including the short-lived WebAPI token.
    pub store_user_config: Option<StoreUserConfig>,
    /// Steam notifications for this account.
    pub notifications: Option<PageNotifications>,
    /// Broadcast status for this account.
    pub broadcast_user: Option<BroadcastUser>,
    /// Wallet balance parsed from the page header.
    pub wallet_balance: Option<WalletBalance>,
    /// SHA-1 avatar hash (e.g. `"834966fea6a0a8a3b7011db7f96d38b51ee0ba64"`).
    pub avatar_hash: Option<String>,
    /// Country code from `data-userinfo` (e.g. `"VN"`, `"US"`).
    pub country: Option<String>,
}

impl AccountDetails {
    /// Human-readable Steam Guard status derived from
    /// [`two_factor_status`](Self::two_factor_status).
    ///
    /// - `state == 1` → `"Steam Guard Mobile Authenticator"`
    /// - `state == 0, email_validated == 1` → `"Steam Guard (Email)"`
    /// - otherwise → `None`
    pub fn account_security(&self) -> Option<String> {
        let tf = self.two_factor_status.as_ref()?;
        match tf.state {
            1 => Some("Steam Guard Mobile Authenticator".to_string()),
            0 if tf.email_validated == Some(1) => Some("Steam Guard (Email)".to_string()),
            _ => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_deserialize_redeem_wallet_response() {
        let json = r#"{"success":1,"detail":0,"formattednewwalletbalance":"132.500\u20ab"}"#;
        let response: RedeemWalletCodeResponse = serde_json::from_str(json).unwrap();
        assert_eq!(response.success, 1);
        assert_eq!(response.detail, 0);
        assert_eq!(response.formatted_new_wallet_balance.as_deref(), Some("132.500₫"));
    }
}