autter-core 2.0.2

use serde::{Deserialize, Serialize};
use serde_valid::Validate;
pub use tetratto_core2::model::{ApiReturn, Error, Result, id::Id};
use totp_rs::TOTP;
use tritools::{
    encoding::{hash_salted, salt},
    time::unix_epoch_timestamp,
};

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Default)]
pub enum ThemePreference {
    #[default]
    Auto,
    Light,
    Dark,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum UserPermission {
    /// Manage other users.
    ManageUsers,
    /// Verify and unverify users.
    ManageVerified,
    /// Manage audit log entries.
    ManageAuditLog,
    /// Manage reports.
    ManageReports,
    /// Manage miscellaneous app data (e.g. Askall asks).
    ManageMiscAppData,
    /// Manage user notifications.
    ManageNotifications,
    /// User is banned.
    Banned,
    /// Ban and unban users.
    ManageBans,
    /// Delete other users.
    DeleteUsers,
    /// Manage user warnings.
    ManageWarnings,
    /// User is a premium user.
    Seedling,
    /// User is a premium plus user.
    SeedlingPlus,
    /// Manage user properties.
    ManageProperties,
    /// Manage user organizations.
    ManageOrganizations,
    /// Manage organization permission lists.
    ManagePermissionsLists,
    /// Manage the permissions of other users.
    Administrator,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum UserBadge {
    /// User is a site moderator.
    Staff,
}

#[derive(Clone, Debug, Serialize, Deserialize, Validate, Default)]
pub struct UserSettings {
    #[serde(default)]
    #[validate(max_length = 32)]
    pub display_name: String,
    #[serde(default)]
    #[validate(max_length = 4096)]
    pub biography: String,
    /// External links for the user's other profiles on other websites.
    #[serde(default)]
    #[validate(max_items = 15)]
    #[validate(unique_items)]
    pub links: Vec<(String, String)>,
    /// The user's contacts.
    #[serde(default)]
    #[validate(max_items = 5)]
    #[validate(unique_items)]
    pub contacts: Vec<(String, String)>,
    /// The user's theme used on their profile.
    #[serde(default)]
    pub profile_theme: ThemePreference,
}

impl UserSettings {
    pub fn verify_values(&self) -> Result<()> {
        if let Err(e) = self.validate() {
            return Err(Error::MiscError(e.to_string()));
        }

        Ok(())
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TetrattoLinkedAccount {
    pub id: Id,
    pub username: String,
    pub added: u128,
}

#[derive(Clone, Debug, Serialize, Deserialize, Default)]
pub struct UserLinkedAccounts {
    #[serde(default)]
    pub tetratto_multiple: Vec<TetrattoLinkedAccount>,
}

/// `(ip, token, creation timestamp)`
pub type Token = (String, String, u128);

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct User {
    pub id: Id,
    pub created: u128,
    pub username: String,
    pub password: String,
    pub salt: String,
    pub settings: UserSettings,
    pub tokens: Vec<Token>,
    pub permissions: Vec<UserPermission>,
    pub is_verified: bool,
    pub notification_count: usize,
    /// The TOTP secret for this profile. An empty value means the user has TOTP disabled.
    #[serde(default)]
    pub totp: String,
    /// The TOTP recovery codes for this profile.
    #[serde(default)]
    pub recovery_codes: Vec<String>,
    /// The user's Stripe customer ID.
    #[serde(default)]
    pub stripe_id: String,
    /// The reason the user was banned.
    #[serde(default)]
    pub ban_reason: String,
    /// The time at which the user's ban will automatically expire.
    #[serde(default)]
    pub ban_expire: usize,
    /// If the user is deactivated. Deactivated users act almost like deleted
    /// users, but their data is not wiped.
    #[serde(default)]
    pub is_deactivated: bool,
    /// The IDs of Stripe checkout sessions that this user has successfully completed.
    ///
    /// This should be checked BEFORE applying purchases to ensure that the user hasn't
    /// already applied this purchase.
    #[serde(default)]
    pub checkouts: Vec<String>,
    /// The time in which the user last consented to the site's policies.
    #[serde(default)]
    pub last_policy_consent: u128,
    /// The other accounts in the database that are linked to this account.
    #[serde(default)]
    pub linked_accounts: UserLinkedAccounts,
    /// A list of the user's profile badges.
    #[serde(default)]
    pub badges: Vec<UserBadge>,
    /// The ID of the user's principal organization (i.e. the organization shown on their profile).
    #[serde(default)]
    pub principal_org: Id,
    /// If the user is locked into their principal organization. Their organization's
    /// owner can manage their account if this is true.
    #[serde(default)]
    pub org_as_tenant: bool,
    /// The number of organizations the user can create.
    #[serde(default)]
    pub org_creation_credits: i32,
    /// The number of users the user can register to an organization.
    #[serde(default)]
    pub org_user_register_credits: i32,
    /// Users can pay to have their account marked as fully verified. This verification
    /// confirms they are a real human (to a degree). Promoting users who are super
    /// verified is a good way to keep AI and disgraceful content down.
    #[serde(default)]
    pub is_super_verified: bool,
}

impl Default for User {
    fn default() -> Self {
        Self::new("<unknown>".to_string(), String::new())
    }
}

impl User {
    /// Create a new [`User`].
    pub fn new(username: String, password: String) -> Self {
        let salt = salt();
        let password = hash_salted(password, salt.clone());
        let created = unix_epoch_timestamp();

        Self {
            id: Id::Legacy(Id::new().as_usize()),
            created,
            username,
            password,
            salt,
            settings: UserSettings::default(),
            tokens: Vec::new(),
            permissions: Vec::new(),
            is_verified: false,
            notification_count: 0,
            totp: String::new(),
            recovery_codes: Vec::new(),
            stripe_id: String::new(),
            ban_reason: String::new(),
            is_deactivated: false,
            ban_expire: 0,
            checkouts: Vec::new(),
            last_policy_consent: created,
            linked_accounts: UserLinkedAccounts::default(),
            badges: Vec::new(),
            principal_org: Id::default(),
            org_as_tenant: false,
            org_creation_credits: 0,
            org_user_register_credits: 0,
            is_super_verified: false,
        }
    }

    /// Deleted user profile.
    pub fn deleted() -> Self {
        Self {
            username: "<deleted>".to_string(),
            id: Id::default(),
            ..Default::default()
        }
    }

    /// Banned user profile.
    pub fn banned() -> Self {
        Self {
            username: "<banned>".to_string(),
            id: Id::default(),
            permissions: vec![UserPermission::Banned],
            ..Default::default()
        }
    }

    /// Create a new token
    ///
    /// # Returns
    /// `(unhashed id, token)`
    pub fn create_token(ip: &str) -> (String, Token) {
        let unhashed = Id::new().to_string();
        (
            unhashed.clone(),
            (
                ip.to_string(),
                tritools::encoding::hash(unhashed),
                tritools::time::unix_epoch_timestamp(),
            ),
        )
    }

    /// Check if the given password is correct for the user.
    pub fn check_password(&self, against: String) -> bool {
        self.password == hash_salted(against, self.salt.clone())
    }

    /// Get a [`TOTP`] from the profile's `totp` secret value.
    pub fn totp(&self, issuer: Option<String>) -> Option<TOTP> {
        if self.totp.is_empty() {
            return None;
        }

        TOTP::new(
            totp_rs::Algorithm::SHA1,
            6,
            1,
            30,
            self.totp.as_bytes().to_owned(),
            Some(issuer.unwrap_or("tetratto!".to_string())),
            self.username.clone(),
        )
        .ok()
    }

    /// Clean the struct for public viewing.
    pub fn clean(&mut self) {
        self.password = String::new();
        self.salt = String::new();

        self.tokens = Vec::new();

        self.recovery_codes = Vec::new();
        self.totp = String::new();

        self.settings = UserSettings::default();
        self.stripe_id = String::new();
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Notification {
    pub id: Id,
    pub created: u128,
    pub title: String,
    pub content: String,
    pub owner: Id,
    pub read: bool,
    pub tag: String,
}

impl Notification {
    /// Create a new [`Notification`].
    pub fn new(title: String, content: String, owner: Id) -> Self {
        Self {
            id: Id::new(),
            created: unix_epoch_timestamp(),
            title,
            content,
            owner,
            read: false,
            tag: String::new(),
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct AuditLogEntry {
    pub id: Id,
    pub created: u128,
    pub moderator: Id,
    pub content: String,
}

impl AuditLogEntry {
    /// Create a new [`AuditLogEntry`].
    pub fn new(moderator: Id, content: String) -> Self {
        Self {
            id: Id::new(),
            created: unix_epoch_timestamp(),
            moderator,
            content,
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct IpBan {
    pub ip: String,
    pub created: u128,
    pub reason: String,
    pub moderator: Id,
}

impl IpBan {
    /// Create a new [`IpBan`].
    pub fn new(ip: String, moderator: Id, reason: String) -> Self {
        Self {
            ip,
            created: unix_epoch_timestamp(),
            reason,
            moderator,
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct UserWarning {
    pub id: Id,
    pub created: u128,
    pub receiver: Id,
    pub moderator: Id,
    pub content: String,
}

impl UserWarning {
    /// Create a new [`UserWarning`].
    pub fn new(user: Id, moderator: Id, content: String) -> Self {
        Self {
            id: Id::new(),
            created: unix_epoch_timestamp(),
            receiver: user,
            moderator,
            content,
        }
    }
}

// socket
pub mod socket {
    use serde::{Deserialize, Serialize, de::DeserializeOwned};

    #[derive(Serialize, Deserialize, PartialEq, Eq)]
    pub enum CrudMessageType {
        Create,
        Delete,
    }

    #[derive(Serialize, Deserialize, PartialEq, Eq)]
    pub enum PacketType {
        /// A regular check to ensure the connection is still alive.
        Ping,
        /// General text which can be ignored.
        Text,
        /// A CRUD operation.
        Crud(CrudMessageType),
        /// A text key which identifies the socket.
        Key,
    }

    #[derive(Serialize, Deserialize, PartialEq, Eq)]
    pub enum SocketMethod {
        /// Authentication and channel identification.
        Headers,
        /// A message was sent in the channel.
        Message,
        /// A message was deleted in the channel.
        Delete,
        /// Forward message from server to client. (Redis pubsub to ws)
        Forward(PacketType),
        /// A general packet from client to server. (ws to Redis pubsub)
        Misc(PacketType),
        /// A general packet from client to server. (ws to Redis pubsub)
        Packet(PacketType),
    }

    #[derive(Serialize, Deserialize)]
    pub struct SocketMessage {
        pub method: SocketMethod,
        pub data: String,
    }

    impl SocketMessage {
        pub fn data<T: DeserializeOwned>(&self) -> T {
            serde_json::from_str(&self.data).unwrap()
        }
    }

    /// [`PacketType::Text`]
    #[derive(Serialize, Deserialize, PartialEq, Eq)]
    pub struct TextMessage {
        pub text: String,
    }
}

// properties
pub mod properties {
    use serde::{Deserialize, Serialize};
    use tetratto_core2::model::id::Id;
    use tritools::time::unix_epoch_timestamp;

    #[derive(Serialize, Deserialize, PartialEq, Eq)]
    pub enum Product {
        /// A single Tetratto account.
        Tetratto,
        /// Ability to create a Shrimpcamp organization.
        ///
        /// $200 once.
        Organization,
        /// Ability to register a user to an organization.
        ///
        /// $4 once.
        UserReg,
        /// A seedling membership.
        ///
        /// $4 monthly.
        Seedling,
        /// A user verification payment (corresponds to [`User::is_super_verified`]).
        ///
        /// $2 once.
        UserVerification,
    }

    #[derive(Serialize, Deserialize)]
    pub struct Property {
        pub id: Id,
        pub created: u128,
        pub owner: Id,
        /// A unique name for the instance. Used in the subdomain for the CNAME
        /// record's host (aka the URL for when the instance doesn't have a custom domain).
        pub name: String,
        pub product: Product,
        pub custom_domain: String,
    }

    impl Property {
        /// Create a new [`Property`].
        pub fn new(owner: Id, name: String, product: Product) -> Self {
            Self {
                id: Id::new(),
                created: unix_epoch_timestamp(),
                owner,
                name,
                product,
                custom_domain: String::new(),
            }
        }
    }
}

// organizations
pub mod organizations {
    use serde::{Deserialize, Serialize};
    use std::collections::HashMap;
    use tetratto_core2::model::id::Id;
    use tritools::time::unix_epoch_timestamp;

    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
    pub enum OrganizationRole {
        Owner,
        Custom(usize),
        #[default]
        Member,
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct Organization {
        pub id: Id,
        pub created: u128,
        pub owner: Id,
        pub name: String,
        pub members: i32,
        pub roles: HashMap<usize, String>,
    }

    impl Organization {
        /// Create a new [`Organization`].
        pub fn new(name: String, owner: Id) -> Self {
            Self {
                id: Id::new(),
                created: unix_epoch_timestamp(),
                owner,
                name,
                members: 0,
                roles: HashMap::new(),
            }
        }
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct OrganizationMembership {
        pub id: Id,
        pub created: u128,
        pub organization: Id,
        pub owner: Id,
        pub role: OrganizationRole,
    }

    impl OrganizationMembership {
        /// Create a new [`OrganizationMembership`].
        pub fn new(organization: Id, owner: Id) -> Self {
            Self {
                id: Id::new(),
                created: unix_epoch_timestamp(),
                organization,
                owner,
                role: OrganizationRole::Member,
            }
        }
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct PermissionsList {
        pub id: Id,
        pub created: u128,
        pub owner_org: Id,
        pub name: String,
        pub roles: Vec<usize>,
    }

    impl PermissionsList {
        /// Create a new [`PermissionsList`].
        pub fn new(owner_org: Id, name: String) -> Self {
            Self {
                id: Id::new(),
                created: unix_epoch_timestamp(),
                owner_org,
                name,
                roles: Vec::new(),
            }
        }
    }
}