@using LibMatrix.EventTypes.Spec.State.Policy
@using System.Reflection
@using ArcaneLibs.Attributes
@using LibMatrix
@using System.Collections.Frozen
@using LibMatrix.EventTypes
@using LibMatrix.RoomTypes
<ModalWindow
    Title="@("Creating many new " + (PolicyTypes.ContainsKey(MappedType ?? "") ? PolicyTypes[MappedType!].GetFriendlyNamePluralOrNull()?.ToLower() ?? PolicyTypes[MappedType!].Name : "event"))"
    OnCloseClicked="@OnClose" X="60" Y="60" MinWidth="600">
    <span>Policy type:</span>
    <select @bind="@MappedType">
        <option>Select a value</option>
        @foreach (var (type, mappedType) in PolicyTypes) {
            <option value="@type">@mappedType.GetFriendlyName().ToLower()</option>
        }
    </select><br/>

    <span>Reason:</span>
    <FancyTextBox @bind-Value="@Reason"></FancyTextBox>
    <br/>

    <span>Recommendation:</span>
    <FancyTextBox @bind-Value="@Recommendation"></FancyTextBox>
    <br/>

    <span>Entities:</span><br/>
    <FancyTextBox Multiline="true" @bind-Value="@Entities"></FancyTextBox>
    <br/>


    @* <details> *@
    @*     <summary>JSON data</summary> *@
    @*     <pre> *@
    @*             $1$ @PolicyEvent.ToJson(true, true) #1# *@
    @*     </pre> *@
    @* </details> *@
    @if (!VerifyIntent) {
        <LinkButton OnClickAsync="@(() => {
                                      OnClose.Invoke();
                                      return Task.CompletedTask;
                                  })"> Cancel
        </LinkButton>
        <LinkButton OnClickAsync="@(() => {
                                      _ = Save();
                                      return Task.CompletedTask;
                                  })"> Save
        </LinkButton>
        @if (!string.IsNullOrWhiteSpace(Response)) {
            <pre style="color: red;">@Response</pre>
        }
    }
    else {
        <b class="blink">WARNING!!!</b>
        <br/>

        @if (!string.IsNullOrWhiteSpace(Response)) {
            <pre style="color: red;">@Response</pre>
        }

        <span>Are you sure you want to do this?</span>
        <LinkButton Color="#00FF00" OnClick="@(() => {
                                                 VerifyIntent = false;
                                                 Response = null;
                                                 StateHasChanged();
                                             })">No
        </LinkButton>
        <LinkButton Color="#FF0000" OnClick="@(() => { _ = Save(force: true); })">Yes</LinkButton>
    }

</ModalWindow>

@code {

    [Parameter]
    public required Action OnClose { get; set; }

    [Parameter]
    public required Action OnSaved { get; set; }

    [Parameter]
    public required GenericRoom Room { get; set; }

    private string Recommendation { get; set; } = "m.ban";
    private string Reason { get; set; } = "spam";

    private string Entities { get; set; } = "";

    private string? Response {
        get;
        set {
            field = value;
            StateHasChanged();
        }
    }

    private bool VerifyIntent { get; set; }

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

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

    private static FrozenSet<string> AllKnownPolicyTypes = KnownPolicyTypes
        .SelectMany(x => x.GetCustomAttributes<MatrixEventAttribute>().Select(y => y.EventName))
        .ToFrozenSet();

    private string? MappedType { get; set; }

    private async Task Save(bool force = false) {
        if (string.IsNullOrWhiteSpace(MappedType)) {
            Response = "No type selected";
            return;
        }

        if (string.IsNullOrWhiteSpace(Entities)) {
            Response = "No users selected";
            return;
        }

        Console.WriteLine("Saving ---");

        var entities = Entities.Split("\n", StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
            .Select(x => x.Trim())
            .Distinct()
            .ToList();

        if (!force && !Validate(entities, PolicyTypes[MappedType])) {
            List<string> distinctTypes = entities
                .Select(GuessType)
                .Where(x => x != null)
                .Distinct()
                .Select(x => x!.Name)
                .ToList();

            VerifyIntent = true;
            Response = $"Invalid entities. Expected {PolicyTypes[MappedType].Name}, got:\n - " +
                       string.Join("\n - ", distinctTypes);
            return;
        }

        try {
            await SaveAll(entities);
        }
        catch (Exception e) {
            Response = $"Failed to save: {e}";
        }
    }

    private bool Validate(List<string> entities, Type expectedType) {
        return entities.All(x => GuessType(x) == expectedType);
    }

    private Type? GuessType(string entity) {
        var sigil = entity[0];
        return TypesBySigil.GetValueOrDefault(sigil.ToString(), typeof(ServerPolicyRuleEventContent));
    }

    private Dictionary<string, Type> TypesBySigil = new() {
        { "@", typeof(UserPolicyRuleEventContent) },
        { "!", typeof(RoomPolicyRuleEventContent) },
        { "#", typeof(RoomPolicyRuleEventContent) }
    };

    private async Task SaveAll(List<string> entities) {
        await foreach (var evt in Room.GetFullStateAsync()) {
            if (evt is null
                || !AllKnownPolicyTypes.Contains(evt.Type)
                || !evt.TypedContent!.GetType().IsAssignableTo(PolicyTypes[MappedType!])
               ) continue;

            if (evt.TypedContent is PolicyRuleEventContent content && content.Recommendation == Recommendation && content.Reason == Reason) {
                if (content.Entity != null && entities.Contains(content.Entity))
                    entities.Remove(content.Entity);
            }
        }

        // var tasks = entities.Select(x => ExecuteBan(Room, x)).ToList();
        // await Task.WhenAll(tasks);

        var events = entities.Select(entity => {
            var content = Activator.CreateInstance(PolicyTypes[MappedType!]) as PolicyRuleEventContent ?? throw new InvalidOperationException("Failed to create event content");
            content.Recommendation = Recommendation;
            content.Reason = Reason;
            content.Entity = entity;
            return new MatrixEvent() {
                Type = MappedType,
                TypedContent = content,
                StateKey = content.GetDraupnir2StateKey()
            };
        });

        foreach (var chunk in events.Chunk(50))
            await Room.BulkSendEventsAsync(chunk);

        OnSaved.Invoke();
    }

    private async Task ExecuteBan(GenericRoom room, string entity) {
        bool success = false;
        while (!success) {
            try {
                var content = Activator.CreateInstance(PolicyTypes[MappedType!]) as PolicyRuleEventContent ?? throw new InvalidOperationException("Failed to create event content");
                content.Recommendation = Recommendation;
                content.Reason = Reason;
                content.Entity = entity;
                await room.SendStateEventAsync(MappedType!, content.GetDraupnir2StateKey(), content);
                success = true;
            }
            catch (MatrixException e) {
                if (e is not { ErrorCode: MatrixException.ErrorCodes.M_FORBIDDEN }) throw;
                Console.WriteLine(e);
            }
            catch (Exception e) {
                //ignored
                Console.WriteLine(e);
            }
        }
    }

}