using Account;
using Grpc.Core;
using Grpc.Net.Client;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Pal.Client.Extensions;
using Pal.Client.Properties;
using Pal.Client.Configuration;
using Pal.Client.DependencyInjection;

namespace Pal.Client.Net
{
    internal partial class RemoteApi
    {
        private async Task<(bool Success, string Error)> TryConnect(CancellationToken cancellationToken, ILoggerFactory? loggerFactory = null, bool retry = true)
        {
            using IDisposable? logScope = _logger.BeginScope("TryConnect");

            if (_configuration.Mode != EMode.Online)
            {
                _logger.LogDebug("Not Online, not attempting to establish a connection");
                return (false, Localization.ConnectionError_NotOnline);
            }

            if (_channel == null || !(_channel.State == ConnectivityState.Ready || _channel.State == ConnectivityState.Idle))
            {
                Dispose();

                _logger.LogInformation("Creating new gRPC channel");
                _channel = GrpcChannel.ForAddress(RemoteUrl, new GrpcChannelOptions
                {
                    HttpHandler = new SocketsHttpHandler
                    {
                        ConnectTimeout = TimeSpan.FromSeconds(5),
                        SslOptions = GetSslClientAuthenticationOptions(),
                    },
                    LoggerFactory = loggerFactory,
                });

                _logger.LogInformation("Connecting to upstream service at {Url}", RemoteUrl);
                await _channel.ConnectAsync(cancellationToken);
            }

            cancellationToken.ThrowIfCancellationRequested();

            var accountClient = new AccountService.AccountServiceClient(_channel);
            IAccountConfiguration? configuredAccount = _configuration.FindAccount(RemoteUrl);
            if (configuredAccount == null)
            {
                _logger.LogInformation("No account information saved for {Url}, creating new account", RemoteUrl);
                var createAccountReply = await accountClient.CreateAccountAsync(new CreateAccountRequest(), headers: UnauthorizedHeaders(), deadline: DateTime.UtcNow.AddSeconds(10), cancellationToken: cancellationToken);
                if (createAccountReply.Success)
                {
                    if (!Guid.TryParse(createAccountReply.AccountId, out Guid accountId))
                        throw new InvalidOperationException("invalid account id returned");

                    configuredAccount = _configuration.CreateAccount(RemoteUrl, accountId);
                    _logger.LogInformation("Account created with id {AccountId}", accountId.ToPartialId());

                    _configurationManager.Save(_configuration);
                }
                else
                {
                    _logger.LogError("Account creation failed with error {Error}", createAccountReply.Error);
                    if (createAccountReply.Error == CreateAccountError.UpgradeRequired && !_warnedAboutUpgrade)
                    {
                        _chat.Error(Localization.ConnectionError_OldVersion);
                        _warnedAboutUpgrade = true;
                    }
                    return (false, string.Format(Localization.ConnectionError_CreateAccountFailed, createAccountReply.Error));
                }
            }

            cancellationToken.ThrowIfCancellationRequested();

            // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
            if (configuredAccount == null)
            {
                _logger.LogWarning("No account to login with");
                return (false, Localization.ConnectionError_CreateAccountReturnedNoId);
            }

            if (!_loginInfo.IsValid)
            {
                _logger.LogInformation("Logging in with account id {AccountId}", configuredAccount.AccountId.ToPartialId());
                LoginReply loginReply = await accountClient.LoginAsync(new LoginRequest { AccountId = configuredAccount.AccountId.ToString() }, headers: UnauthorizedHeaders(), deadline: DateTime.UtcNow.AddSeconds(10), cancellationToken: cancellationToken);
                if (loginReply.Success)
                {
                    _logger.LogInformation("Login successful with account id: {AccountId}", configuredAccount.AccountId.ToPartialId());
                    _loginInfo = new LoginInfo(loginReply.AuthToken);

                    bool save = configuredAccount.EncryptIfNeeded();

                    List<string> newRoles = _loginInfo.Claims?.Roles.ToList() ?? new();
                    if (!newRoles.SequenceEqual(configuredAccount.CachedRoles))
                    {
                        configuredAccount.CachedRoles = newRoles;
                        save = true;
                    }

                    if (save)
                        _configurationManager.Save(_configuration);
                }
                else
                {
                    _logger.LogError("Login failed with error {Error}", loginReply.Error);
                    _loginInfo = new LoginInfo(null);
                    if (loginReply.Error == LoginError.InvalidAccountId)
                    {
                        _configuration.RemoveAccount(RemoteUrl);
                        _configurationManager.Save(_configuration);
                        if (retry)
                        {
                            _logger.LogInformation("Attempting connection retry without account id");
                            return await TryConnect(cancellationToken, retry: false);
                        }
                        else
                            return (false, Localization.ConnectionError_InvalidAccountId);
                    }
                    if (loginReply.Error == LoginError.UpgradeRequired && !_warnedAboutUpgrade)
                    {
                        _chat.Error(Localization.ConnectionError_OldVersion);
                        _warnedAboutUpgrade = true;
                    }
                    return (false, string.Format(Localization.ConnectionError_LoginFailed, loginReply.Error));
                }
            }

            if (!_loginInfo.IsValid)
            {
                _logger.LogError("Login state is loggedIn={LoggedIn}, expired={Expired}", _loginInfo.IsLoggedIn, _loginInfo.IsExpired);
                return (false, Localization.ConnectionError_LoginReturnedNoToken);
            }

            cancellationToken.ThrowIfCancellationRequested();
            return (true, string.Empty);
        }

        private async Task<bool> Connect(CancellationToken cancellationToken)
        {
            var result = await TryConnect(cancellationToken);
            return result.Success;
        }

        public async Task<string> VerifyConnection(CancellationToken cancellationToken = default)
        {
            using IDisposable? logScope = _logger.BeginScope("VerifyConnection");

            _warnedAboutUpgrade = false;

            var connectionResult = await TryConnect(cancellationToken, loggerFactory: _loggerFactory);
            if (!connectionResult.Success)
                return string.Format(Localization.ConnectionError_CouldNotConnectToServer, connectionResult.Error);

            _logger.LogInformation("Connection established, trying to verify auth token");
            var accountClient = new AccountService.AccountServiceClient(_channel);
            await accountClient.VerifyAsync(new VerifyRequest(), headers: AuthorizedHeaders(), deadline: DateTime.UtcNow.AddSeconds(10), cancellationToken: cancellationToken);

            _logger.LogInformation("Verification returned no errors.");
            return Localization.ConnectionSuccessful;
        }

        internal sealed class LoginInfo
        {
            public LoginInfo(string? authToken)
            {
                if (!string.IsNullOrEmpty(authToken))
                {
                    IsLoggedIn = true;
                    AuthToken = authToken;
                    Claims = JwtClaims.FromAuthToken(authToken);
                }
                else
                    IsLoggedIn = false;
            }

            public bool IsLoggedIn { get; }
            public string? AuthToken { get; }
            public JwtClaims? Claims { get; }
            private DateTimeOffset ExpiresAt => Claims?.ExpiresAt.Subtract(TimeSpan.FromMinutes(5)) ?? DateTimeOffset.MinValue;
            public bool IsExpired => ExpiresAt < DateTimeOffset.UtcNow;

            public bool IsValid => IsLoggedIn && !IsExpired;
        }
    }
}