using Nuuru.Server.Auth;
using System.Reflection;

namespace Nuuru.Server.Services
{
    public interface IPermissionMetadataService
    {
        IEnumerable<PermissionInfo> GetAllPermissions();
        Dictionary<PermissionCategory, IEnumerable<PermissionInfo>> GetPermissionsByCategory();
        bool IsValidPermission(string permission);
        PermissionInfo? GetPermissionInfo(string permission);
    }

    public class PermissionInfo
    {
        public string Value { get; set; } = string.Empty;
        public string Description { get; set; } = string.Empty;
        public PermissionCategory Category { get; set; }
        public int DisplayOrder { get; set; }
    }

    public class PermissionMetadataService : IPermissionMetadataService
    {
        private readonly List<PermissionInfo> _permissions;
        private readonly Dictionary<string, PermissionInfo> _permissionLookup;

        public PermissionMetadataService()
        {
            _permissions = LoadPermissions();
            _permissionLookup = _permissions.ToDictionary(p => p.Value);
        }

        private List<PermissionInfo> LoadPermissions()
        {
            var permissions = new List<PermissionInfo>();

            // Get all nested types in the Permissions class (Moderation, Admin, User, Forum, etc.)
            var nestedTypes = typeof(Permissions).GetNestedTypes(BindingFlags.Public | BindingFlags.Static);

            foreach (var nestedType in nestedTypes)
            {
                // Get all const fields in each nested type
                var fields = nestedType.GetFields(BindingFlags.Public | BindingFlags.Static)
                    .Where(f => f.IsLiteral && !f.IsInitOnly);

                foreach (var field in fields)
                {
                    var attribute = field.GetCustomAttribute<PermissionMetadataAttribute>();
                    if (attribute != null)
                    {
                        var value = field.GetValue(null) as string;
                        if (value != null)
                        {
                            permissions.Add(new PermissionInfo
                            {
                                Value = value,
                                Description = attribute.Description,
                                Category = attribute.Category,
                                DisplayOrder = attribute.DisplayOrder
                            });
                        }
                    }
                }
            }

            return permissions
                .OrderBy(p => p.Category)
                .ThenBy(p => p.DisplayOrder)
                .ThenBy(p => p.Description)
                .ToList();
        }

        public IEnumerable<PermissionInfo> GetAllPermissions()
        {
            return _permissions;
        }

        public Dictionary<PermissionCategory, IEnumerable<PermissionInfo>> GetPermissionsByCategory()
        {
            return _permissions
                .GroupBy(p => p.Category)
                .ToDictionary(
                    g => g.Key,
                    g => g.AsEnumerable()
                );
        }

        public bool IsValidPermission(string permission)
        {
            return _permissionLookup.ContainsKey(permission);
        }

        public PermissionInfo? GetPermissionInfo(string permission)
        {
            return _permissionLookup.TryGetValue(permission, out var info) ? info : null;
        }
    }
}