using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using xCommons.Attributes;
using xCommons.Configurations;
using xCommons.Providers;
using xIdentityHelper;
using xIdentityService.Interfaces;
using xModels.Dtos;
using xStringService.Controllers;
using xStringService.Interfaces;
using xStringService.Models.Dtos;

namespace xApi.Controllers.V1.Services
{
    [ApiController]
    [ApiVersion("1.0")]
    [RequireXPowered(true)]
    [Route("api/v{version:apiVersion}/services/[controller]")]
    public class StringsController : XStringServiceControllerBase, IXStringServiceControllerActions
    {
        //
        #region Constructor ...
        public StringsController(
            ILogger<StringsController> logger,
            IXStringProvider stringProvider,
            XAppConfiguration appConfiguration,
            IXIdentityProvider identityProvider,
            XValidationProvider validationProvider
        ) : base(
            logger,
            stringProvider,
            appConfiguration,
            identityProvider,
            validationProvider
        )
        { }
        #endregion

        //
        #region Implementing Actions ...
        //
        #region Retrievers ...
        /// <summary>
        /// Retrieve all Exists Languages ...
        /// </summary>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("Languages")]        
        public override async Task<ActionResult<IEnumerable<string>>> GetLanguages()
        {
            return await base.GetLanguages();
        }

        /// <summary>
        /// Check Specified Resource Exists or not ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("IsResourceExists")]
        public override async Task<ActionResult<bool>> IsResourceExists(
            [FromQuery] string resource,
            [FromQuery] string language = null
        )
        {
            //
            return await base
                .IsResourceExists(
                    resource: resource,
                    language: language
            );
        }

        /// <summary>
        /// Retrieve Specified Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpGet("")]
        [AllowAnonymous]
        public override async Task<ActionResult<XStringDto>> Get(
            [FromQuery] string resource,
            [FromQuery] string language = null
        )
        {
            //
            return await base
                .Get(
                    resource: resource,
                    language: language
            );
        }

        /// <summary>
        /// Retrieve Specified Translation of Specified Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("ResourceValue")]
        public override async Task<ActionResult<string>> GetResourceValue(
            [FromQuery] string resource,
            [FromQuery] string language = null
        )
        {
            //
            return await base
                .GetResourceValue(
                    resource: resource,
                    language: language
            );
        }

        /// <summary>
        /// Retrieve an Specified Resource Items ...
        /// </summary>
        /// <param name="resource"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("Resources")]
        public override async Task<ActionResult<IEnumerable<XStringDto>>> GetResources(
            [FromQuery] string resource
        )
        {
            return await base.GetResources(resource);
        }

        /// <summary>
        /// Retrieve Specified Resource Items as XResourceDto Presentation ...
        /// </summary>
        /// <param name="resource"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("AsResource")]
        public override async Task<ActionResult<XResourceDto>> GetResource(
            [FromQuery] string resource
        )
        {
            return await base.GetResource(resource);
        }
        #endregion

        //
        #region Query ...
        /// <summary>
        /// Query Resource IDs ...
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("QueryResourceIds")]
        public override ActionResult<XQueryResult<string>> QueryResourceIds(
            [FromQuery] XQuery query
        )
        {
            return base.QueryResourceIds(query);
        }

        /// <summary>
        /// Query Specified Language Resources ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpGet("QueryLanguageResources")]
        public override async Task<ActionResult<XQueryResult<XStringDto>>> QueryLanguageResources(
            [FromQuery] XQuery query,
            [FromQuery] string language = null //
        )
        {
            //
            return await base
                .QueryLanguageResources(
                    query: query,
                    language: language
            );
        }

        /// <summary>
        /// Query Locale Resources ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpGet("QueryLocaleResources")]
        public override async Task<ActionResult<XQueryResult<XLocaleResourceDto>>> QueryLocaleResources(
            [FromQuery] XQuery query,
            [FromQuery] string language = null //
        )
        {
            //
            return await base
                .QueryLocaleResources(
                    query: query,
                    language: language
            );
        }
        #endregion

        //
        #region Add/Update Actions ...
        /// <summary>
        /// Add Specified Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="value"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpPost("Add")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<bool>> Add(
            [FromQuery] string resource,
            [FromQuery] string value,
            [FromQuery] string language = null
        )
        {
            //
            return await base
                .Add(
                    value: value,
                    resource: resource,
                    language: language
            );
        }

        /// <summary>
        /// Update Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="value"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpPut("Update")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<bool>> Update(
            [FromQuery] string resource,
            [FromQuery] string value,
            [FromQuery] string language = null
        )
        {
            //
            return await base
                .Update(
                    value: value,
                    resource: resource,
                    language: language
            );
        }

        /// <summary>
        /// Add Or Update Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="value"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpPost("AddOrUpdate")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<bool>> AddOrUpdate(
            [FromQuery] string resource,
            [FromQuery] string value,
            [FromQuery] string language = null
        )
        {
            //
            return await base
                .AddOrUpdate(
                    value: value,
                    resource: resource,
                    language: language
            );
        }

        /// <summary>
        /// Add Specified Resource ...
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        [HttpPost("AddModel")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XStringDto>> AddEntity(
            [FromBody] XStringDto item
        )
        {
            return await base.AddEntity(item);
        }

        /// <summary>
        /// Update Specified Entity ...
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        [HttpPut("UpdateModel")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XStringDto>> UpdateEntity(
            [FromBody] XStringDto item
        )
        {
            return await base.UpdateEntity(item);
        }

        /// <summary>
        /// Add Or Update Specified Entitiy ... 
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        [HttpPost("AddOrUpdateModel")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XStringDto>> AddOrUpdateEntity(
            [FromBody] XStringDto item
        )
        {
            return await base.AddOrUpdateEntity(item);
        }

        /// <summary>
        /// Add Specified Locale Resource ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="resource"></param>
        /// <returns></returns>
        [HttpPost("AddLocale")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XStringDto>> AddByLocaleResource(
            [FromBody] XLocaleResourceDto item,
            [FromQuery] string resource
        )
        {
            //
            return await base
                .AddByLocaleResource(
                    item: item,
                    resource: resource
            );
        }

        /// <summary>
        /// Update Specified Locale Resource ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="resource"></param>
        /// <returns></returns>
        [HttpPut("UpdateLocale")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XStringDto>> UpdateByLocaleResource(
            [FromBody] XLocaleResourceDto item,
            [FromQuery] string resource
        )
        {
            //
            return await base
                .UpdateByLocaleResource(
                    item: item,
                    resource: resource
            );
        }

        /// <summary>
        /// Add Or Update Resource By Locale ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="resource"></param>
        /// <returns></returns>
        [HttpPost("AddOrUpdateLocale")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<XStringDto>> AddOrUpdateByLocaleResource(
            [FromBody] XLocaleResourceDto item,
            [FromQuery] string resource
        )
        {
            //
            return await base
                .AddOrUpdateByLocaleResource(
                    item: item,
                    resource: resource
            );
        }

        /// <summary>
        /// Add Or Update all XResourceDto(s) Locales ...
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        [HttpPost("AddResource")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<IEnumerable<XStringDto>>> AddByResource(
            [FromBody] XResourceDto item
        )
        {
            return await base.AddByResource(item);
        }
        #endregion

        //
        #region Remove Actions ...
        /// <summary>
        /// Remove all Specified Language's Resources ...
        /// </summary>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpDelete("RemoveLanguage")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult> RemoveLanguageResources(
            [FromQuery] string language
        )
        {
            return await base.RemoveLanguageResources(language);
        }

        /// <summary>
        /// Remove all Specified Resource Ids instances ... 
        /// </summary>
        /// <param name="resource"></param>
        /// <returns></returns>
        [HttpDelete("RemoveLocales")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<IEnumerable<XStringDto>>> RemoveResource(
            [FromQuery] string resource
        )
        {
            return await base.RemoveResource(resource);
        }

        /// <summary>
        /// Remove Specified Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        [HttpDelete("Remove")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult<bool>> Remove(
            [FromQuery] string resource,
            [FromQuery] string language = null
        )
        {
            //
            return await base
                .Remove(
                    resource: resource,
                    language: language
            );
        }

        /// <summary>
        /// Remove all Resource of Specified XResourceDto ...
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        [HttpPost("RemoveResource")]
        [Authorize(Policy = XPolicies.EnabledAdminOrAgent)]
        public override async Task<ActionResult> RemoveByResource(
            [FromBody] XResourceDto item
        )
        {
            //
            return await base.RemoveByResource(item);
        }
        #endregion                
        #endregion
    }
}