using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using xCommons.Configurations;
using xCommons.Extensions;
using xCommons.Providers;
using xExceptions.Constants;
using xIdentityService.Controllers;
using xIdentityService.Interfaces;
using xModels.Base;
using xTermsAndConditionsService.Interfaces;

namespace xTermsAndConditionsService.Controllers
{
    /// <summary>
    /// a Base Controller Implementation for Providing Base Actions of 
    /// Terms and Conditions Provided Actions ...
    /// </summary>
    [AllowAnonymous]
    public abstract class XTermsAndComditionsControllerBase : XBaseIdentityApiV1Controller, IXTermsAndComditionsController
    {
        private readonly IXTermsAndComditionsProvider provider;

        protected XTermsAndComditionsControllerBase(
            ILogger<XTermsAndComditionsControllerBase> logger, 
            XAppConfiguration appConfiguration, 
            IXIdentityProvider identityProvider, 
            IXTermsAndComditionsProvider provider,
            XValidationProvider validationProvider
        ) : base(
            logger, 
            appConfiguration, 
            identityProvider, 
            validationProvider
        )
        {
            this.provider = provider;
        }

        //
        #region Actions ...
        /// <summary>
        /// Retrieved all Exists Languages Terms and Conditions ...
        /// </summary>
        /// <returns></returns>
        [HttpGet("Terms/Languages")]
        public virtual async Task<ActionResult<IEnumerable<string>>> TermsLanguages(
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                var result = await provider.TermsLanguages(
                    cancellationToken: cancellationToken
                );

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

        /// <summary>
        /// Check Has Terms and Conditions based on Specified Language ...
        /// </summary>
        /// <param name="language">if null, used Default Language ...</param>
        /// <returns></returns>
        [HttpGet("Terms/{language}/Has")]
        public virtual async Task<ActionResult<bool>> HasTerms(
            [FromRoute] string language = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(language)
                    .ValidateGroupAsync();

                //
                var result = await provider.HasTerms(
                    language: language,
                    cancellationToken: cancellationToken
                );

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

        /// <summary>
        /// Retrieve Terms and Conditions for Specified Language ...
        /// </summary>
        /// <param name="language">if null, used Default Language ...</param>
        /// <returns></returns>
        [HttpGet("Terms/{language}")]
        public virtual async Task<ActionResult<string>> GetTerms(
            [FromRoute] string language = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(language)
                    .ValidateGroupAsync();

                //
                var result = await provider.GetTerms(
                    language: language,
                    cancellationToken: cancellationToken
                );

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

        /// <summary>
        /// Add Terms and Conditions for Specified Language ...
        /// </summary>
        /// <param name="language"></param>
        /// <param name="terms"></param>
        /// <returns></returns>
        [HttpPost("Terms/{language}")]
        public virtual async Task<ActionResult<string>> AddTerms(
            [FromRoute] string language,
            [FromBody] XBaseValueContainer<string> terms,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(language)
                    .AddNotNull(terms)
                    .AddNotEmpty(terms.Value)
                    .ValidateGroupAsync();

                //
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.AddTerms(
                    language: language,
                    terms: terms.Value,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

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

        /// <summary>
        /// Remove Terms and Conditions of Specified Language ...
        /// </summary>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpDelete("Terms/{language}")]
        public virtual async Task<ActionResult<bool>> RemoveTerms(
            [FromRoute] string language,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(language)
                    .ValidateGroupAsync();

                //
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.RemoveTerms(
                    language: language,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

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

        /// <summary>
        /// Update Terms and Conditions of Specified Language ...
        /// </summary>
        /// <param name="language"></param>
        /// <param name="terms"></param>
        /// <returns></returns>
        [HttpPut("Terms/{language}")]
        public virtual async Task<ActionResult<bool>> UpdateTerms(
            [FromRoute] string language,
            [FromBody] XBaseValueContainer<string> terms,
            CancellationToken cancellationToken = default
        )
        {
            //
            try
            {
                //
                // Validate ...
                if (!ModelState.IsValid)
                {
                    XException.InvalidArgs.Throw();
                }
                await ValidationProvider
                    .GroupValidationBuilder()
                    .AddNotEmpty(language)
                    .AddNotNull(terms)
                    .AddNotEmpty(terms.Value)
                    .ValidateGroupAsync();

                //
                var userInfo = await GetUserInfo();
                var connectionId = GetConnectionId();

                //
                var result = await provider.UpdateTerms(
                    language: language,
                    terms: terms.Value,
                    userInfo: userInfo,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );

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