@page "/Rooms/{RoomId}/Policies2"
@using LibMatrix
@using ArcaneLibs.Extensions
@using LibMatrix.EventTypes.Spec.State.Policy
@using System.Diagnostics
@using LibMatrix.RoomTypes
@using System.Collections.Frozen
@using System.Reflection
@using ArcaneLibs.Attributes
@using LibMatrix.EventTypes
@using LibMatrix.EventTypes.Spec.State.RoomInfo

@using MatrixUtils.Web.Shared.PolicyEditorComponents

<h3>Policy list editor - Editing @RoomId</h3>
<hr/>
@* <InputCheckbox @bind-Value="EnableAvatars"></InputCheckbox><label>Enable avatars (WILL EXPOSE YOUR IP TO TARGET HOMESERVERS!)</label> *@
<LinkButton OnClick="@(() => { CurrentlyEditingEvent = new() { Type = "", RawContent = new() }; return Task.CompletedTask; })">Create new policy</LinkButton>

@if (Loading) {
    <p>Loading...</p>
}
else if (PolicyEventsByType is not { Count: > 0 }) {
    <p>No policies yet</p>
}
else {
    var renderSw = Stopwatch.StartNew();
    var renderTotalSw = Stopwatch.StartNew();
    @foreach (var (type, value) in PolicyEventsByType) {
        <p>
            @(GetValidPolicyEventsByType(type).Count) active,
            @(GetInvalidPolicyEventsByType(type).Count) invalid
            (@value.Count total)
            @(GetPolicyTypeName(type).ToLower())
        </p>
    }

    Console.WriteLine($"Rendered hearder in {renderSw.GetElapsedAndRestart()}");

    @foreach (var type in KnownPolicyTypes.OrderByDescending(t => GetPolicyEventsByType(t).Count)) {
        <details>
            <summary>
                <span>
                    @($"{GetPolicyTypeName(type)}: {GetPolicyEventsByType(type).Count} policies")
                </span>
                <hr style="margin: revert;"/>
            </summary>
            <div class="flex-grid">
                @{
                    var policies = GetValidPolicyEventsByType(type);
                    var invalidPolicies = GetInvalidPolicyEventsByType(type);
                    // enumerate all properties with friendly name
                    var props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                        .Where(x => (x.GetFriendlyNameOrNull() ?? x.GetJsonPropertyNameOrNull()) is not null)
                        .Where(x => x.GetCustomAttribute<TableHideAttribute>() is null)
                        .ToFrozenSet();
                    var propNames = props.Select(x => x.GetFriendlyNameOrNull() ?? x.GetJsonPropertyName()!).ToFrozenSet();

                    var proxySafeProps = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                        .Where(x => props.Any(y => y.Name == x.Name))
                        .ToFrozenSet();
                    Console.WriteLine($"{proxySafeProps?.Count} proxy safe props found in {policies.FirstOrDefault()?.TypedContent?.GetType()}");
                }
                @foreach (var policy in policies.OrderBy(x => x.RawContent?["entity"]?.GetValue<string>())) {
                    <div class="flex-item">
                        @{
                            var typedContent = policy.TypedContent!;
                        }
                        @foreach (var prop in proxySafeProps ?? Enumerable.Empty<PropertyInfo>()) {
                            <td>@prop.GetGetMethod()?.Invoke(typedContent, null)</td>
                        }
                        <div style="display: ruby;">
                            @if (PowerLevels.UserHasStatePermission(Homeserver.WhoAmI.UserId, policy.Type)) {
                                <LinkButton OnClick="@(() => { CurrentlyEditingEvent = policy; return Task.CompletedTask; })">Edit</LinkButton>
                                <LinkButton OnClick="@(() => RemovePolicyAsync(policy))">Remove</LinkButton>
                                @if (policy.IsLegacyType) {
                                    <LinkButton OnClick="@(() => RemovePolicyAsync(policy))">Update policy type</LinkButton>
                                }

                                @if (PolicyTypeIds[typeof(ServerPolicyRuleEventContent)].Contains(policy.EventId)) {
                                    <LinkButton OnClick="@(() => { ServerPolicyToMakePermanent = policy; return Task.CompletedTask; })">Make permanent (wildcard)</LinkButton>
                                    @if (CurrentUserIsDraupnir) {
                                        <LinkButton OnClick="@(() => UpgradePolicyAsync(policy))">Kick matching users</LinkButton>
                                    }
                                }
                                else {
                                    <p>meow</p>
                                }
                            }
                            else {
                                <p>No permission to modify</p>
                            }
                        </div>
                    </div>
                }
            </div>
            <details>
                <summary>
                    <u>
                        @("Invalid " + GetPolicyTypeName(type).ToLower())
                    </u>
                </summary>
                <table class="table table-striped table-hover">
                    <thead>
                        <tr>
                            <th>State key</th>
                            <th>Json contents</th>
                        </tr>
                    </thead>
                    <tbody>
                        @foreach (var policy in invalidPolicies) {
                            <tr>
                                <td>@policy.StateKey</td>
                                <td>
                                    <pre>@policy.RawContent.ToJson(true, false)</pre>
                                </td>
                            </tr>
                        }
                    </tbody>
                </table>
            </details>
        </details>
    }

    Console.WriteLine($"Rendered policies in {renderSw.GetElapsedAndRestart()}");
    Console.WriteLine($"Rendered in {renderTotalSw.Elapsed}");
}

@if (CurrentlyEditingEvent is not null) {
    <PolicyEditorModal PolicyEvent="@CurrentlyEditingEvent" OnClose="@(() => CurrentlyEditingEvent = null)" OnSave="@(e => UpdatePolicyAsync(e))"></PolicyEditorModal>
}

@code {

#if DEBUG
    private const bool Debug = true;
#else
    private const bool Debug = false;
#endif

    private bool Loading { get; set; } = true;

    [Parameter]
    public string RoomId { get; set; }

    private bool _enableAvatars;
    private StateEventResponse? _currentlyEditingEvent;
    private StateEventResponse? _serverPolicyToMakePermanent;

    private Dictionary<Type, List<StateEventResponse>> PolicyEventsByType { get; set; } = new();

    private StateEventResponse? CurrentlyEditingEvent {
        get => _currentlyEditingEvent;
        set {
            _currentlyEditingEvent = value;
            StateHasChanged();
        }
    }

    private StateEventResponse? ServerPolicyToMakePermanent {
        get => _serverPolicyToMakePermanent;
        set {
            _serverPolicyToMakePermanent = value;
            StateHasChanged();
        }
    }

    private AuthenticatedHomeserverGeneric Homeserver { get; set; }
    private GenericRoom Room { get; set; }
    private RoomPowerLevelEventContent PowerLevels { get; set; }
    private bool CurrentUserIsDraupnir { get; set; }

    protected override async Task OnInitializedAsync() {
        var sw = Stopwatch.StartNew();
        await base.OnInitializedAsync();
        Homeserver = (await sessionStore.GetCurrentHomeserver(navigateOnFailure: true))!;
        if (Homeserver is null) return;
        Room = Homeserver.GetRoom(RoomId!);
        PowerLevels = (await Room.GetPowerLevelsAsync())!;
        CurrentUserIsDraupnir = (await Homeserver.GetAccountDataOrNullAsync<object>("org.matrix.mjolnir.protected_rooms")) is not null;
        await LoadStatesAsync();
        Console.WriteLine($"Policy list editor initialized in {sw.Elapsed}!");
    }

    private async Task LoadStatesAsync() {
        Loading = true;
        var states = Room.GetFullStateAsync();
        PolicyEventsByType.Clear();
        await foreach (var state in states) {
            if (state is null) continue;
            if (!state.MappedType.IsAssignableTo(typeof(PolicyRuleEventContent))) continue;
            if (!PolicyEventsByType.ContainsKey(state.MappedType)) PolicyEventsByType.Add(state.MappedType, new());
            PolicyEventsByType[state.MappedType].Add(state);
        }

        Loading = false;
        StateHasChanged();
    }

    private List<StateEventResponse> GetPolicyEventsByType(Type type) => PolicyEventsByType.ContainsKey(type) ? PolicyEventsByType[type] : [];

    private List<StateEventResponse> GetValidPolicyEventsByType(Type type) => GetPolicyEventsByType(type)
        .Where(x => !string.IsNullOrWhiteSpace(x.RawContent?["recommendation"]?.GetValue<string>())).ToList();

    private List<StateEventResponse> GetInvalidPolicyEventsByType(Type type) => GetPolicyEventsByType(type)
        .Where(x => string.IsNullOrWhiteSpace(x.RawContent?["recommendation"]?.GetValue<string>())).ToList();

    private string? GetPolicyTypeNameOrNull(Type type) => type.GetFriendlyNamePluralOrNull()
                                                          ?? type.GetCustomAttributes<MatrixEventAttribute>()
                                                              .FirstOrDefault(x => !string.IsNullOrWhiteSpace(x.EventName))?.EventName;

    private string GetPolicyTypeName(Type type) => GetPolicyTypeNameOrNull(type) ?? type.Name;

    private async Task RemovePolicyAsync(StateEventResponse policyEvent) {
        await Room.SendStateEventAsync(policyEvent.Type, policyEvent.StateKey.UrlEncode(), new { });
        PolicyEventsByType[policyEvent.MappedType].Remove(policyEvent);
        await LoadStatesAsync();
    }

    private async Task UpdatePolicyAsync(StateEventResponse policyEvent) {
        await Room.SendStateEventAsync(policyEvent.Type, policyEvent.StateKey.UrlEncode(), policyEvent.RawContent);
        CurrentlyEditingEvent = null;
        await LoadStatesAsync();
    }

    private async Task UpgradePolicyAsync(StateEventResponse policyEvent) {
        policyEvent.RawContent["upgraded_from_type"] = policyEvent.Type;
        await LoadStatesAsync();
    }

    private static FrozenSet<Type> KnownPolicyTypes = StateEvent.KnownStateEventTypes.Where(x => x.IsAssignableTo(typeof(PolicyRuleEventContent))).ToFrozenSet();

    // event types, unnamed
    private static Dictionary<string, Type> PolicyTypes = KnownPolicyTypes
        .ToDictionary(x => x.GetCustomAttributes<MatrixEventAttribute>().First(y => !string.IsNullOrWhiteSpace(y.EventName)).EventName, x => x);

    private static Dictionary<Type, string[]> PolicyTypeIds = KnownPolicyTypes
        .ToDictionary(x => x, x => x.GetCustomAttributes<MatrixEventAttribute>().Select(y => y.EventName).ToArray());

}