using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using xCommons.Constants;
using xCommons.Extensions;
using xIdentityModels.Models;
using xIdentityService.Constants;

namespace xIdentityService.Extensions {
    public static class HttpContextExtensions {
        /// <summary>
        /// Retrieve Authentication Service ...
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public static IAuthenticationService GetAuthenticationService (this HttpContext context) {
            //
            var result = context.RequestServices
                .GetRequiredService<IAuthenticationService> ();

            //
            return result;
        }

        /// <summary>
        /// Retrieve Specific Token from HttpContext ...
        /// </summary>
        /// <param name="context"></param>
        /// <param name="tokenName"></param>
        /// <param name="scheme"></param>
        /// <returns></returns>
        public static async Task<string> GetXTokenAsync (
            this HttpContext context,
            string tokenName,
            XAuthenticationScheme scheme = XAuthenticationScheme.XToken
        ) {
            //
            // Validate Args ...
            if (tokenName.IsNullOrEmpty ()) {
                return null;
            }

            //
            var authService = context.GetAuthenticationService ();
            if (authService.IsNull ()) {
                return null;
            }

            //
            var authResult = await authService
                .AuthenticateAsync (
                    context,
                    scheme
                    .GetStringValue ()
                );

            //
            var result = authResult?.Properties?
                .GetTokenValue (tokenName);
            return result;
        }

        /// <summary>
        /// Retrieve Access Token
        /// </summary>
        /// <returns></returns>
        public static async Task<string> GetAccessToken (this HttpContext context) {
            //
            var accessToken = context.Request.Headers[XAuthorization.Header]
                .ToString ();
            if (accessToken.IsNullOrEmpty ()) {
                accessToken = await context
                    .GetTokenAsync (XAuthorization.AccessToken);
            }

            //
            if (accessToken
                .ToNormalString ()
                .Contains (XAuthorization.TokenIdentifier
                    .ToNormalString ())) {
                accessToken = accessToken
                    .Remove (0, XAuthorization.TokenIdentifier.Length);
            }

            //
            return accessToken;
        }

        /// <summary>
        /// Retrieve Refresh Token
        /// </summary>
        /// <returns></returns>
        public static async Task<string> GetRefreshToken (this HttpContext context) {
            //
            var refreshToken = context.Request.Headers[XAuthorization.RefreshToken]
                .ToString ();
            if (refreshToken.IsNullOrEmpty ()) {
                refreshToken = await context
                    .GetTokenAsync (XAuthorization.RefreshToken);
            }

            //
            return refreshToken;
        }

        /// <summary>
        /// Retrieve Access Token Expiration Date
        /// </summary>
        /// <returns></returns>
        public static async Task<long> GetTokenExpiresAt (this HttpContext context) {
            //
            var expiresAtStr = context.Request.Headers[XAuthorization.ExpiresAt]
                .ToString ();
            if (expiresAtStr.IsNullOrEmpty ()) {
                expiresAtStr = await context
                    .GetTokenAsync (XAuthorization.ExpiresAt);
            }

            //
            var expiresAt = expiresAtStr.ConvertTo<long> ();

            //
            return expiresAt;
        }

        /// <summary>
        /// Retrieve All Required Tokens
        /// </summary>
        /// <returns></returns>
        public static async Task<XTokenResponse> RetrieveTokensAsXTokenResponse (HttpContext context) {
            //
            var accessToken = await GetAccessToken (context);
            var refreshToken = await GetRefreshToken (context);
            var expiresAt = await GetTokenExpiresAt (context);

            //
            return new XTokenResponse {
                AccessToken = accessToken,
                    RefreshToken = refreshToken,
                    ExpiresAt = expiresAt
            };
        }
    }
}