using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using xCommons.Extensions;
using xExceptions.Constants;
using xModels.Dtos;
using xStringService.Extensions;
using xStringService.Interfaces;
using xStringService.Interfaces.Dtos;
using xStringService.Models.Dtos;

namespace xStringService.Providers
{
    public class XBaseResourceProvider : IXResourceProvider
    {
        protected string resource;
        private readonly IXStringServiceProvider provider;

        public XBaseResourceProvider(
            string resource,
            IXStringServiceProvider provider
        )
        {
            this.resource = resource;
            this.provider = provider;
        }

        //
        #region Actions ...
        /// <summary>
        /// Retrieve a List of Exists Languages ...
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<string>> GetLanguages(
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = (await ExtractItems(cancellationToken))
                .Select(x => x.Language)
                .Distinct()
                .ToList();

            //
            return result;
        }

        /// <summary>
        /// Retrieve all Exists Items ...
        /// </summary>
        /// <param name="resource">Specified Resource Title</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<XStringDto>> GetResourceLocales(
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await ExtractItems(cancellationToken);

            //
            return result;
        }

        /// <summary>
        /// Extract Translation of in Specified Language ...
        /// </summary>
        /// <param name="language">Specified Language ...</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<string> GetResourceTranslation(
            string language,
            CancellationToken cancellationToken = default
        )
        {
            //
            var item = (await ExtractItems(cancellationToken))
                .FirstOrDefault(x => x.Language.Equals(language, StringComparison.InvariantCultureIgnoreCase));

            //
            var result = item?.TranslatedValue ?? string.Empty;

            //
            return result;
        }

        /// <summary>
        /// Check Has Specified Translation or not ...
        /// </summary>
        /// <param name="language">Specified Language ...</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<bool> HasLocale(
            string language,
            CancellationToken cancellationToken = default
        )
        {
            //
            var item = (await ExtractItems(cancellationToken))
                .FirstOrDefault(x => x.Language.Equals(language, StringComparison.InvariantCultureIgnoreCase));

            //
            var result = !item.IsNullOrDefault();

            //
            return result;
        }

        /// <summary>
        /// Retrieve as Locale Model ...
        /// </summary>
        /// <param name="language">Specified Language ...</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XLocaleResourceDto> GetLocale(
            string language,
            CancellationToken cancellationToken = default
        )
        {
            //
            var item = (await ExtractItems(cancellationToken))
                .FirstOrDefault(x => x.Language.Equals(language, StringComparison.InvariantCultureIgnoreCase));

            //
            var result =
                !item.IsNullOrDefault()
                ? item.ToXLocaleResourceDto()
                : null;

            //
            return result;
        }

        /// <summary>
        /// Retrieve all Exists Locale Models ...
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<XLocaleResourceDto>> GetLocales(
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = (await ExtractItems(cancellationToken))
                .Select(x => x.ToXLocaleResourceDto())
                .ToList();

            //
            return result;
        }

        /// <summary>
        /// Retrieve as XResourceDto ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XResourceDto> GetResource(
            CancellationToken cancellationToken = default
        )
        {
            //
            var locales = await GetLocales();

            //
            var result = new XResourceDto
            {
                Locales = locales,
                Resource = resource,
            };

            //
            return result;
        }

        /// <summary>
        /// Add or Update a Resource Model ...
        /// </summary>
        /// <param name="resource">a XResourceDto Model ...</param>
        /// <param name="connectionId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XResourceDto> AddOrUpdateResource(
            XResourceDto resource,
            string connectionId = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var isValid =
                !resource.IsNullOrDefault() &&
                resource.Resource == this.resource;
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Retrieve Exists Resource ...
            var result = await GetResource(cancellationToken);
            isValid = !result.IsNullOrDefault() && result.Locales.HasChild();
            if (isValid)
            {
                await RemoveResource(
                    resource: result,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );
            }

            //
            foreach (var locale in resource.Locales)
            {
                //
                var item = new XStringDto
                {
                    Language = locale.Language,
                    ResourceTitle = this.resource,
                    TranslatedValue = locale.Value,
                };

                //
                await provider.AddAsync(
                    item: item,
                    saveChanges: true,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );
            }

            //
            result = await GetResource(cancellationToken);
            return result;
        }

        /// <summary>
        /// Add Or Update Locale ...
        /// </summary>
        /// <param name="locale"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XResourceDto> AddOrUpdateLocale(
            XLocaleResourceDto locale,
            string connectionId = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var item = (await ExtractItems(cancellationToken))
                .FirstOrDefault(x =>
                    x.ResourceTitle == resource &&
                    x.Language == locale.Language);
            var isExists = !item.IsNullOrDefault();
            if (isExists)
            {
                item.TranslatedValue = locale.Value;
                item = await provider.UpdateAsync(
                    item: item,
                    id: item.Id,
                    saveChanges: true,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );
            }
            else
            {
                item = new XStringDto
                {
                    ResourceTitle = resource,
                    Language = locale.Language,
                    TranslatedValue = locale.Value
                };
                item = await provider.AddAsync(
                    item: item,
                    saveChanges: true,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );
            }

            //
            var result = await GetResource(cancellationToken);

            //
            return result;
        }

        /// <summary>
        /// Remove Locale ...
        /// </summary>
        /// <param name="locale"></param>
        /// <param name="connectionId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XResourceDto> RemoveLocale(
            XLocaleResourceDto locale,
            string connectionId = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            var item = (await ExtractItems(cancellationToken))
                .FirstOrDefault(x =>
                    x.ResourceTitle == resource &&
                    x.Language == locale.Language);
            var isExists = !item.IsNullOrDefault();
            if (isExists)
            {
                await provider.RemoveAsync(
                    id: item.Id,
                    softDelete: false,
                    saveChanges: true,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );
            }

            //
            var result = await GetResource(cancellationToken);

            //
            return result;
        }

        /// <summary>
        /// Remove Specified Resource Model ...
        /// </summary>
        /// <param name="resource">a XResourceDto Model ...</param>
        /// <param name="connectionId"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task RemoveResource(
            XResourceDto resource,
            string connectionId = null,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Validate Resource ...
            var isValid = 
                !resource.IsNullOrDefault() &&
                !resource.Resource.IsNullOrEmpty() &&
                resource.Resource == this.resource;
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }
            
            //
            var items = await ExtractItems(cancellationToken);

            //
            foreach (var item in items)
            {
                //
                await provider.RemoveAsync(
                    id: item.Id,
                    softDelete: false,
                    saveChanges: true,
                    connectionId: connectionId,
                    cancellationToken: cancellationToken
                );
            }
        }
        #endregion

        //
        #region Private ...
        private async Task<IEnumerable<XStringDto>> ExtractItems(
            CancellationToken cancellationToken = default
        )
        {
            //
            var result = await provider.FindManyAsync(
                includeBuilder: null,
                ignoreSoftDeleteds: true,
                orderBuilder: x => x
                    .OrderBy(y => y.Language)
                    .ThenBy(y => y.ResourceTitle),
                cancellationToken: cancellationToken,
                predicate: x =>
                    x.ResourceTitle.Equals(resource, StringComparison.InvariantCultureIgnoreCase)
            );

            //
            return result;
        }
        #endregion
    }
}