db/heromodels/src/models/heroledger/group.rs

use heromodels_core::{Model, BaseModelData, IndexKey};
use heromodels_derive::model;
use serde::{Deserialize, Serialize};

/// Defines the lifecycle of a group
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum GroupStatus {
    Active,
    Inactive,
    Suspended,
    Archived,
}

impl Default for GroupStatus {
    fn default() -> Self {
        GroupStatus::Active
    }
}

/// Visibility controls who can discover or view the group
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum Visibility {
    Public,   // Anyone can see and request to join
    Private,  // Only invited users can see the group
    Unlisted, // Not visible in search; only accessible by direct link or DNS
}

impl Default for Visibility {
    fn default() -> Self {
        Visibility::Public
    }
}

/// GroupConfig holds rules that govern group membership and behavior
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct GroupConfig {
    pub max_members: u32,
    pub allow_guests: bool,
    pub auto_approve: bool,
    pub require_invite: bool,
}

impl GroupConfig {
    pub fn new() -> Self {
        Self {
            max_members: 0,
            allow_guests: false,
            auto_approve: false,
            require_invite: false,
        }
    }

    pub fn max_members(mut self, max_members: u32) -> Self {
        self.max_members = max_members;
        self
    }

    pub fn allow_guests(mut self, allow_guests: bool) -> Self {
        self.allow_guests = allow_guests;
        self
    }

    pub fn auto_approve(mut self, auto_approve: bool) -> Self {
        self.auto_approve = auto_approve;
        self
    }

    pub fn require_invite(mut self, require_invite: bool) -> Self {
        self.require_invite = require_invite;
        self
    }

    pub fn build(self) -> Self {
        self
    }
}

/// Represents a collaborative or access-controlled unit within the system
#[model]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct Group {
    /// Base model data
    pub base_data: BaseModelData,
    #[index]
    pub name: String,
    pub description: String,
    pub dnsrecords: Vec<u32>,
    pub administrators: Vec<u32>,
    pub config: GroupConfig,
    pub status: GroupStatus,
    pub visibility: Visibility,
    pub created: u64,
    pub updated: u64,
}

impl Group {
    /// Create a new group instance
    pub fn new(id: u32) -> Self {
        let mut base_data = BaseModelData::new();
        base_data.update_id(id);
        Self {
            base_data,
            name: String::new(),
            description: String::new(),
            dnsrecords: Vec::new(),
            administrators: Vec::new(),
            config: GroupConfig::new(),
            status: GroupStatus::default(),
            visibility: Visibility::default(),
            created: 0,
            updated: 0,
        }
    }

    /// Set the group name (fluent)
    pub fn name(mut self, name: impl ToString) -> Self {
        self.name = name.to_string();
        self
    }

    /// Set the group description (fluent)
    pub fn description(mut self, description: impl ToString) -> Self {
        self.description = description.to_string();
        self
    }

    /// Add a DNS record ID (fluent)
    pub fn add_dnsrecord(mut self, dnsrecord_id: u32) -> Self {
        self.dnsrecords.push(dnsrecord_id);
        self
    }

    /// Set all DNS record IDs (fluent)
    pub fn dnsrecords(mut self, dnsrecords: Vec<u32>) -> Self {
        self.dnsrecords = dnsrecords;
        self
    }

    /// Add an administrator user ID (fluent)
    pub fn add_administrator(mut self, user_id: u32) -> Self {
        self.administrators.push(user_id);
        self
    }

    /// Set all administrator user IDs (fluent)
    pub fn administrators(mut self, administrators: Vec<u32>) -> Self {
        self.administrators = administrators;
        self
    }

    /// Set the group configuration (fluent)
    pub fn config(mut self, config: GroupConfig) -> Self {
        self.config = config;
        self
    }

    /// Set the group status (fluent)
    pub fn status(mut self, status: GroupStatus) -> Self {
        self.status = status;
        self
    }

    /// Set the group visibility (fluent)
    pub fn visibility(mut self, visibility: Visibility) -> Self {
        self.visibility = visibility;
        self
    }

    /// Set the created timestamp (fluent)
    pub fn created(mut self, created: u64) -> Self {
        self.created = created;
        self
    }

    /// Set the updated timestamp (fluent)
    pub fn updated(mut self, updated: u64) -> Self {
        self.updated = updated;
        self
    }

    /// Build the final group instance
    pub fn build(self) -> Self {
        self
    }
}



/// Represents the membership relationship between users and groups
#[model]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct UserGroupMembership {
    /// Base model data
    pub base_data: BaseModelData,
    #[index]
    pub user_id: u32,
    pub group_ids: Vec<u32>,
}

impl UserGroupMembership {
    /// Create a new user group membership instance
    pub fn new(id: u32) -> Self {
        let mut base_data = BaseModelData::new();
        base_data.update_id(id);
        Self {
            base_data,
            user_id: 0,
            group_ids: Vec::new(),
        }
    }

    /// Set the user ID (fluent)
    pub fn user_id(mut self, user_id: u32) -> Self {
        self.user_id = user_id;
        self
    }

    /// Add a group ID (fluent)
    pub fn add_group_id(mut self, group_id: u32) -> Self {
        self.group_ids.push(group_id);
        self
    }

    /// Set all group IDs (fluent)
    pub fn group_ids(mut self, group_ids: Vec<u32>) -> Self {
        self.group_ids = group_ids;
        self
    }

    /// Build the final membership instance
    pub fn build(self) -> Self {
        self
    }
}