using System;
using System.Linq;
using xIdentityHelper;
using System.Threading;
using xCommons.Attributes;
using xCommons.Extensions;
using xIdentityModels.Dtos;
using xExceptions.Constants;
using xIdentityModels.Models;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using xIdentityModels.Extensions;
using Microsoft.AspNetCore.Authorization;
using static IdentityServer4.IdentityServerConstants;

namespace xIds.Controllers
{
    public partial class ApplicationsController
    {
        /// <summary>
        /// Show Api Key ...
        /// </summary>
        /// <param name="apiKeyId"></param>
        /// <param name="applicationId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [RequireXPowered]
        [Authorize(LocalApi.PolicyName)]
        [Authorize(Policy = XPolicies.EnabledUser)]
        [HttpGet("{applicationId}/ApiKeys/{apiKeyId}/Show")]
        public async Task<ActionResult<string>> ShowApiKey(
            [FromRoute] Guid apiKeyId,
            [FromRoute] int applicationId,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (
                    apiKeyId.IsDefaultGuid() ||
                    !applicationId.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var userInfo = await GetUserInfo();

                //
                var result = await provider.ShowApiKey(
                    userInfo: userInfo,
                    apiKeyId: apiKeyId,
                    applicationId: applicationId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result);
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Create Api Key ...
        /// </summary>
        /// <param name="applicationId"></param>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [RequireXPowered]
        [Authorize(LocalApi.PolicyName)]
        [Authorize(Policy = XPolicies.EnabledUser)]
        [HttpPost("{applicationId}/ApiKeys/Create")]
        public async Task<ActionResult<XApiKeyDto>> CreateApiKey(
            [FromRoute] int applicationId,
            [FromBody] XCreateApiKeyRequest request,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (
                    !request.IsValid() ||
                    !applicationId.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var userInfo = await GetUserInfo();

                //
                // Retrieve Application for Validating ...
                var application = await provider.GetApplicationAsync(
                    id: applicationId,
                    userInfo: userInfo,
                    includeBuilder: null,
                    ignoreSoftDeleteds: true
                );
                if (application.IsNullOrDefault())
                {
                    XException.NotFound.Throw();
                }

                //
                // Noramlize TimeSpan ...
                var expirationTimeSpan = TimeSpan
                    .FromMinutes(apiKeyConfiguration.DefaultExpirationMinutes);
                if (
                    request.ExpirationMinutes.HasValue &&
                    request.ExpirationMinutes.Value > 0
                )
                {
                    //
                    // Normalize Expiration Minutes ...
                    int minutes = request.ExpirationMinutes.Value;
                    if (minutes > apiKeyConfiguration.MaxExpirationMinutes)
                    {
                        minutes = apiKeyConfiguration.MaxExpirationMinutes;
                    }

                    //
                    expirationTimeSpan = TimeSpan.FromMinutes(minutes);
                }

                //
                var result = await provider.CreateApiKey(
                    userInfo: userInfo,
                    scopes: request.Scopes,
                    applicationId: applicationId,
                    rateLimit: request.RateLimit,
                    allowedIPs: request.AllowedIPs,
                    expiration: expirationTimeSpan,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Remove Specified Api Key ...
        /// </summary>
        /// <param name="apiKeyId"></param>
        /// <param name="applicationId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [RequireXPowered]
        [Authorize(LocalApi.PolicyName)]
        [Authorize(Policy = XPolicies.EnabledUser)]
        [HttpDelete("{applicationId}/ApiKeys/{apiKeyId}")]
        public async Task<ActionResult<XApiKeyDto>> RemoveApiKey(
            [FromRoute] Guid apiKeyId,
            [FromRoute] int applicationId,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (
                    apiKeyId.IsDefaultGuid() ||
                    !applicationId.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var userInfo = await GetUserInfo();

                //
                // Retrieve Application for Validating ...
                var application = await provider.GetApplicationAsync(
                    id: applicationId,
                    userInfo: userInfo,
                    includeBuilder: null,
                    ignoreSoftDeleteds: true
                );
                if (application.IsNullOrDefault())
                {
                    XException.NotFound.Throw();
                }

                //
                var result = await provider.RemoveApiKeyAsync(
                    id: apiKeyId,
                    softDelete: false,
                    userInfo: userInfo,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Rotate Specified Api Key ...
        /// </summary>
        /// <param name="apiKeyId"></param>
        /// <param name="applicationId"></param>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [RequireXPowered]
        [Authorize(LocalApi.PolicyName)]
        [Authorize(Policy = XPolicies.EnabledUser)]
        [HttpPost("{applicationId}/ApiKeys/{apiKeyId}")]
        public async Task<ActionResult<XApiKeyDto>> RotateApiKey(
            [FromRoute] Guid apiKeyId,
            [FromRoute] int applicationId,
            [FromBody] XRotateApiKeyRequest request,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (
                    apiKeyId.IsDefaultGuid() ||
                    !applicationId.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                // Normalize ...
                if (
                    request.IsNullOrDefault() ||
                    request.NewExpiration.IsNull() ||
                    !request.NewExpiration.HasValue
                )
                {
                    //
                    var timeSpan = TimeSpan.FromMinutes(apiKeyConfiguration.DefaultExpirationMinutes);
                    request = new XRotateApiKeyRequest
                    {
                        NewExpiration = timeSpan
                    };
                }

                //
                var userInfo = await GetUserInfo();

                //
                // Retrieve Application for Validating ...
                var application = await provider.GetApplicationAsync(
                    id: applicationId,
                    userInfo: userInfo,
                    includeBuilder: null,
                    ignoreSoftDeleteds: true
                );
                if (application.IsNullOrDefault())
                {
                    XException.NotFound.Throw();
                }

                //
                var result = await provider.RotateApiKey(
                    apiKeyId: apiKeyId,
                    userInfo: userInfo,
                    newExpiration: request.NewExpiration,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Revoke Specified Api Key ...
        /// </summary>
        /// <param name="apiKeyId"></param>
        /// <param name="applicationId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [RequireXPowered]
        [Authorize(LocalApi.PolicyName)]
        [Authorize(Policy = XPolicies.EnabledUser)]
        [HttpPost("{applicationId}/ApiKeys/{apiKeyId}/Revoke")]
        public async Task<ActionResult<bool>> RevokeApiKey(
            [FromRoute] Guid apiKeyId,
            [FromRoute] int applicationId,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (
                    apiKeyId.IsDefaultGuid() ||
                    !applicationId.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var userInfo = await GetUserInfo();

                //
                // Retrieve Application for Validating ...
                var application = await provider.GetApplicationAsync(
                    id: applicationId,
                    userInfo: userInfo,
                    includeBuilder: null,
                    ignoreSoftDeleteds: true
                );
                if (application.IsNullOrDefault())
                {
                    XException.NotFound.Throw();
                }

                //
                var result = await provider.RevokeApiKey(
                    apiKeyId: apiKeyId,
                    userInfo: userInfo,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result);
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Retrieve Specified Application's Api Keys ...
        /// </summary>
        /// <param name="applicationId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [RequireXPowered]
        [Authorize(LocalApi.PolicyName)]
        [HttpGet("{applicationId}/ApiKeys")]
        [Authorize(Policy = XPolicies.EnabledUser)]
        public async Task<ActionResult<IEnumerable<XApiKeyDto>>> GetApiKeys(
            [FromRoute] int applicationId,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!applicationId.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var userInfo = await GetUserInfo();

                //
                // Retrieve Application for Validating ...
                var application = await provider.GetApplicationAsync(
                    id: applicationId,
                    userInfo: userInfo,
                    includeBuilder: null,
                    ignoreSoftDeleteds: true
                );
                if (application.IsNullOrDefault())
                {
                    XException.NotFound.Throw();
                }

                //
                var result = await provider.GetApplicationApiKeys(
                    userInfo: userInfo,
                    applicationId: applicationId,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Retrieve Specified Api Keys Usages ...
        /// </summary>
        /// <param name="apiKeyId"></param>
        /// <param name="applicationId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [RequireXPowered]
        [Authorize(LocalApi.PolicyName)]
        [Authorize(Policy = XPolicies.EnabledUser)]
        [HttpGet("{applicationId}/ApiKeys/{apiKeyId}/Usages")]
        public async Task<ActionResult<IEnumerable<XApiKeyUsageDto>>> GetApiKeyUsages(
            [FromRoute] Guid apiKeyId,
            [FromRoute] int applicationId,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (
                    apiKeyId.IsDefaultGuid() ||
                    !applicationId.IsValidIntId())
                {
                    XException.InvalidArgs.Throw();
                }

                //
                var userInfo = await GetUserInfo();

                //
                // Retrieve Application for Validating ...
                var application = await provider.GetApplicationAsync(
                    id: applicationId,
                    userInfo: userInfo,
                    includeBuilder: null,
                    ignoreSoftDeleteds: true
                );
                if (application.IsNullOrDefault())
                {
                    XException.NotFound.Throw();
                }

                //
                // Retrieve ApiKey for Validating ...
                var apiKey = await provider.GetApiKeyAsync(
                    id: apiKeyId,
                    userInfo: userInfo,
                    includeBuilder: null,
                    ignoreSoftDeleteds: true
                );
                if (application.IsNullOrDefault())
                {
                    XException.NotFound.Throw();
                }

                //
                var result = await provider.FindManyApiKeyUsageAsync(
                    userInfo: userInfo,
                    includeBuilder: null,
                    ignoreSoftDeleteds: true,
                    cancellationToken: cancellationToken,
                    predicate: x => x.ApiKeyId == apiKeyId,
                    orderBuilder: x => x.OrderBy(y => y.RequestedOn)
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }

        /// <summary>
        /// Validate Specifed Api Key ...
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [RequireXPowered]
        [HttpPost("ApiKeys/Validate")]
        [Authorize(LocalApi.PolicyName)]
        public async Task<ActionResult<XApiKeyValidationResult>> ValidateApiKey(
            [FromBody] XApiKeyValidationRequest request,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotNull(request)
                    .AddNotEmpty(request.ApiKey)
                    .AddNotEmpty(request.ClientIP)
                    .ValidateGroupAsync();

                //
                var userInfo = await GetUserInfo();

                //
                var result = await provider.ValidateApiKey(
                    userInfo: userInfo,
                    apiKey: request.ApiKey,
                    clientIP: request.ClientIP,
                    requiredScope: request.RequiredScope,
                    cancellationToken: cancellationToken
                );

                //
                return Ok(result.ToDynamicObject());
            }
            catch (Exception ex)
            {
                //
                var result = GetExceptionActionResult(ex);
                return result;
            }
        }
    }
}