source: TFP-WebServer/WebServer/src/Permissions/AdminWebModules.cs@ 498

using System;
using System.Collections.Generic;
using System.Xml;
using JetBrains.Annotations;
using UnityEngine;

namespace Webserver.Permissions {
        public class AdminWebModules : AdminSectionAbs {
                public static AdminWebModules Instance { get; private set; }

                public AdminWebModules (AdminTools _parent) : base (_parent, "webmodules") {
                        Instance = this;
                }

                private readonly Dictionary<string, WebModule> modules = new CaseInsensitiveStringDictionary<WebModule> ();


#region IO

                public override void Clear () {
                        allModulesList.Clear ();
                        modules.Clear ();
                }

                public override void ParseElement (XmlElement _childElement) {
                        allModulesList.Clear ();

                        if (!WebModule.TryParse (_childElement, out WebModule webModule)) {
                                return;
                        }

                        if (knownModules.TryGetValue (webModule.Name, out WebModule knownModule)) {
                                webModule = webModule.FixPermissionLevelsFromKnownModule (knownModule);
                        }
                        
                        modules [webModule.Name] = webModule;
                }

                public override void Save (XmlElement _root) {
                        XmlElement modulesElement = _root.AddXmlElement (SectionTypeName);
                        // modulesElement.AddXmlComment (" <module name=\"adminuser1\" secret=\"supersecrettoken\" permission_level=\"0\" /> ");

                        foreach ((string _, WebModule module) in modules) {
                                module.ToXml (modulesElement);
                        }
                }

#endregion


#region Runtime interaction


                public void AddModule (WebModule _module) {
                        lock (Parent) {
                                allModulesList.Clear ();
                        
                                modules [_module.Name] = _module;
                                Parent.Save ();
                        }
                }

                public bool RemoveModule (string _module) {
                        lock (Parent) {
                                allModulesList.Clear ();
                                
                                bool removed = modules.Remove (_module);
                                if (removed) {
                                        Parent.Save ();
                                }

                                return removed;
                        }
                }

                public List<WebModule> GetModules () {
                        lock (Parent) {
                                if (allModulesList.Count != 0) {
                                        return allModulesList;
                                }

                                foreach ((string moduleName, WebModule moduleDefaultPerm) in knownModules) {
                                        allModulesList.Add (modules.TryGetValue (moduleName, out WebModule modulePermission)
                                                ? modulePermission
                                                : moduleDefaultPerm);
                                }

                                return allModulesList;
                        }
                }

#endregion
                
                public readonly struct WebModule {
                        public readonly string Name;
                        public readonly int LevelGlobal;
                        public readonly int[] LevelPerMethod;
                        public readonly bool IsDefault;

                        public WebModule (string _name, int _level, bool _isDefault) {
                                LevelPerMethod = null;
                                
                                Name = _name;
                                LevelGlobal = _level;
                                IsDefault = _isDefault;
                        }

                        public WebModule (string _name, int _levelGlobal, int[] _levelPerMethod, bool _isDefault) {
                                if (_levelPerMethod != null && _levelPerMethod.Length != (int)ERequestMethod.Count) {
                                        LevelPerMethod = createDefaultPerMethodArray ();

                                        for (int i = 0; i < (int)ERequestMethod.Count; i++) {
                                                if (_levelPerMethod != null && i < _levelPerMethod.Length) {
                                                        LevelPerMethod [i] = _levelPerMethod [i];
                                                }
                                        }
                                } else {
                                        LevelPerMethod = _levelPerMethod;
                                }

                                Name = _name;
                                LevelGlobal = _levelGlobal;
                                IsDefault = _isDefault;
                        }
                        
                        public void ToXml (XmlElement _parent) {
                                bool hasPerMethodLevels = LevelPerMethod != null;

                                XmlElement permissionElement = _parent.AddXmlElement ("module")
                                        .SetAttrib ("name", Name)
                                        .SetAttrib ("permission_level", LevelGlobal.ToString ());
                                
                                if (!hasPerMethodLevels) {
                                        return;
                                }

                                for (int i = 0; i < LevelPerMethod.Length; i++) {
                                        ERequestMethod method = (ERequestMethod)i;
                                        int level = LevelPerMethod [i];
                                        
                                        if (level == MethodLevelNotSupported) {
                                                continue;
                                        }

                                        permissionElement.AddXmlElement ("method")
                                                .SetAttrib ("name", method.ToStringCached ())
                                                .SetAttrib ("permission_level", level == MethodLevelInheritGlobal ? MethodLevelInheritKeyword : level.ToString ());
                                }
                        }

                        public static bool TryParse (XmlElement _element, out WebModule _result) {
                                _result = default;


                                if (!_element.TryGetAttribute ("name", out string name)) {
                                        Log.Warning ($"[Web] [Perms] Ignoring module-entry because of missing 'name' attribute: {_element.OuterXml}");
                                        return false;
                                }

                                if (!_element.TryGetAttribute ("permission_level", out string permissionLevelString)) {
                                        Log.Warning ($"[Web] [Perms] Ignoring module-entry because of missing 'permission_level' attribute: {_element.OuterXml}");
                                        return false;
                                }

                                if (!int.TryParse (permissionLevelString, out int permissionLevel)) {
                                        Log.Warning (
                                                $"[Web] [Perms] Ignoring module-entry because of invalid (non-numeric) value for 'permission_level' attribute: {_element.OuterXml}");
                                        return false;
                                }

                                int[] perMethodLevels = null;
                                
                                foreach (XmlNode child in _element.ChildNodes) {
                                        if (child.NodeType != XmlNodeType.Element) {
                                                continue;
                                        }

                                        XmlElement childElem = (XmlElement)child;
                                        if (childElem.Name != "method") {
                                                Log.Warning ($"[Web] [Perms] Ignoring module child element, invalid element name: {childElem.OuterXml}");
                                                continue;
                                        }

                                        if (!childElem.TryGetAttribute ("name", out string methodName)) {
                                                Log.Warning ($"[Web] [Perms] Ignoring module child element, missing 'name' attribute: {childElem.OuterXml}");
                                                continue;
                                        }

                                        if (!EnumUtils.TryParse (methodName, out ERequestMethod method, true)) {
                                                Log.Warning (
                                                        $"[Web] [Perms] Ignoring module child element, unknown method name in 'name' attribute: {childElem.OuterXml}");
                                                continue;
                                        }

                                        if (method >= ERequestMethod.Count) {
                                                Log.Warning (
                                                        $"[Web] [Perms] Ignoring module child element, invalid method name in 'name' attribute: {childElem.OuterXml}");
                                                continue;
                                        }
                                        
                                        if (!childElem.TryGetAttribute ("permission_level", out permissionLevelString)) {
                                                Log.Warning ($"[Web] [Perms] Ignoring module child element, missing 'permission_level' attribute: {childElem.OuterXml}");
                                                continue;
                                        }

                                        int methodPermissionLevel;
                                        if (permissionLevelString.EqualsCaseInsensitive (MethodLevelInheritKeyword)) {
                                                methodPermissionLevel = MethodLevelInheritGlobal;
                                        } else if (!int.TryParse (permissionLevelString, out methodPermissionLevel)) {
                                                Log.Warning (
                                                        $"[Web] [Perms] Ignoring module child element, invalid (non-numeric) value for 'permission_level' attribute: {childElem.OuterXml}");
                                                continue;
                                        }

                                        perMethodLevels ??= createDefaultPerMethodArray ();
                                        perMethodLevels [(int)method] = methodPermissionLevel;
                                }

                                _result = new WebModule (name, permissionLevel, perMethodLevels, false);

                                return true;
                        }

                        [MustUseReturnValue]
                        public WebModule SetLevelGlobal (int _level) {
                                int[] perMethodClone = LevelPerMethod == null ? null : new int[LevelPerMethod.Length];
                                if (perMethodClone != null) {
                                        Array.Copy (LevelPerMethod, perMethodClone, perMethodClone.Length);
                                }

                                return new WebModule (Name, _level, perMethodClone, false);
                        }

                        [MustUseReturnValue]
                        public WebModule SetLevelForMethod (ERequestMethod _method, int _level) {
                                int[] perMethodClone = createDefaultPerMethodArray ();
                                if (LevelPerMethod != null) {
                                        Array.Copy (LevelPerMethod, perMethodClone, perMethodClone.Length);
                                }

                                perMethodClone[(int)_method] = _level;
                                
                                return new WebModule (Name, LevelGlobal, perMethodClone, false);
                        }
                        
                        private static int[] createDefaultPerMethodArray () {
                                int[] result = new int[(int)ERequestMethod.Count];

                                for (int i = 0; i < (int)ERequestMethod.Count; i++) {
                                        result [i] = MethodLevelNotSupported;
                                }

                                return result;
                        }

                        [MustUseReturnValue]
                        public WebModule FixPermissionLevelsFromKnownModule (WebModule _knownModule) {
                                if (_knownModule.LevelPerMethod == null) {
                                        if (LevelPerMethod != null) {
                                                return new WebModule (Name, LevelGlobal, false);
                                        }
                                        return this;
                                }
                                
                                WebModule result = this;
                                for (int i = 0; i < _knownModule.LevelPerMethod.Length; i++) {
                                        if (result.LevelPerMethod == null || result.LevelPerMethod[i] == MethodLevelNotSupported) {
                                                result = result.SetLevelForMethod ((ERequestMethod)i, _knownModule.LevelPerMethod[i]);
                                        }
                                }

                                return result;
                        }
                }


#region Specials

                /// <summary>
                /// Use global (API based) permission level for the method
                /// </summary>
                public const int MethodLevelInheritGlobal = int.MinValue;

                /// <summary>
                /// Keyword used to signal inherit level on user facing levels like admins.xml or WebAPIs
                /// </summary>
                public const string MethodLevelInheritKeyword = "inherit";

                /// <summary>
                /// Method not supported
                /// </summary>
                public const int MethodLevelNotSupported = int.MinValue + 1;

                public const int PermissionLevelUser = 1000;
                public const int PermissionLevelGuest = 2000;

                /// <summary>
                /// Contains all registered modules and their default permission
                /// </summary>
                private readonly Dictionary<string, WebModule> knownModules = new CaseInsensitiveStringDictionary<WebModule> ();

                /// <summary>
                /// Public list of all modules, both those with custom permissions as well as those that do not with their default permission
                /// </summary>
                private readonly List<WebModule> allModulesList = new List<WebModule> ();

                public void AddKnownModule (WebModule _module) {
                        if (!_module.IsDefault) {
                                Log.Warning ($"Call to AddKnownModule with IsDefault==false! From:\n{StackTraceUtility.ExtractStackTrace()}");
                        }

                        if (string.IsNullOrEmpty (_module.Name)) {
                                return;
                        }

                        lock (Parent) {
                                allModulesList.Clear ();
                                knownModules [_module.Name] = _module;
                                
                                if (modules.TryGetValue (_module.Name, out WebModule overrideModule)) {
                                        overrideModule = overrideModule.FixPermissionLevelsFromKnownModule (_module);
                                        modules[_module.Name] = overrideModule;
                                }
                        }
                }

                public bool IsKnownModule (string _module) {
                        if (string.IsNullOrEmpty (_module)) {
                                return false;
                        }

                        lock (Parent) {
                                return knownModules.ContainsKey (_module);
                        }
                }

                public bool ModuleAllowedWithLevel (string _module, int _level) {
                        lock (Parent) {
                                return GetModule (_module).LevelGlobal >= _level;
                        }
                }

                public WebModule GetModule (string _module) {
                        lock (Parent) {
                                if (modules.TryGetValue (_module, out WebModule result)) {
                                        return result;
                                }

                                return knownModules.TryGetValue (_module, out result) ? result : defaultModulePermission;
                        }
                }

                private readonly WebModule defaultModulePermission = new WebModule ("", 0, true);
                
#endregion

        }
}