Permissions

pub struct PolicySet {
    pub add_member_policy: MembershipPolicies,
    pub remove_member_policy: MembershipPolicies,
    pub update_metadata_policy: HashMap<String, MetadataPolicies>,
    pub add_admin_policy: PermissionsPolicies,
    pub remove_admin_policy: PermissionsPolicies,
    pub update_permissions_policy: PermissionsPolicies,
}

pub fn new(
    add_member_policy: MembershipPolicies,
    remove_member_policy: MembershipPolicies,
    update_metadata_policy: HashMap<String, MetadataPolicies>,
    add_admin_policy: PermissionsPolicies,
    remove_admin_policy: PermissionsPolicies,
    update_permissions_policy: PermissionsPolicies,
) -> Self

pub fn new_dm() -> Self

pub fn evaluate_commit(&self, commit: &ValidatedCommit) -> bool

pub fn to_bytes(&self) -> Result<Vec<u8>, PolicyError>
pub fn from_bytes(bytes: &[u8]) -> Result<Self, PolicyError>

pub enum PreconfiguredPolicies {
    Default,      // "All Members" policy
    AdminsOnly,   // "Admin Only" policy
}

pub fn to_policy_set(&self) -> PolicySet

pub fn from_policy_set(policy_set: &PolicySet) -> Result<Self, PolicyError>

pub enum MembershipPolicies {
    Standard(BasePolicies),
    AndCondition(AndCondition),
    AnyCondition(AnyCondition),
}

pub fn allow() -> Self
pub fn deny() -> Self
pub fn allow_if_actor_admin() -> Self
pub fn allow_if_actor_super_admin() -> Self
pub fn and(policies: Vec<MembershipPolicies>) -> Self
pub fn any(policies: Vec<MembershipPolicies>) -> Self

pub enum BasePolicies {
    Allow,
    Deny,
    AllowSameMember,
    AllowIfAdminOrSuperAdmin,
    AllowIfSuperAdmin,
}

pub trait MembershipPolicy {
    fn evaluate(&self, actor: &CommitParticipant, change: &Inbox) -> bool;
    fn to_proto(&self) -> Result<MembershipPolicyProto, PolicyError>;
}

pub enum MetadataPolicies {
    Standard(MetadataBasePolicies),
    AndCondition(MetadataAndCondition),
    AnyCondition(MetadataAnyCondition),
}

pub fn allow() -> Self
pub fn deny() -> Self
pub fn allow_if_actor_admin() -> Self
pub fn allow_if_actor_super_admin() -> Self
pub fn and(policies: Vec<MetadataPolicies>) -> Self
pub fn any(policies: Vec<MetadataPolicies>) -> Self

pub fn default_map(policies: MetadataPolicies) -> HashMap<String, MetadataPolicies>

pub enum MetadataBasePolicies {
    Allow,
    Deny,
    AllowIfActorAdminOrSuperAdmin,
    AllowIfActorSuperAdmin,
}

pub trait MetadataPolicy {
    fn evaluate(&self, actor: &CommitParticipant, change: &MetadataFieldChange) -> bool;
    fn to_proto(&self) -> Result<MetadataPolicyProto, PolicyError>;
}

pub enum PermissionsPolicies {
    Standard(PermissionsBasePolicies),
    AndCondition(PermissionsAndCondition),
    AnyCondition(PermissionsAnyCondition),
}

pub fn deny() -> Self
pub fn allow_if_actor_admin() -> Self
pub fn allow_if_actor_super_admin() -> Self
pub fn and(policies: Vec<PermissionsPolicies>) -> Self
pub fn any(policies: Vec<PermissionsPolicies>) -> Self

pub enum PermissionsBasePolicies {
    Deny,
    AllowIfActorAdminOrSuperAdmin,
    AllowIfActorSuperAdmin,
}

pub trait PermissionsPolicy {
    fn evaluate(&self, actor: &CommitParticipant) -> bool;
    fn to_proto(&self) -> Result<PermissionsPolicyProto, PolicyError>;
}

let policy = MembershipPolicies::and(vec![
    MembershipPolicies::allow_if_actor_admin(),
    // additional policies...
]);

let policy = MembershipPolicies::any(vec![
    MembershipPolicies::allow_if_actor_admin(),
    MembershipPolicies::allow_if_actor_super_admin(),
]);

pub struct GroupMutablePermissions {
    pub policies: PolicySet,
}

pub fn new(policies: PolicySet) -> Self

pub fn preconfigured_policy(
    &self,
) -> Result<PreconfiguredPolicies, GroupMutablePermissionsError>

impl TryFrom<GroupMutablePermissions> for Vec<u8>
impl TryFrom<&Vec<u8>> for GroupMutablePermissions
impl TryFrom<&Extensions> for GroupMutablePermissions
impl TryFrom<&OpenMlsGroup> for GroupMutablePermissions

pub fn extract_group_permissions(
    group: &OpenMlsGroup,
) -> Result<GroupMutablePermissions, GroupMutablePermissionsError>

pub enum PolicyError {
    Serialization(prost::EncodeError),
    Deserialization(prost::DecodeError),
    MissingMetadataPolicyField { name: String },
    InvalidPolicy,
    InvalidPresetPolicy,
    InvalidMetadataPolicy,
    InvalidMembershipPolicy,
    InvalidPermissionsPolicy,
    // ... proto conversion errors
}

pub enum GroupMutablePermissionsError {
    Serialization(prost::EncodeError),
    Deserialization(prost::DecodeError),
    Policy(PolicyError),
    InvalidConversationType,
    MissingPolicies,
    MissingExtension,
    InvalidPermissionPolicyOption,
}

use xmtp_mls::groups::group_permissions::*;

let custom_policy = PolicySet::new(
    MembershipPolicies::allow_if_actor_admin(),  // Add members: admin only
    MembershipPolicies::allow_if_actor_admin(),  // Remove members: admin only
    MetadataPolicies::default_map(MetadataPolicies::allow()),  // Metadata: allow all
    PermissionsPolicies::allow_if_actor_super_admin(),  // Add admin: super admin only
    PermissionsPolicies::allow_if_actor_super_admin(),  // Remove admin: super admin only
    PermissionsPolicies::allow_if_actor_super_admin(),  // Update permissions: super admin only
);

let default_policy = PreconfiguredPolicies::Default.to_policy_set();
let admin_only_policy = PreconfiguredPolicies::AdminsOnly.to_policy_set();

let permissions = extract_group_permissions(&mls_group)?;
let policy_set = &permissions.policies;

if let Ok(preset) = permissions.preconfigured_policy() {
    println!("Using preset: {:?}", preset);
}