@page "/"
@inject ILogger<Index> logger
@using LibMatrix.Responses
@using LibMatrix
@using ArcaneLibs
@using System.Diagnostics

<PageTitle>Index</PageTitle>

<h3>Rory&::MatrixUtils</h3>
Small collection of tools to do not-so-everyday things.

<br/><br/>
<h5>@totalSessions signed in sessions - <a href="/Login">Add new account</a></h5>
@if (scannedSessions != totalSessions) {
    <span>
        <span>@scannedSessions/@totalSessions</span>
        <progress max="@totalSessions" value="@scannedSessions"></progress>
    </span>
}
<hr/>
<form aria-busy="@Busy">
    <table>
        @foreach (var session in _sessions.OrderByDescending(x => x.UserInfo.RoomCount)) {
            var auth = session.Auth;
            <tr class="user-entry">
                <td>
                    @if (!string.IsNullOrWhiteSpace(@session.UserInfo?.AvatarUrl)) {
                        // Console.WriteLine($"Rendering {session.UserInfo.AvatarUrl} with homeserver {session.Homeserver}");
                        <MxcAvatar Homeserver="@session.Homeserver" MxcUri="@session.UserInfo.AvatarUrl" Circular="true" Size="4" SizeUnit="em"/>
                    }
                    else {
                        <img class="avatar" src="@_identiconGenerator.GenerateAsDataUri(session.Homeserver.WhoAmI.UserId)"/>
                    }
                    @* <img class="avatar" src="@session.UserInfo.AvatarUrl" crossorigin="anonymous"/> *@
                </td>
                <td class="user-info">
                    <p>
                        <input type="radio" name="csa" checked="@(_currentSession.Auth.AccessToken == auth.AccessToken)" @onclick="@(() => SwitchSession(session.SessionId))"
                               style="text-decoration-line: unset;"/>
                        <b>@session.UserInfo.DisplayName</b> on <b>@auth.Homeserver</b><br/>
                    </p>
                    <span style="display: inline-block; width: 128px;">@session.UserInfo.RoomCount rooms</span>
                    <a style="color: #888888"
                       href="@("/ServerInfo/" + session.Homeserver?.ServerName + "/")">@session.ServerVersion?.Server.Name @session.ServerVersion?.Server.Version</a>
                    @if (auth.Proxy != null) {
                        <span class="badge badge-info"> (proxied via @auth.Proxy)</span>
                    }
                    else {
                        <p>Not proxied</p>
                    }
                    @if (_debug) {
                        <p>T=@session.Homeserver.GetType().FullName</p>
                        <p>D=@session.Homeserver.WhoAmI.DeviceId</p>
                        <p>U=@session.Homeserver.WhoAmI.UserId</p>
                        <p>S=@session.Homeserver.WhoAmI.UserId</p>
                    }
                </td>
                <td>
                    <p>
                        <LinkButton OnClick="@(() => ManageUser(session.SessionId))">Manage</LinkButton>
                        <LinkButton OnClick="@(() => RemoveUser(session.SessionId))">Remove</LinkButton>
                        <LinkButton OnClick="@(() => RemoveUser(session.SessionId, true))">Log out</LinkButton>
                    </p>
                </td>
            </tr>
        }
    </table>
</form>

@if (_offlineSessions.Count > 0) {
    <br/>
    <br/>
    <h5>Sessions on unreachable servers</h5>
    <hr/>
    <form>
        <table>
            @foreach (var session in _offlineSessions) {
                <tr class="user-entry">
                    <td>
                        <p>
                            @{
                                string[] parts = session.Auth.UserId.Split(':');
                            }
                            <span>@parts[0][1..]</span> on <span>@parts[1]</span>
                            @if (!string.IsNullOrWhiteSpace(session.Auth.Proxy)) {
                                <span class="badge badge-info"> (proxied via @session.Auth.Proxy)</span>
                            }
                        </p>
                    </td>
                    <td>
                        <LinkButton OnClick="@(() => RemoveUser(session.SessionId))">Remove</LinkButton>
                    </td>
                </tr>
            }
        </table>
    </form>
}

@if (_invalidSessions.Count > 0) {
    <br/>
    <br/>
    <h5>Invalid sessions</h5>
    <hr/>
    <form>
        <table>
            @foreach (var session in _invalidSessions) {
                <tr class="user-entry">
                    <td>
                        <p>
                            @{
                                string[] parts = session.Auth.UserId.Split(':');
                            }
                            <span>@parts[0][1..]</span> on <span>@parts[1]</span>
                            @if (!string.IsNullOrWhiteSpace(session.Auth.Proxy)) {
                                <span class="badge badge-info"> (proxied via @session.Auth.Proxy)</span>
                            }
                        </p>
                    </td>
                    <td>
                        <LinkButton OnClick="@(() => Task.Run(() => NavigationManager.NavigateTo($"/InvalidSession?ctx={session.SessionId}")))">Re-login</LinkButton>
                    </td>
                    <td>
                        <LinkButton OnClick="@(() => RemoveUser(session.SessionId))">Remove</LinkButton>
                    </td>
                </tr>
            }
        </table>
    </form>
}

@code
{
#if DEBUG
    private const bool _debug = true;
#else
    private const bool _debug = false;
#endif

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

    private class HomepageSessionInfo : RmuSessionStore.SessionInfo {
        public UserInfo? UserInfo { get; set; }
        public ServerVersionResponse? ServerVersion { get; set; }
        public AuthenticatedHomeserverGeneric? Homeserver { get; set; }
    }

    private readonly List<HomepageSessionInfo> _sessions = [];
    private readonly List<RmuSessionStore.SessionInfo> _offlineSessions = [];
    private readonly List<RmuSessionStore.SessionInfo> _invalidSessions = [];
    private RmuSessionStore.SessionInfo? _currentSession;
    int scannedSessions, totalSessions = 1;
    private SvgIdenticonGenerator _identiconGenerator = new();

    protected override async Task OnInitializedAsync() {
        Console.WriteLine("Index.OnInitializedAsync");
        logger.LogDebug("Initialising index page");
        
        _currentSession = await sessionStore.GetCurrentSession();
        _sessions.Clear();
        _offlineSessions.Clear();
        var sessions = await sessionStore.GetAllSessions();
        scannedSessions = 0;
        totalSessions = sessions.Count;
        logger.LogDebug("Found {0} tokens", totalSessions);
        if (sessions is not { Count: > 0 }) {
            Console.WriteLine("No tokens found, trying migration from MRU...");
            sessions = await sessionStore.GetAllSessions();
            if (sessions is not { Count: > 0 }) {
                Console.WriteLine("No tokens found");
                return;
            }
        }

        List<string> offlineServers = [];
        var sema = new SemaphoreSlim(8, 8);
        var updateSw = Stopwatch.StartNew();
        var tasks = sessions.Select(async session => {
            await sema.WaitAsync();
            var token = session.Value.Auth;

            AuthenticatedHomeserverGeneric hs;
            try {
                Task<ServerVersionResponse> serverVersionTask = Task.FromResult<ServerVersionResponse>(new() {
                    Server = new() {
                        Name = "Unknown",
                        Version = "0.0.0"
                    }
                });
                try {
                    hs = await HsProvider.GetAuthenticatedWithToken(token.Homeserver, token.AccessToken, token.Proxy);
                    serverVersionTask = hs.FederationClient?.GetServerVersionAsync() ?? serverVersionTask!;
                }
                catch (Exception e) {
                    logger.LogError("Failed to get info for {0} via {1}: {2}", token.UserId, token.Homeserver, e);
                    logger.LogError("Continuing with server-less session");
                    hs = await HsProvider.GetAuthenticatedWithToken(token.Homeserver, token.AccessToken, token.Proxy, useGeneric: true, enableServer: false);
                }

                var joinedRoomsTask = hs.GetJoinedRooms();
                var profileTask = hs.GetProfileAsync(hs.WhoAmI.UserId);
                _sessions.Add(new() {
                    Auth = token,
                    SessionId = session.Value.SessionId,
                    Homeserver = hs,
                    UserInfo = new() {
                        AvatarUrl = (await profileTask).AvatarUrl,
                        RoomCount = (await joinedRoomsTask).Count,
                        DisplayName = (await profileTask).DisplayName ?? hs.WhoAmI.UserId
                    },
                    ServerVersion = await (serverVersionTask ?? Task.FromResult<ServerVersionResponse?>(null)!),
                });
                if (updateSw.ElapsedMilliseconds > 25) {
                    updateSw.Restart();
                    StateHasChanged();
                }
            }
            catch (MatrixException e) {
                if (e is { ErrorCode: "M_UNKNOWN_TOKEN" }) {
                    logger.LogWarning("Got unknown token error for {0} via {1}", token.UserId, token.Homeserver);
                    _invalidSessions.Add(session.Value);
                }
                else {
                    logger.LogError("Failed to get info for {0} via {1}: {2}", token.UserId, token.Homeserver, e);
                    throw;
                }
            }
            catch (Exception e) {
                logger.LogError("Failed to get info for {0} via {1}: {2}", token.UserId, token.Homeserver, e);
                if (!string.IsNullOrWhiteSpace(token.Proxy)) {
                    offlineServers.Add(token.Proxy);

                    sema.Release();
                    return;
                }

                offlineServers.Add(token.Homeserver);
            }

            scannedSessions++;
            sema.Release();
        }).ToList();
        await Task.WhenAll(tasks);
        scannedSessions = totalSessions;

        Busy = false;
        StateHasChanged();
        Console.WriteLine("Index.OnInitializedAsync finished");
    }

    private class UserInfo {
        internal string? AvatarUrl { get; set; }
        internal string DisplayName { get; set; }
        internal int RoomCount { get; set; }
    }

    private async Task RemoveUser(string sessionId, bool logout = false) {
        try {
            if (logout) {
                var auth = (await sessionStore.GetSession(sessionId))?.Auth;
                await (await HsProvider.GetAuthenticatedWithToken(auth.Homeserver, auth.AccessToken, auth.Proxy)).Logout();
            }
        }
        catch (Exception e) {
            if (e is MatrixException { ErrorCode: "M_UNKNOWN_TOKEN" }) {
                //todo: handle this
                return;
            }

            Console.WriteLine(e);
        }

        await sessionStore.RemoveSession(sessionId);
        StateHasChanged();
    }

    private async Task SwitchSession(string sessionId) {
        Console.WriteLine($"Switching to {sessionId}");
        await sessionStore.SetCurrentSession(sessionId);
        _currentSession = await sessionStore.GetCurrentSession();
        StateHasChanged();
    }

    private async Task ManageUser(string sessionId) {
        await sessionStore.SetCurrentSession(sessionId);
        NavigationManager.NavigateTo("/User/Profile");
    }
}