#nullable enable
using System;
using System.Collections.Concurrent;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Barotrauma.Debugging;
using Barotrauma.Networking;
using Barotrauma;

namespace EosInterfacePrivate;

static class LoginPrivate
{
    private const string EosLoginSteamIdentity = "BarotraumaEosLogin";
    private static Option<Steamworks.AuthTicket> steamworksAuthTicket;

    private static Option<ulong> eosConnectExpirationNotifyId, eosConnectStatusChangedNotifyId;
    private static Option<ulong> egsAuthExpirationNotifyId;

    internal static void Init()
    {
        if (CorePrivate.ConnectInterface is not { } connectInterface) { return; }
        if (CorePrivate.EgsAuthInterface is not { } egsAuthInterface) { return; }

        ClearNotificationId(ref egsAuthExpirationNotifyId, egsAuthInterface.RemoveNotifyLoginStatusChanged);
        var authExpirationOptions = new Epic.OnlineServices.Auth.AddNotifyLoginStatusChangedOptions();
        ulong authExpirationNotifyId = egsAuthInterface.AddNotifyLoginStatusChanged(ref authExpirationOptions, null, OnEgsAuthStatusChanged);
        StoreNotificationId(out egsAuthExpirationNotifyId, authExpirationNotifyId);

        ClearNotificationId(ref eosConnectExpirationNotifyId, connectInterface.RemoveNotifyAuthExpiration);
        var connectExpirationOptions = new Epic.OnlineServices.Connect.AddNotifyAuthExpirationOptions();
        ulong connectExpirationNotifyId = connectInterface.AddNotifyAuthExpiration(ref connectExpirationOptions, null, OnConnectExpiration);
        StoreNotificationId(out eosConnectExpirationNotifyId, connectExpirationNotifyId);

        ClearNotificationId(ref eosConnectStatusChangedNotifyId, connectInterface.RemoveNotifyLoginStatusChanged);
        var addNotifyConnectStatusChangedOptions = new Epic.OnlineServices.Connect.AddNotifyLoginStatusChangedOptions();
        var connectChangedNotifyId = connectInterface.AddNotifyLoginStatusChanged(ref addNotifyConnectStatusChangedOptions, null, OnConnectStatusChanged);
        StoreNotificationId(out eosConnectStatusChangedNotifyId, connectChangedNotifyId);

        static void ClearNotificationId(ref Option<ulong> field, Action<ulong> clearAction)
        {
            if (field.TryUnwrap(out var notificationId))
            {
                clearAction(notificationId);
            }
            field = Option.None;
        }

        static void StoreNotificationId(out Option<ulong> field, ulong value)
        {
            bool isValid = value is not Epic.OnlineServices.Common.InvalidNotificationid;
            field = isValid
                ? Option.Some(value)
                : Option.None;
        }
    }

    internal static readonly ConcurrentDictionary<EosInterface.ProductUserId, AccountId> PuidToPrimaryExternalId = new();

    private readonly record struct LoginParams(
        Epic.OnlineServices.Connect.Credentials Credentials,
        AccountId ExternalAccountId);
    
    private static async Task<Result<LoginParams, EosInterface.Login.LoginError>> GenCredentialsSteam()
    {
        if (!Steamworks.SteamClient.IsValid || !Steamworks.SteamClient.IsLoggedOn) { return Result.Failure(EosInterface.Login.LoginError.SteamNotLoggedIn); }
        if (steamworksAuthTicket.TryUnwrap(out var oldTicket)) { oldTicket.Cancel(); }
        var newTicketNullable = await Steamworks.SteamUser.GetAuthTicketForWebApiAsync(EosLoginSteamIdentity);
        if (newTicketNullable is not { Data: not null } ticket)
        {
            return Result.Failure(EosInterface.Login.LoginError.FailedToGetSteamSessionTicket);
        }
        return Result.Success(
            new LoginParams(
                Credentials: new Epic.OnlineServices.Connect.Credentials
                {
                    Token = ToolBoxCore.ByteArrayToHexString(ticket.Data),
                    Type = Epic.OnlineServices.ExternalCredentialType.SteamSessionTicket
                },
                ExternalAccountId: new SteamId(Steamworks.SteamClient.SteamId)));
    }

    private static async Task<Result<Either<LoginParams, Epic.OnlineServices.ContinuanceToken>, EosInterface.Login.LoginError>> GenCredentialsEpic(
        Epic.OnlineServices.Auth.LoginCredentialType credentialsType,
        string? credentialsId,
        string? credentialsToken,
        Epic.OnlineServices.ExternalCredentialType credentialsExternalType,
        EosInterface.Login.LoginEpicFlags flags)
    {
        if (CorePrivate.EgsAuthInterface is not { } egsAuthInterface) { return Result.Failure(EosInterface.Login.LoginError.EosNotInitialized); }

        if (credentialsType is not (
            Epic.OnlineServices.Auth.LoginCredentialType.ExternalAuth
            or Epic.OnlineServices.Auth.LoginCredentialType.Developer
            or Epic.OnlineServices.Auth.LoginCredentialType.ExchangeCode))
        {
            return Result.Failure(EosInterface.Login.LoginError.InvalidUser);
        }

        var authLoginOptions = new Epic.OnlineServices.Auth.LoginOptions
        {
            Credentials = new Epic.OnlineServices.Auth.Credentials
            {
                Id = credentialsId,
                Token = credentialsToken,
                Type = credentialsType,
                SystemAuthCredentialsOptions = default,
                ExternalType = credentialsExternalType
            },
            ScopeFlags =
                Epic.OnlineServices.Auth.AuthScopeFlags.BasicProfile
                | Epic.OnlineServices.Auth.AuthScopeFlags.Presence
                | Epic.OnlineServices.Auth.AuthScopeFlags.FriendsList,
            LoginFlags = flags.HasFlag(EosInterface.Login.LoginEpicFlags.FailWithoutOpeningBrowser)
                ? Epic.OnlineServices.Auth.LoginFlags.NoUserInterface
                : Epic.OnlineServices.Auth.LoginFlags.None
        };

        var authLoginWaiter = new CallbackWaiter<Epic.OnlineServices.Auth.LoginCallbackInfo>();
        egsAuthInterface.Login(options: ref authLoginOptions, clientData: null, completionDelegate: authLoginWaiter.OnCompletion);

        // This can time out if authLoginOptions.ScopeFlags is set incorrectly,
        // because the docs lied and this callback isn't guaranteed to be called
        var authLoginCallbackInfoOption = await authLoginWaiter.Task;

        if (!authLoginCallbackInfoOption.TryUnwrap(out var authLoginCallbackInfo))
        {
            return Result.Failure(EosInterface.Login.LoginError.EgsLoginTimeout);
        }
        if (authLoginCallbackInfo is { ResultCode: Epic.OnlineServices.Result.InvalidUser, ContinuanceToken: { } continuanceToken })
        {
            return Result.Success((Either<LoginParams, Epic.OnlineServices.ContinuanceToken>)continuanceToken);
        }
        
        if (authLoginCallbackInfo.ResultCode != Epic.OnlineServices.Result.Success)
        {
            return Result.Failure(authLoginCallbackInfo.ResultCode switch {
                Epic.OnlineServices.Result.NotFound
                    => EosInterface.Login.LoginError.EgsAccountNotFound,
                Epic.OnlineServices.Result.AuthExchangeCodeNotFound
                    => EosInterface.Login.LoginError.AuthExchangeCodeNotFound,
                Epic.OnlineServices.Result.AuthUserInterfaceRequired
                    => EosInterface.Login.LoginError.AuthRequiresOpeningBrowser,
                Epic.OnlineServices.Result.AccessDenied
                    => EosInterface.Login.LoginError.EgsAccessDenied,
                _
                    => EosInterface.Login.LoginError.UnhandledFailureCondition
            });
        }
        if (!EpicAccountId.Parse(authLoginCallbackInfo.LocalUserId.ToString()).TryUnwrap(out var externalAccountId))
        {
            return Result.Failure(EosInterface.Login.LoginError.FailedToParseEgsId);
        }

        var copyIdTokenOptions = new Epic.OnlineServices.Auth.CopyIdTokenOptions
        {
            AccountId = authLoginCallbackInfo.LocalUserId
        };

        var tokenCopyResult = egsAuthInterface.CopyIdToken(ref copyIdTokenOptions, out var tokenNullable);
        if (tokenCopyResult != Epic.OnlineServices.Result.Success)
        {
            Result.Failure(EosInterface.Login.LoginError.FailedToGetEgsIdToken);
        }
        if (tokenNullable is not { } token) { return Result.Failure(EosInterface.Login.LoginError.FailedToGetEgsIdToken); }

        return Result.Success(
            (Either<LoginParams, Epic.OnlineServices.ContinuanceToken>)new LoginParams(
                Credentials: new Epic.OnlineServices.Connect.Credentials
                {
                    Token = token.JsonWebToken,
                    Type = Epic.OnlineServices.ExternalCredentialType.EpicIdToken
                },
                ExternalAccountId: externalAccountId));
    }

    public static async Task<Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>> LoginSteam()
    {
        var credentialsSteamResult = await GenCredentialsSteam();
        if (credentialsSteamResult.TryUnwrapFailure(out var error))
        {
            return Result.Failure(error);
        }
        if (!credentialsSteamResult.TryUnwrapSuccess(out var loginParams))
        {
            return Result.Failure(EosInterface.Login.LoginError.InvalidUser);
        }

        var result = await Login(loginParams);
        if (steamworksAuthTicket.TryUnwrap(out var ticket)) { ticket.Cancel(); }
        steamworksAuthTicket = Option.None;
        return result;
    }

    public static async Task<Result<OneOf<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken, EosInterface.EgsAuthContinuanceToken>, EosInterface.Login.LoginError>> LoginEpicWithLinkedSteamAccount(EosInterface.Login.LoginEpicFlags flags)
    {
        if (steamworksAuthTicket.TryUnwrap(out var oldTicket)) { oldTicket.Cancel(); }
        var newTicketNullable = await Steamworks.SteamUser.GetAuthTicketForWebApiAsync(EosLoginSteamIdentity);
        if (newTicketNullable is not { Data: not null } ticket)
        {
            return Result.Failure(EosInterface.Login.LoginError.FailedToGetSteamSessionTicket);
        }
        var epicCredentialsOption = await GenCredentialsEpic(
            credentialsType: Epic.OnlineServices.Auth.LoginCredentialType.ExternalAuth,
            credentialsId: null,
            credentialsToken: ToolBoxCore.ByteArrayToHexString(ticket.Data),
            credentialsExternalType: Epic.OnlineServices.ExternalCredentialType.SteamSessionTicket,
            flags: flags);
        if (epicCredentialsOption.TryUnwrapFailure(out var epicCredentialsFail))
        {
            return Result.Failure(epicCredentialsFail);
        }
        if (!epicCredentialsOption.TryUnwrapSuccess(out var loginParamsOrContinuanceToken))
        {
            return Result.Failure(EosInterface.Login.LoginError.UnhandledFailureCondition);
        }

        if (loginParamsOrContinuanceToken.TryGet(out Epic.OnlineServices.ContinuanceToken continuanceToken))
        {
            return Result.Success((OneOf<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken, EosInterface.EgsAuthContinuanceToken>)
                new EosInterface.EgsAuthContinuanceToken(continuanceToken.InnerHandle, ExtractExpiryTimeFromContinuanceToken(continuanceToken, EosInterface.EgsAuthContinuanceToken.Duration)));
        }
        if (!loginParamsOrContinuanceToken.TryGet(out LoginParams loginParams))
        {
            return Result.Failure(EosInterface.Login.LoginError.UnexpectedContinuanceToken);
        }

        var loginResult = await Login(loginParams);
        if (loginResult.TryUnwrapSuccess(out var loginSuccess))
        {
            return loginSuccess.TryGet(out EosInterface.EosConnectContinuanceToken eosContinuanceToken)
                ? Result.Success((OneOf<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken, EosInterface.EgsAuthContinuanceToken>)eosContinuanceToken)
                : loginSuccess.TryGet(out EosInterface.ProductUserId puid)
                    ? Result.Success((OneOf<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken, EosInterface.EgsAuthContinuanceToken>)puid)
                    : Result.Failure(EosInterface.Login.LoginError.UnhandledFailureCondition);
        }
        return loginResult.TryUnwrapFailure(out var loginFailure)
            ? Result.Failure(loginFailure)
            : Result.Failure(EosInterface.Login.LoginError.UnhandledFailureCondition);
    }

    public static async Task<Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>> LoginEpicExchangeCode(string exchangeCode)
    {
        var epicCredentialsOption = await GenCredentialsEpic(
            credentialsType: Epic.OnlineServices.Auth.LoginCredentialType.ExchangeCode,
            credentialsId: "",
            credentialsToken: exchangeCode,
            credentialsExternalType: Epic.OnlineServices.ExternalCredentialType.Epic,
            flags: EosInterface.Login.LoginEpicFlags.None);
        if (epicCredentialsOption.TryUnwrapFailure(out var epicCredentialsFail))
        {
            return Result.Failure(epicCredentialsFail);
        }
        if (!epicCredentialsOption.TryUnwrapSuccess(out var loginParamsOrContinuanceToken))
        {
            return Result.Failure(EosInterface.Login.LoginError.UnhandledFailureCondition);
        }
        if (!loginParamsOrContinuanceToken.TryGet(out LoginParams loginParams))
        {
            return Result.Failure(EosInterface.Login.LoginError.UnexpectedContinuanceToken);
        }

        var result = await Login(loginParams);
        return result;
    }

    public static async Task<Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>> LoginEpicIdToken(EosInterface.EgsIdToken egsIdToken)
    {
        if (egsIdToken is not EgsIdTokenPrivate privateEgsIdToken) { return Result.Failure(EosInterface.Login.LoginError.InvalidUser); }
        var credentials = new Epic.OnlineServices.Connect.Credentials
        {
            Token = privateEgsIdToken.InternalToken.JsonWebToken,
            Type = Epic.OnlineServices.ExternalCredentialType.EpicIdToken
        };

        return await Login(new LoginParams(credentials, privateEgsIdToken.AccountId));
    }

    private static DateTime ExtractExpiryTimeFromContinuanceToken(Epic.OnlineServices.ContinuanceToken continuanceToken, TimeSpan fallbackDuration)
    {
        // Not the exact expiry time, but it's a pretty close guess should we fail to decode the continuance token
        var expiryTime = DateTime.Now + fallbackDuration;
        
        // This method exists to replace Epic.OnlineServices.ContinuanceToken.ToString because
        // the generated code is broken, and I don't want to modify it because we risk undoing
        // a fix when we update the SDK.
        static string continuanceTokenToString(Epic.OnlineServices.ContinuanceToken continuanceToken)
        {
            int inOutBufferLength = 1024;
            System.IntPtr outBufferAddress = Epic.OnlineServices.Helper.AddAllocation(inOutBufferLength);

            var funcResult = Epic.OnlineServices.Bindings.EOS_ContinuanceToken_ToString(continuanceToken.InnerHandle, outBufferAddress, ref inOutBufferLength);
            if (funcResult == Epic.OnlineServices.Result.LimitExceeded)
            {
                // Buffer wasn't large enough to copy the string.
                // inOutBufferLength was updated by the last call to be the actual length required.
                // Generate a new buffer and try again.
                Epic.OnlineServices.Helper.Dispose(ref outBufferAddress);
                outBufferAddress = Epic.OnlineServices.Helper.AddAllocation(inOutBufferLength);
                funcResult = Epic.OnlineServices.Bindings.EOS_ContinuanceToken_ToString(continuanceToken.InnerHandle, outBufferAddress, ref inOutBufferLength);
                if (funcResult != Epic.OnlineServices.Result.Success)
                {
                    DebugConsoleCore.Log($"EOS_ContinuanceToken_ToString failed with result {funcResult}");
                }
            }

            Epic.OnlineServices.Utf8String outBuffer = "EOS_ContinuanceToken_ToString failed";
            if (funcResult == Epic.OnlineServices.Result.Success)
            {
                Epic.OnlineServices.Helper.Get(outBufferAddress, out outBuffer);
            }
            Epic.OnlineServices.Helper.Dispose(ref outBufferAddress);

            return outBuffer;
        }

        var ctDecode = JsonWebToken.Parse(continuanceTokenToString(continuanceToken));
        if (ctDecode.TryUnwrap(out var jwt))
        {
            string decodedPayload = jwt.PayloadDecoded;
            try
            {
                // Ugly regex hack to get expiry time. The right thing to do would be to parse the payload as JSON,
                // but I don't really care because we're extracting one field out of this whole thing.
                string expiryTimeUnix = Regex.Match(decodedPayload, @"""exp""\s*:\s*([0-9]+)").Groups[1].Value;
                expiryTime = UnixTime.ParseUtc(expiryTimeUnix).Fallback(UnixTime.UtcEpoch).ToLocalTime();
            }
            catch
            {
                // could not extract expiry time, oh well!
            }
        }

        return expiryTime;
    }

    private static async Task<Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>> Login(LoginParams loginParams)
    {
        static Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError> success(EosInterface.ProductUserId id)
            => Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>.Success(id);
        static Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError> continuance(EosInterface.EosConnectContinuanceToken token)
            => Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>.Success(token);
        static Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError> failure(EosInterface.Login.LoginError error)
            => Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>.Failure(error);

        if (CorePrivate.ConnectInterface is not { } connectInterface) { return failure(EosInterface.Login.LoginError.EosNotInitialized); }

        var loginOptions = new Epic.OnlineServices.Connect.LoginOptions
        {
            Credentials = loginParams.Credentials,
            UserLoginInfo = null
        };
        AccountId primaryExternalId = loginParams.ExternalAccountId;

        var loginWaiter = new CallbackWaiter<Epic.OnlineServices.Connect.LoginCallbackInfo>();
        connectInterface.Login(options: ref loginOptions, clientData: null, completionDelegate: loginWaiter.OnCompletion);
        var callbackResultOption = await loginWaiter.Task;
        if (!callbackResultOption.TryUnwrap(out var callbackResult))
        {
            return failure(EosInterface.Login.LoginError.Timeout);
        }

        if (callbackResult.ResultCode == Epic.OnlineServices.Result.Success)
        {
            var retVal = new EosInterface.ProductUserId(callbackResult.LocalUserId.ToString());
            PuidToPrimaryExternalId[retVal] = primaryExternalId;
            return success(retVal);
        }

        if (callbackResult is { ResultCode: Epic.OnlineServices.Result.InvalidUser, ContinuanceToken: { } continuanceToken })
        {
            var expiryTime = ExtractExpiryTimeFromContinuanceToken(continuanceToken, EosInterface.EosConnectContinuanceToken.Duration);

            return continuance(new EosInterface.EosConnectContinuanceToken(callbackResult.ContinuanceToken.InnerHandle, primaryExternalId, expiryTime));
        }

        return callbackResult.ResultCode switch
        {
            Epic.OnlineServices.Result.InvalidUser
                => failure(EosInterface.Login.LoginError.InvalidUser),
            Epic.OnlineServices.Result.AccessDenied
                => failure(EosInterface.Login.LoginError.EosAccessDenied),
            var unhandled
                => failure(unhandled.FailAndLogUnhandledError(EosInterface.Login.LoginError.UnhandledFailureCondition))
        };
    }

    private static void OnEgsAuthStatusChanged(ref Epic.OnlineServices.Auth.LoginStatusChangedCallbackInfo info)
    {
        var eaidOption = EpicAccountId.Parse(info.LocalUserId.ToString());
        if (!eaidOption.TryUnwrap(out var eaid)) { return; }

        if (info.CurrentStatus == Epic.OnlineServices.LoginStatus.NotLoggedIn)
        {
            TaskPool.Add(
                "UnlogPuidLinkedToEaid",
                IdQueriesPrivate.GetPuidForExternalId(eaid),
                t =>
                {
                    if (!t.TryGetResult(out Result<EosInterface.ProductUserId, Epic.OnlineServices.Result>? result)) { return; }
                    if (!result.TryUnwrapSuccess(out var puid)) { return; }

                    MarkAsInaccessible(puid);
                });
        }
    }

    public static void OnConnectExpiration(ref Epic.OnlineServices.Connect.AuthExpirationCallbackInfo info)
    {
        var puid = new EosInterface.ProductUserId(info.LocalUserId.ToString());
        DebugConsoleCore.Log($"OnAuthExpirationNotification {puid}");
        if (!PuidToPrimaryExternalId.TryGetValue(puid, out var externalId)) { return; }

        switch (externalId)
        {
            case SteamId:
            {
                static async Task RelogSteam()
                {
                    var steamCredentialsResult = await GenCredentialsSteam();
                    if (!steamCredentialsResult.TryUnwrapSuccess(out var loginParams)) { return; }
                    await Relog(loginParams);
                }

                TaskPool.Add(
                    "EosReLoginSteam",
                    RelogSteam(),
                    TaskPool.IgnoredCallback);
                break;
            }
            case EpicAccountId epicAccountId:
            {
                if (CopyEpicIdToken(epicAccountId).TryUnwrap(out var token))
                {
                    var epicLoginCredentials = new Epic.OnlineServices.Connect.Credentials
                    {
                        Token = token.JsonWebToken,
                        Type = Epic.OnlineServices.ExternalCredentialType.EpicIdToken
                    };
                    var reLogParams = new LoginParams(Credentials: epicLoginCredentials, ExternalAccountId: externalId);
                    TaskPool.Add("OnAuthExpirationNotification", Relog(reLogParams), onCompletion: TaskPool.IgnoredCallback);
                }

                break;
            }
        }

        static async Task Relog(LoginParams loginParams)
        {
            var loginOptions = new Epic.OnlineServices.Connect.LoginOptions
            {
                Credentials = loginParams.Credentials,
                UserLoginInfo = null
            };

            var connectLoginWaiter = new CallbackWaiter<Epic.OnlineServices.Connect.LoginCallbackInfo>();
            CorePrivate.ConnectInterface?.Login(options: ref loginOptions, clientData: null, completionDelegate: connectLoginWaiter.OnCompletion);
            var resultOption = await connectLoginWaiter.Task;
            if (resultOption.TryUnwrap(out var result))
            {
                string s = $"EOS relog result: {result.ResultCode}";
                if (result.LocalUserId != null)
                {
                    s += " : " + result.LocalUserId;
                }

                if (result.ContinuanceToken != null)
                {
                    s += " ; " + result.ContinuanceToken;
                }
                DebugConsoleCore.Log(s);
            }
            else
            {
                DebugConsoleCore.Log("EOS relog timed out");
            }
        }
    }

    private static void OnConnectStatusChanged(ref Epic.OnlineServices.Connect.LoginStatusChangedCallbackInfo info)
    {
        var puid = new EosInterface.ProductUserId(info.LocalUserId.ToString());
        DebugConsoleCore.Log($"OnLoginStatusChangedNotification {puid} {info.CurrentStatus}");
        if (info.CurrentStatus == Epic.OnlineServices.LoginStatus.NotLoggedIn)
        {
            PuidToPrimaryExternalId.TryRemove(puid, out _);
        }
    }

    public static async Task<Result<EpicAccountId, EosInterface.Login.LinkExternalAccountToEpicAccountError>> LinkExternalAccountToEpicAccount(EosInterface.EgsAuthContinuanceToken continuanceToken)
    {
        if (CorePrivate.EgsAuthInterface is not { } egsAuthInterface) { return Result.Failure(EosInterface.Login.LinkExternalAccountToEpicAccountError.EosNotInitialized); }

        var linkOptions = new Epic.OnlineServices.Auth.LinkAccountOptions
        {
            LinkAccountFlags = Epic.OnlineServices.Auth.LinkAccountFlags.NoFlags,
            ContinuanceToken = new Epic.OnlineServices.ContinuanceToken(continuanceToken.Spend()),
            LocalUserId = null
        };

        var callbackWaiter = new CallbackWaiter<Epic.OnlineServices.Auth.LinkAccountCallbackInfo>(timeout: TimeSpan.FromMinutes(5));
        egsAuthInterface.LinkAccount(options: ref linkOptions, clientData: null, completionDelegate: callbackWaiter.OnCompletion);
        var resultOption = await callbackWaiter.Task;

        if (!resultOption.TryUnwrap(out var result))
        {
            return Result.Failure(EosInterface.Login.LinkExternalAccountToEpicAccountError.TimedOut);
        }

        if (result.ResultCode == Epic.OnlineServices.Result.Success)
        {
            if (!EpicAccountId.Parse(result.SelectedAccountId.ToString()).TryUnwrap(out var epicAccountId))
            {
                return Result.Failure(EosInterface.Login.LinkExternalAccountToEpicAccountError.FailedToParseEgsAccountId);
            }
            return Result.Success(epicAccountId);
        }
        return Result.Failure(EosInterface.Login.LinkExternalAccountToEpicAccountError.UnhandledErrorCondition);
    }
    
    public static async Task<Result<Unit, EosInterface.Login.LogoutEpicAccountError>> LogoutEpicAccount(EpicAccountId egsId)
    {
        if (CorePrivate.EgsAuthInterface is not { } egsAuthInterface) { return Result.Failure(EosInterface.Login.LogoutEpicAccountError.EosNotInitialized); }

        var logoutOptions = new Epic.OnlineServices.Auth.LogoutOptions
        {
            LocalUserId = Epic.OnlineServices.EpicAccountId.FromString(egsId.EosStringRepresentation)
        };

        var callbackWaiter = new CallbackWaiter<Epic.OnlineServices.Auth.LogoutCallbackInfo>();
        egsAuthInterface.Logout(options: ref logoutOptions, clientData: null, completionDelegate: callbackWaiter.OnCompletion);
        var logoutResultOption = await callbackWaiter.Task;
        if (!logoutResultOption.TryUnwrap(out var logoutResult))
        {
            return Result.Failure(EosInterface.Login.LogoutEpicAccountError.TimedOut);
        }
        if (logoutResult.ResultCode == Epic.OnlineServices.Result.Success) { return Result.Success(Unit.Value); }

        return Result.Failure(logoutResult.ResultCode switch
        {
            _
                => EosInterface.Login.LogoutEpicAccountError.UnhandledErrorCondition
        });
    }

    public static void MarkAsInaccessible(EosInterface.ProductUserId puid)
    {
        PuidToPrimaryExternalId.TryRemove(puid, out _);
    }

    private static Option<Epic.OnlineServices.Auth.IdToken> CopyEpicIdToken(EpicAccountId epicAccountId)
    {
        if (CorePrivate.EgsAuthInterface is not { } egsAuthInterface) { return Option.None; }

        var copyIdTokenOptions = new Epic.OnlineServices.Auth.CopyIdTokenOptions
        {
            AccountId = Epic.OnlineServices.EpicAccountId.FromString(epicAccountId.EosStringRepresentation)
        };
        var result = egsAuthInterface.CopyIdToken(ref copyIdTokenOptions, out var tokenNullable);

        if (result is Epic.OnlineServices.Result.Success && tokenNullable is { } token)
        {
            return Option.Some(token);
        }

        return Option.None;
    }

    public static async Task<Result<EosInterface.ProductUserId, EosInterface.Login.CreateProductAccountError>> CreateProductAccount(EosInterface.EosConnectContinuanceToken eosContinuanceToken)
    {
        if (CorePrivate.ConnectInterface is not { } connectInterface) { return Result.Failure(EosInterface.Login.CreateProductAccountError.EosNotInitialized); }
        if (eosContinuanceToken is not { IsValid: true }) { return Result.Failure(EosInterface.Login.CreateProductAccountError.InvalidContinuanceToken); }

        var internalContinuanceToken = new Epic.OnlineServices.ContinuanceToken(eosContinuanceToken.Spend());
        var options = new Epic.OnlineServices.Connect.CreateUserOptions
        {
            ContinuanceToken = internalContinuanceToken
        };

        var createUserWaiter = new CallbackWaiter<Epic.OnlineServices.Connect.CreateUserCallbackInfo>();
        connectInterface.CreateUser(options: ref options, clientData: null, completionDelegate: createUserWaiter.OnCompletion);
        var callbackResultOption = await createUserWaiter.Task;
        if (!callbackResultOption.TryUnwrap(out var callbackResult))
        {
            return Result.Failure(EosInterface.Login.CreateProductAccountError.Timeout);
        }

        if (callbackResult.ResultCode == Epic.OnlineServices.Result.Success)
        {
            var retVal = new EosInterface.ProductUserId(callbackResult.LocalUserId.ToString());
            PuidToPrimaryExternalId[retVal] = eosContinuanceToken.ExternalAccountId;
            return Result.Success(retVal);
        }

        return Result.Failure(EosInterface.Login.CreateProductAccountError.UnhandledErrorCondition);
    }

    public static async Task<Result<Unit, EosInterface.Login.LinkExternalAccountError>> LinkExternalAccount(EosInterface.ProductUserId puid, EosInterface.EosConnectContinuanceToken eosContinuanceToken)
    {
        if (CorePrivate.ConnectInterface is not { } connectInterface) { return Result.Failure(EosInterface.Login.LinkExternalAccountError.EosNotInitialized); }
        if (eosContinuanceToken is not { IsValid: true }) { return Result.Failure(EosInterface.Login.LinkExternalAccountError.InvalidContinuanceToken); }

        var internalContinuanceToken = new Epic.OnlineServices.ContinuanceToken(eosContinuanceToken.Spend());
        var internalPuid = Epic.OnlineServices.ProductUserId.FromString(puid.Value);
        var options = new Epic.OnlineServices.Connect.LinkAccountOptions
        {
            LocalUserId = internalPuid,
            ContinuanceToken = internalContinuanceToken
        };

        var linkAccountAwaiter = new CallbackWaiter<Epic.OnlineServices.Connect.LinkAccountCallbackInfo>();
        connectInterface.LinkAccount(options: ref options, clientData: null, completionDelegate: linkAccountAwaiter.OnCompletion);
        var callbackResultOption = await linkAccountAwaiter.Task;
        if (!callbackResultOption.TryUnwrap(out var callbackResult))
        {
            return Result.Failure(EosInterface.Login.LinkExternalAccountError.Timeout);
        }

        if (callbackResult.ResultCode == Epic.OnlineServices.Result.Success)
        {
            return Result.Success(Unit.Value);
        }

        return Result.Failure(callbackResult.ResultCode switch
        {
            Epic.OnlineServices.Result.ConnectLinkAccountFailed
                => EosInterface.Login.LinkExternalAccountError.CannotLink,
            _
                => EosInterface.Login.LinkExternalAccountError.UnhandledErrorCondition
        });
    }

    public static async Task<Result<Unit, EosInterface.Login.UnlinkExternalAccountError>> UnlinkExternalAccount(EosInterface.ProductUserId puid)
    {
        if (CorePrivate.ConnectInterface is not { } connectInterface) { return Result.Failure(EosInterface.Login.UnlinkExternalAccountError.EosNotInitialized); }

        var internalPuid = Epic.OnlineServices.ProductUserId.FromString(puid.Value);
        var options = new Epic.OnlineServices.Connect.UnlinkAccountOptions
        {
            LocalUserId = internalPuid
        };

        var unlinkAccountAwaiter = new CallbackWaiter<Epic.OnlineServices.Connect.UnlinkAccountCallbackInfo>();
        connectInterface.UnlinkAccount(options: ref options, clientData: null, completionDelegate: unlinkAccountAwaiter.OnCompletion);
        var callbackResultOption = await unlinkAccountAwaiter.Task;
        if (!callbackResultOption.TryUnwrap(out var callbackResult))
        {
            return Result.Failure(EosInterface.Login.UnlinkExternalAccountError.Timeout);
        }

        if (callbackResult.ResultCode == Epic.OnlineServices.Result.Success)
        {
            PuidToPrimaryExternalId.TryRemove(puid, out _);
            return Result.Success(Unit.Value);
        }

        return Result.Failure(callbackResult.ResultCode switch
        {
            Epic.OnlineServices.Result.InvalidUser
                => EosInterface.Login.UnlinkExternalAccountError.InvalidUser,
            _
                => EosInterface.Login.UnlinkExternalAccountError.UnhandledErrorCondition
        });
    }
}

internal sealed partial class ImplementationPrivate : EosInterface.Implementation
{
    public override Task<Result<EosInterface.ProductUserId, EosInterface.Login.CreateProductAccountError>> CreateProductAccount(EosInterface.EosConnectContinuanceToken eosContinuanceToken)
        => TaskScheduler.Schedule(() => LoginPrivate.CreateProductAccount(eosContinuanceToken));

    public override Task<Result<Unit, EosInterface.Login.LinkExternalAccountError>> LinkExternalAccount(EosInterface.ProductUserId puid, EosInterface.EosConnectContinuanceToken eosContinuanceToken)
        => TaskScheduler.Schedule(() => LoginPrivate.LinkExternalAccount(puid, eosContinuanceToken));

    public override Task<Result<Unit, EosInterface.Login.UnlinkExternalAccountError>> UnlinkExternalAccount(EosInterface.ProductUserId puid)
        => TaskScheduler.Schedule(() => LoginPrivate.UnlinkExternalAccount(puid));

    public override Task<Result<OneOf<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken, EosInterface.EgsAuthContinuanceToken>, EosInterface.Login.LoginError>> LoginEpicWithLinkedSteamAccount(EosInterface.Login.LoginEpicFlags flags)
        => TaskScheduler.Schedule(() => LoginPrivate.LoginEpicWithLinkedSteamAccount(flags));

    public override Task<Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>> LoginEpicExchangeCode(string exchangeCode)
        => TaskScheduler.Schedule(() => LoginPrivate.LoginEpicExchangeCode(exchangeCode));

    public override Task<Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>> LoginEpicIdToken(EosInterface.EgsIdToken token)
        => TaskScheduler.Schedule(() => LoginPrivate.LoginEpicIdToken(token));

    public override Task<Result<Either<EosInterface.ProductUserId, EosInterface.EosConnectContinuanceToken>, EosInterface.Login.LoginError>> LoginSteam()
        => TaskScheduler.Schedule(LoginPrivate.LoginSteam);

    public override Task<Result<EpicAccountId, EosInterface.Login.LinkExternalAccountToEpicAccountError>> LinkExternalAccountToEpicAccount(EosInterface.EgsAuthContinuanceToken continuanceToken)
        => TaskScheduler.Schedule(() => LoginPrivate.LinkExternalAccountToEpicAccount(continuanceToken));

    public override Task<Result<Unit, EosInterface.Login.LogoutEpicAccountError>> LogoutEpicAccount(EpicAccountId egsId)
        => LoginPrivate.LogoutEpicAccount(egsId);

    public override void MarkAsInaccessible(EosInterface.ProductUserId puid)
        => LoginPrivate.MarkAsInaccessible(puid);

    public override void TestEosSessionTimeoutRecovery(EosInterface.ProductUserId puid)
    {
        var info = new Epic.OnlineServices.Connect.AuthExpirationCallbackInfo
        {
            ClientData = null,
            LocalUserId = Epic.OnlineServices.ProductUserId.FromString(puid.Value)
        };
        LoginPrivate.OnConnectExpiration(ref info);
    }
}