implemented a way to filter out roles that can't be assigned to permission, and disable permissions that are above the current power level of the user.

ElementX/Sources/Services/Room/RoomPermissions.swift

@@ -10,24 +10,29 @@ import Foundation
 import MatrixRustSDK
 
 struct RoomPermissionsSetting: Identifiable {
-    var id: KeyPath<RoomPermissions, RoomRole> { keyPath }
+    static let allValues: [(title: String, tag: RoomRole)] = [(title: L10n.screenRoomChangePermissionsAdministrators, tag: .administrator),
+                                                              (title: L10n.screenRoomChangePermissionsModerators, tag: .moderator),
+                                                              (title: L10n.screenRoomChangePermissionsEveryone, tag: .user)]
+    var id: KeyPath<RoomPermissions, Int64> { keyPath }
     
     /// The title of this setting.
     let title: String
     
     /// The selected role of this setting.
-    var value: RoomRole
-    /// All of the available roles that this setting can be configured with.
-    var allValues: [(title: String, tag: RoomRole)] {
-        [
-            (title: L10n.screenRoomChangePermissionsAdministrators, tag: .administrator),
-            (title: L10n.screenRoomChangePermissionsModerators, tag: .moderator),
-            (title: L10n.screenRoomChangePermissionsEveryone, tag: .user)
-        ]
-    }
+    var value: Int64
     
+    let ownPowerLevel: RoomPowerLevel
+    
+    var roleValue: RoomRole {
+        get {
+            RoomRole(powerLevelValue: value)
+        } set {
+            value = newValue.powerLevelValue
+        }
+    }
+        
     /// The `RoomPermissions` property that this setting is for.
-    let keyPath: KeyPath<RoomPermissions, RoomRole>
+    let keyPath: KeyPath<RoomPermissions, Int64>
     /// The `RoomPowerLevelChanges` property that this setting is saved into.
     var rustKeyPath: WritableKeyPath<RoomPowerLevelChanges, Int64?> {
         switch keyPath {
@@ -45,46 +50,75 @@ struct RoomPermissionsSetting: Identifiable {
         default: fatalError("Unexpected key path: \(keyPath)")
         }
     }
+    
+    /// Can the setting be edited
+    var isDisabled: Bool {
+        switch ownPowerLevel {
+        case .value(let ownValue):
+            ownValue < value
+        case .infinite:
+            false
+        }
+    }
+    
+    /// All of the available roles that this setting can be configured with.
+    var availableValues: [(title: String, tag: RoomRole)] {
+        if isDisabled {
+            Self.allValues.filter { $0.tag == RoomRole(powerLevelValue: value) }
+        } else {
+            Self.allValues.filter { $0.tag <= ownPowerLevel.role }
+        }
+    }
+    
+    init(title: String,
+         value: Int64,
+         ownPowerLevel: RoomPowerLevel,
+         keyPath: KeyPath<RoomPermissions, Int64>) {
+        self.ownPowerLevel = ownPowerLevel
+        self.title = title
+        self.value = value
+        self.keyPath = keyPath
+    }
 }
 
 struct RoomPermissions {
     /// The level required to ban a user.
-    var ban: RoomRole
+    var ban: Int64
     /// The level required to invite a user.
-    var invite: RoomRole
+    var invite: Int64
     /// The level required to kick a user.
-    var kick: RoomRole
+    var kick: Int64
     /// The level required to redact an event.
-    var redact: RoomRole
+    var redact: Int64
     /// The default level required to send message events.
-    var eventsDefault: RoomRole
+    var eventsDefault: Int64
     /// The default level required to send state events.
-    var stateDefault: RoomRole
+    var stateDefault: Int64
     /// The default power level for every user in the room.
-    var usersDefault: RoomRole
+    var usersDefault: Int64
     /// The level required to change the room's name.
-    var roomName: RoomRole
+    var roomName: Int64
     /// The level required to change the room's avatar.
-    var roomAvatar: RoomRole
+    var roomAvatar: Int64
     /// The level required to change the room's topic.
-    var roomTopic: RoomRole
+    var roomTopic: Int64
     /// The level required to add/remove childrens from a space.
-    var spaceChild: RoomRole
+    var spaceChild: Int64
 }
 
 extension RoomPermissions {
     /// Create permissions from the room's power levels.
     init(powerLevels: RoomPowerLevelsValues) {
-        ban = RoomRole(powerLevelValue: powerLevels.ban)
-        invite = RoomRole(powerLevelValue: powerLevels.invite)
-        kick = RoomRole(powerLevelValue: powerLevels.kick)
-        redact = RoomRole(powerLevelValue: powerLevels.redact)
-        eventsDefault = RoomRole(powerLevelValue: powerLevels.eventsDefault)
-        stateDefault = RoomRole(powerLevelValue: powerLevels.stateDefault)
-        usersDefault = RoomRole(powerLevelValue: powerLevels.usersDefault)
-        roomName = RoomRole(powerLevelValue: powerLevels.roomName)
-        roomAvatar = RoomRole(powerLevelValue: powerLevels.roomAvatar)
-        roomTopic = RoomRole(powerLevelValue: powerLevels.roomTopic)
-        spaceChild = RoomRole(powerLevelValue: powerLevels.spaceChild)
+        ban = powerLevels.ban
+        invite = powerLevels.invite
+        kick = powerLevels.kick
+        redact = powerLevels.redact
+        eventsDefault = powerLevels.eventsDefault
+        stateDefault = powerLevels.stateDefault
+        usersDefault = powerLevels.usersDefault
+        roomName = powerLevels.roomName
+        roomAvatar = powerLevels.roomAvatar
+        roomTopic = powerLevels.roomTopic
+        spaceChild = powerLevels.spaceChild
     }
 }

ElementX/Sources/Services/Room/RoomPowerLevel.swift

@@ -30,6 +30,10 @@ enum RoomPowerLevel: Hashable, Comparable {
         case .value(let value): .value(value: Int64(value))
         }
     }
+    
+    var role: RoomRole {
+        RoomRole(powerLevel: self)
+    }
 }
 
 extension PowerLevel {

ElementX/Sources/Services/Room/RoomRole.swift

@@ -110,21 +110,25 @@ extension RoomRole {
     /// To be used when setting the power level of a user to get the suggested equivalent power level value for that specific role
     /// NOTE: Do not use for comparison, use the true power level instead.
     var powerLevelValue: Int64 {
+        switch powerLevel {
+        case .infinite:
+            fatalError("Impossible")
+        case .value(let value):
+            return Int64(value)
+        }
+    }
+    
+    var powerLevel: RoomPowerLevel {
         guard self != .owner else {
             // Would be better if the SDK would return this, maybe a `suggestedPowerLevelValueForRole` function would solve the problem
-            return 150
+            return .value(150)
         }
         
         do {
-            switch try suggestedPowerLevelForRole(role: rustRole) {
-            case .infinite:
-                fatalError("Impossible")
-            case .value(let value):
-                return value
-            }
+            return try RoomPowerLevel(rustPowerLevel: suggestedPowerLevelForRole(role: rustRole))
         } catch {
             MXLog.error("Falied to convert role to power level value: \(error)")
-            return 0
+            return .value(0)
         }
     }
 }