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

/// Defines the possible roles a member can have
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum MemberRole {
    Owner,
    Admin,
    Moderator,
    Member,
    Guest,
}

impl Default for MemberRole {
    fn default() -> Self {
        MemberRole::Member
    }
}

/// Represents the current status of membership
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum MemberStatus {
    Active,
    Pending,
    Suspended,
    Removed,
}

impl Default for MemberStatus {
    fn default() -> Self {
        MemberStatus::Pending
    }
}

/// Represents a member within a circle
#[model]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
pub struct Member {
    /// Base model data
    pub base_data: BaseModelData,
    #[index]
    pub user_id: u32,
    pub role: MemberRole,
    pub status: MemberStatus,
    pub joined_at: u64,
    pub invited_by: u32,
    pub permissions: Vec<String>,
}

impl Member {
    /// Create a new member instance
    pub fn new(id: u32) -> Self {
        let mut base_data = BaseModelData::new();
        base_data.update_id(id);
        Self {
            base_data,
            user_id: 0,
            role: MemberRole::default(),
            status: MemberStatus::default(),
            joined_at: 0,
            invited_by: 0,
            permissions: Vec::new(),
        }
    }

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

    /// Set the member role (fluent)
    pub fn role(mut self, role: MemberRole) -> Self {
        self.role = role;
        self
    }

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

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

    /// Set who invited this member (fluent)
    pub fn invited_by(mut self, invited_by: u32) -> Self {
        self.invited_by = invited_by;
        self
    }

    /// Add a permission (fluent)
    pub fn add_permission(mut self, permission: impl ToString) -> Self {
        self.permissions.push(permission.to_string());
        self
    }

    /// Set all permissions (fluent)
    pub fn permissions(mut self, permissions: Vec<String>) -> Self {
        self.permissions = permissions;
        self
    }

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