using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Microsoft.AspNetCore.SignalR;
using xCommons.Configurations;
using xCommons.Extensions;
using xDataService.Configuration;
using xDataService.Extensions;
using xExceptions.Constants;
using xModels.Dtos;
using xPushService.Constants;
using xStringService.Extensions;
using xStringService.Hubs;
using xStringService.Interfaces;
using xStringService.Interfaces.Entities;
using xStringService.Models.Dtos;
using xStringService.Models.Entities;

namespace xStringService.Providers
{
    public class XStringProvider : IXStringProvider
    {
        //
        #region Props ...
        public IHubContext<XStringEntityHub> Hub { get; }
        public IXStringRepository Repository { get; }
        public XAppConfiguration AppConfiguration { get; }
        public XDataServiceConfiguration DataConfiguration { get; }
        #endregion

        //
        #region Constructor ...
        public XStringProvider(
            IXStringRepository repository,
            XAppConfiguration appConfiguration,
            XDataServiceConfiguration dataConfiguration,
            IHubContext<XStringEntityHub> hub = null
        )
        {
            //
            Repository = repository;
            AppConfiguration = appConfiguration;
            DataConfiguration = dataConfiguration;
            Hub = hub;
        }
        #endregion

        //
        #region Retrievers ...
        /// <summary>
        /// Retrieve all Exists Languages ...
        /// </summary>
        /// <returns></returns>
        public async Task<IEnumerable<string>> GetLanguages()
        {
            //
            var result = (await Repository.GetAllAsync())
                .AsQueryable()
                .Select(e => e.Language)
                .Distinct()
                .ToList();

            //
            // Check Configuration Default Language Exists ...
            var hasDefaultLanguage = !AppConfiguration.DefaultLanguage.IsNullOrEmpty();
            if (hasDefaultLanguage)
            {
                //
                // Find Default Language on Result ...
                hasDefaultLanguage = result.Any(e => e.ToNormalString() == AppConfiguration.DefaultLanguage.ToNormalString());
                if (!hasDefaultLanguage)
                {
                    result.Add(AppConfiguration.DefaultLanguage);
                }
            }

            //
            result = result
                .Distinct()
                .ToList();

            //
            return result;
        }

        /// <summary>
        /// Check Specified Resource Exists or not ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        public async Task<bool> IsResourceExists(
            string resource,
            string language = null
        )
        {
            //
            var result = false;

            //
            // Validate ...
            result = !resource.IsNullOrEmpty();
            if (!result)
            {
                return result;
            }

            //
            XString entity = null;
            if (language.IsNullOrEmpty())
            {
                //
                entity = await Repository
                    .FindOneAsync(e => e.ResourceTitle == resource);
            }
            else
            {
                //
                entity = await Repository
                    .FindOneAsync(e => e.ResourceTitle == resource &&
                        e.Language.ToNormalString() == language.ToNormalString()
                );
            }
            result = !entity.IsNullOrDefault();

            //
            return result;
        }

        /// <summary>
        /// Retrieve Specified Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        public async Task<XStringDto> Get(
            string resource,
            string language = null
        )
        {
            //
            // Normalize ...
            if (language.IsNullOrEmpty())
            {
                language = AppConfiguration.DefaultLanguage;
            }

            //
            // Validate ...
            if (resource.IsNullOrEmpty() || language.IsNullOrEmpty())
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Resource Exists ...
            var isExists = await IsResourceExists(
                resource: resource,
                language: language
            );
            if (!isExists)
            {
                XException.NotFound.Throw();
            }

            //
            var entity = await Repository
                .FindOneAsync(e =>
                    e.ResourceTitle == resource &&
                    e.Language.ToNormalString() == language.ToNormalString()
            );
            if (entity.IsNullOrDefault())
            {
                XException.ActionFailed.Throw();
            }

            //
            return entity.ToXStringDto();
        }

        /// <summary>
        /// Retrieve Specified Translation of Specified Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        public async Task<string> GetResourceValue(
            string resource,
            string language = null
        )
        {
            //
            var result = "";

            //
            // Normalize ...
            if (language.IsNullOrEmpty())
            {
                language = AppConfiguration.DefaultLanguage;
            }

            //
            // Validate ...
            var isValid = !resource.IsNullOrEmpty() &&
                !language.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Langauage Exists ...
            var languages = await GetLanguages();
            isValid = languages.Any(l => l.ToNormalString() == language.ToNormalString());
            if (!isValid)
            {
                XException.NotFound.Throw();
            }

            //
            // Check Resource Exists ...
            isValid = await IsResourceExists(resource);
            if (!isValid)
            {
                XException.NotFound.Throw();
            }

            //
            var entity = await Repository.FindOneAsync(e =>
                e.ResourceTitle == resource &&
                e.Language.ToNormalString() == language.ToNormalString()
            );
            isValid = !entity.IsNullOrDefault();
            if (!isValid)
            {
                XException.ActionFailed.Throw();
            }

            //
            result = entity.TranslatedValue;

            //
            return result;
        }

        /// <summary>
        /// Retrieve an Specified Resource Items ...
        /// </summary>
        /// <param name="resource"></param>
        /// <returns></returns>
        public async Task<IEnumerable<XStringDto>> GetResources(string resource)
        {
            //
            // Validate ...
            var isValid = await IsResourceExists(resource);
            if (!isValid)
            {
                XException.NotFound.Throw();
            }

            //
            var result = (await Repository
                .FindManyAsync(e => e.ResourceTitle == resource))
                .ToXStringDtos();

            //
            return result;
        }

        /// <summary>
        /// Retrieve Specified Resource Items as XResourceDto Presentation ...
        /// </summary>
        /// <param name="resource"></param>
        /// <returns></returns>
        public async Task<XResourceDto> GetResource(string resource)
        {
            //
            // Validate ...
            bool isExists = await IsResourceExists(resource);
            if (!isExists)
            {
                XException.NotFound.Throw();
            }

            //
            // Retrieve String Dto (s) ...
            var resources = await GetResources(resource);
            if (!resource.HasChild())
            {
                XException.NotFound.Throw();
            }

            //
            var result = new XResourceDto
            {
                Resource = resource,
                Locales = resources.ToXLocaleResourceDtos()
            };

            return result;
        }
        #endregion

        //
        #region Query ...
        /// <summary>
        /// Query Resource IDs ...
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public XQueryResult<string> QueryResourceIds(XQuery query)
        {
            //
            // Normalize ...
            query = query.NormalizeQuery(DataConfiguration);

            //
            // Read Resource IDs ...
            var items = Repository
                .AsQueryable()
                .Select(e => e.ResourceTitle)
                .Distinct();

            //
            var totalItemsCount = items.Count();

            //
            // Apply Filter ...
            if (totalItemsCount > 0 &&
                !query.Filter.IsNullOrEmpty())
            {
                //
                items = items
                    .Where(e => e.ToNormalString().Contains(query.Filter.ToNormalString()));
            }

            //
            var filteredItemsCount = items.Count();
            var totalPagesCount = query.CountPages(totalItemsCount);
            var filteredPagesCount = query.CountPages(filteredItemsCount);

            //
            // Apply Paging / Sorting ...
            if (totalItemsCount > 0 &&
                filteredItemsCount > 0)
            {
                //
                items = items.ApplyPaging(
                    query.Page,
                    query.PageSize
                );
            }

            //
            // Prepare result ...
            var result = new XQueryResult<string>
            {
                Items = items,
                Page = query.Page,
                PageSize = query.PageSize,
                TotalPages = totalPagesCount,
                TotalItems = totalItemsCount,
                TotalFilteredPages = filteredPagesCount,
                TotalFilteredItems = filteredItemsCount
            };

            //
            return result;
        }

        /// <summary>
        /// Query Specified Language Resources ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        public async Task<XQueryResult<XStringDto>> QueryLanguageResources(
            XQuery query,
            string language = null //
        )
        {
            //
            // Normalize ...
            query = query.NormalizeQuery(DataConfiguration);

            //
            // Validate ...
            if (query.IsNull())
            {
                XException.InvalidArgs.Throw();
            }

            //
            XQueryResult<XString> entityResult = null;
            if (language.IsNullOrEmpty())
            {
                //
                entityResult = await Repository.QueryAsync(query);
            }
            else
            {
                //
                entityResult = await Repository.ConditionalQueryAsync(
                    e => e.Language.ToNormalString() == language.ToNormalString(),
                    query
                );
            }

            //
            var result = new XQueryResult<XStringDto>
            {
                Page = entityResult.Page,
                PageSize = entityResult.PageSize,
                TotalPages = entityResult.TotalPages,
                TotalItems = entityResult.TotalItems,
                TotalFilteredPages = entityResult.TotalFilteredPages,
                TotalFilteredItems = entityResult.TotalFilteredItems,
                Items = entityResult.Items.Select(i => i.ToXStringDto()),
            };

            //
            return result;
        }

        /// <summary>
        /// Query Locale Resources ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        public async Task<XQueryResult<XLocaleResourceDto>> QueryLocaleResources(
            XQuery query,
            string language = null //
        )
        {
            //
            // Normalize ...
            query.NormalizeQuery(DataConfiguration);

            //
            // Validate ...
            if (query.IsNull())
            {
                XException.InvalidArgs.Throw();
            }

            //
            IEnumerable<XLocaleResourceDto> items = null;
            if (!language.IsNullOrEmpty())
            {
                items = (await Repository
                    .FindManyAsync(e => e.Language.ToNormalString() == language.ToNormalString()))
                    .ToXLocaleResourceDtos();
            }
            else
            {
                items = (await Repository.GetAllAsync())
                    .ToXLocaleResourceDtos();
            }

            //
            var totalItemsCount = items.Count();

            //
            // Apply Filter ...
            if (totalItemsCount > 0 &&
                !query.Filter.IsNullOrEmpty())
            {
                //
                items = items.ApplyFilter(query.Filter);
            }

            //
            var filteredItemsCount = items.Count();
            var totalPagesCount = query.CountPages(totalItemsCount);
            var filteredPagesCount = query.CountPages(filteredItemsCount);

            //
            // Apply Paging/Sorting ...
            if (totalItemsCount > 0 &&
                filteredItemsCount > 0)
            {
                //
                // Apply Sorting ...
                items = items.ApplySorting(
                    query.SortBy,
                    query.IsAscending
                );

                //
                // Apply Paging ...
                items = items.ApplyPaging(
                    query.Page,
                    query.PageSize
                );
            }

            //
            // Prepare Result ...
            var result = new XQueryResult<XLocaleResourceDto>
            {
                Items = items,
                Page = query.Page,
                PageSize = query.PageSize,
                TotalPages = totalPagesCount,
                TotalItems = totalItemsCount,
                TotalFilteredPages = filteredPagesCount,
                TotalFilteredItems = filteredItemsCount
            };

            //
            return result;
        }

        /// <summary>
        /// Conditional Query Resources ...
        /// </summary>
        /// <param name="query"></param>
        /// <param name="condition"></param>
        /// <param name="language"></param>
        /// <returns></returns>
        public async Task<XQueryResult<XStringDto>> ConditionalQueryResources(
            XQuery query,
            Expression<Func<XString, bool>> condition,
            string language = null
        )
        {
            //
            // Normalize ...
            query = query.NormalizeQuery(DataConfiguration);

            //
            if (!language.IsNullOrEmpty())
            {
                //
                // Renew and Update Condition by Language Checking ...
                var compiledCondition = condition.Compile();
                condition =
                    e => compiledCondition(e) &&
                    e.Language.ToNormalString() == language.ToNormalString();
            }

            //
            var entityResult = await Repository.ConditionalQueryAsync(condition, query);
            var result = new XQueryResult<XStringDto>
            {
                Page = entityResult.Page,
                PageSize = entityResult.PageSize,
                TotalPages = entityResult.TotalPages,
                TotalItems = entityResult.TotalItems,
                TotalFilteredPages = entityResult.TotalFilteredPages,
                TotalFilteredItems = entityResult.TotalFilteredItems,
                Items = entityResult.Items.Select(i => i.ToXStringDto()),
            };

            //
            return result;
        }
        #endregion

        //
        #region Add/Update Actions ...
        /// <summary>
        /// Add Specified Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="value"></param>
        /// <param name="language"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<bool> Add(
            string resource,
            string value,
            string language = null,
            string connectionId = null
        )
        {
            //
            bool result = false;

            //
            // Normalize ...
            if (language.IsNullOrEmpty())
            {
                language = AppConfiguration.DefaultLanguage;
            }

            //
            // Validate ...
            result =
                !value.IsNullOrEmpty() &&
                !resource.IsNullOrEmpty() &&
                !language.IsNullOrEmpty();
            if (!result)
            {
                return result;
            }

            //
            // Check Exists ...
            bool isExists = await IsResourceExists(resource, language);
            result = !isExists;
            if (!result)
            {
                XException.Duplicate.Throw();
            }

            //
            // Prepare Entity to Add ...
            XString entity = new XString
            {
                Language = language,
                TranslatedValue = value,
                ResourceTitle = resource,
            };
            entity = await Repository.AddAsync(entity);
            result = !entity.IsNullOrDefault();
            if (result)
            {
                //
                await SendPush(
                    action: XBaseEntityHubAction.Add.GetStringValue(),
                    entityId: entity.Id,
                    connectionId: connectionId
                );
            }

            //
            return result;
        }

        /// <summary>
        /// Update Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="value"></param>
        /// <param name="language"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<bool> Update(
            string resource,
            string value,
            string language = null,
            string connectionId = null
        )
        {
            //
            bool result = false;

            //
            // Normalize ...
            if (language.IsNullOrEmpty())
            {
                language = AppConfiguration.DefaultLanguage;
            }

            //
            // Validate ...
            result =
                !value.IsNullOrEmpty() &&
                !language.IsNullOrEmpty() &&
                !resource.IsNullOrEmpty();
            if (!result)
            {
                return result;
            }

            //
            // Check Value Must Exists ...
            result = await IsResourceExists(
                resource: resource,
                language: language
            );
            if (!result)
            {
                XException.NotFound.Throw();
            }

            //
            var entity = await Repository.FindOneAsync(e =>
                e.ResourceTitle == resource &&
                e.Language.ToNormalString() == language.ToNormalString()
            );
            if (entity.IsNullOrDefault())
            {
                XException.NotFound.Throw();
            }

            //
            // Update Entity ...
            entity.TranslatedValue = value;
            entity = await Repository.UpdateAsync(entity.Id, entity);
            result = !entity.IsNullOrDefault();
            if (result)
            {
                //
                await SendPush(
                    action: XBaseEntityHubAction.Update.GetStringValue(),
                    entityId: entity.Id,
                    connectionId: connectionId
                );
            }

            //
            return result;
        }

        /// <summary>
        /// Add Or Update Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="value"></param>
        /// <param name="language"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<bool> AddOrUpdate(
            string resource,
            string value,
            string language = null,
            string connectionId = null
        )
        {
            //
            var result = false;

            //
            // Normalize ...
            if (language.IsNullOrEmpty())
            {
                language = AppConfiguration.DefaultLanguage;
            }

            //
            // Check Existsance ...
            bool isExists = await IsResourceExists(
                resource: resource,
                language: language
            );

            //
            // Act Based on Existance ...
            if (isExists)
            {
                //
                result = await Update(
                    value: value,
                    resource: resource,
                    language: language
                );
            }
            else
            {
                //
                result = await Add(
                    value: value,
                    resource: resource,
                    language: language
                );
            }

            //
            return result;
        }

        /// <summary>
        /// Add Specified Resource ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<XStringDto> AddEntity(
            XStringDto item,
            string connectionId = null
        )
        {
            //
            // Validate ...
            bool isValid = !item.IsNull() &&
                !item.ResourceTitle.IsNullOrEmpty() &&
                !item.TranslatedValue.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Normalize ...
            if (item.Language.IsNullOrEmpty())
            {
                item.Language = AppConfiguration.DefaultLanguage;
            }
            isValid = !item.Language.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Resource Doesn't Exists ...
            isValid = await IsResourceExists(
                    resource: item.ResourceTitle,
                    language: item.Language
                );
            if (isValid)
            {
                XException.Duplicate.Throw();
            }

            //
            var result = new XString
            {
                Language = item.Language,
                ResourceTitle = item.ResourceTitle,
                TranslatedValue = item.TranslatedValue
            };
            result = await Repository.AddAsync(result);
            if (result.IsNullOrDefault())
            {
                XException.ActionFailed.Throw();
            }

            //
            await SendPush(
                action: XBaseEntityHubAction.Add.GetStringValue(),
                entityId: result.Id,
                connectionId: connectionId
            );

            //
            return result.ToXStringDto();
        }

        /// <summary>
        /// Update Specified Entity ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<XStringDto> UpdateEntity(
            XStringDto item,
            string connectionId = null
        )
        {
            //
            // Validate ...
            bool isValid = !item.IsNull() &&
                !item.ResourceTitle.IsNullOrEmpty() &&
                !item.TranslatedValue.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Normalize ...
            if (item.Language.IsNullOrEmpty())
            {
                item.Language = AppConfiguration.DefaultLanguage;
            }
            isValid = !item.Language.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Resource Exists ...
            isValid = await IsResourceExists(
                    resource: item.ResourceTitle,
                    language: item.Language
                );
            if (!isValid)
            {
                XException.NotFound.Throw();
            }

            //
            var entity = await Repository.FindOneAsync(e =>
                e.ResourceTitle == item.ResourceTitle &&
                e.Language.ToNormalString() == item.Language.ToNormalString()
            );
            if (entity.IsNullOrDefault())
            {
                XException.NotFound.Throw();
            }

            //
            // Update Entity ...
            entity.TranslatedValue = item.TranslatedValue;
            entity = await Repository.UpdateAsync(entity.Id, entity);
            if (entity.IsNullOrDefault())
            {
                XException.ActionFailed.Throw();
            }

            //
            XStringDto result = entity.ToXStringDto();
            await SendPush(
                action: XBaseEntityHubAction.Update.GetStringValue(),
                entityId: entity.Id,
                connectionId: connectionId
            );

            //
            return result;
        }

        /// <summary>
        /// Add Or Update Specified Entitiy ... 
        /// </summary>
        /// <param name="item"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<XStringDto> AddOrUpdateEntity(
            XStringDto item,
            string connectionId = null
        )
        {
            //
            // Validate ...
            bool isValid = !item.IsNull() &&
                !item.ResourceTitle.IsNullOrEmpty() &&
                !item.TranslatedValue.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Normalize ...
            if (item.Language.IsNullOrEmpty())
            {
                item.Language = AppConfiguration.DefaultLanguage;
            }
            isValid = !item.Language.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Resource Exists ...
            var isExists = await IsResourceExists(
                    resource: item.ResourceTitle,
                    language: item.Language
                );

            //
            XStringDto result = null;
            if (!isExists)
            {
                result = await AddEntity(item, connectionId);
            }
            else
            {
                result = await UpdateEntity(item, connectionId);
            }
            if (result.IsNullOrDefault())
            {
                XException.ActionFailed.Throw();
            }

            //
            return result;
        }

        /// <summary>
        /// Add Specified Locale Resource ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="resource"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<XStringDto> AddByLocaleResource(
            XLocaleResourceDto item,
            string resource,
            string connectionId = null
        )
        {
            //
            // Validate ...
            bool isValid =
                !item.IsNull() &&
                !resource.IsNullOrEmpty() &&
                !item.Value.IsNullOrEmpty() &&
                !item.Language.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Specified Resource / Language Exists ...
            isValid = await IsResourceExists(
                resource: resource,
                language: item.Language
            );
            if (isValid)
            {
                XException.Duplicate.Throw();
            }

            //
            // Prepare Item to Add ...
            var result = new XStringDto
            {
                Language = item.Language,
                ResourceTitle = resource,
                TranslatedValue = item.Value
            };
            result = await AddEntity(result, connectionId);

            //
            return result;
        }

        /// <summary>
        /// Update Specified Locale Resource ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="resource"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<XStringDto> UpdateByLocaleResource(
            XLocaleResourceDto item,
            string resource,
            string connectionId = null
        )
        {
            //
            // Validate ...
            bool isValid =
                !item.IsNull() &&
                !resource.IsNullOrEmpty() &&
                !item.Value.IsNullOrEmpty() &&
                !item.Language.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Specified Resource / Language Exists ...
            isValid = await IsResourceExists(
                resource: resource,
                language: item.Language
            );
            if (!isValid)
            {
                XException.NotFound.Throw();
            }

            //
            var entity = await Repository.FindOneAsync(e =>
                e.ResourceTitle == resource &&
                e.Language.ToNormalString() == item.Language.ToNormalString()
            );
            if (entity.IsNullOrDefault())
            {
                XException.NotFound.Throw();
            }

            //
            // Update ...
            entity.TranslatedValue = item.Value;
            entity = await Repository.UpdateAsync(entity.Id, entity);
            if (entity.IsNullOrDefault())
            {
                XException.ActionFailed.Throw();
            }

            //
            XStringDto result = entity.ToXStringDto();
            await SendPush(
                action: XBaseEntityHubAction.Update.GetStringValue(),
                entityId: entity.Id,
                connectionId: connectionId
            );

            //
            return result;
        }

        /// <summary>
        /// Add Or Update Resource By Locale ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="resource"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<XStringDto> AddOrUpdateByLocaleResource(
            XLocaleResourceDto item,
            string resource,
            string connectionId = null
        )
        {
            //
            // Validate ...
            bool isValid =
                !item.IsNull() &&
                !resource.IsNullOrEmpty() &&
                !item.Value.IsNullOrEmpty() &&
                !item.Language.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Check Specified Resource / Language Exists ...
            isValid = await IsResourceExists(
                resource: resource,
                language: item.Language
            );

            //
            XStringDto result = null;
            if (!isValid)
            {
                //
                result = await AddByLocaleResource(
                    item: item,
                    resource: resource
                );
            }
            else
            {
                //
                result = await UpdateByLocaleResource(
                    item: item,
                    resource: resource
                );
            }
            if (result.IsNullOrDefault())
            {
                XException.ActionFailed.Throw();
            }

            //
            return result;
        }

        /// <summary>
        /// Add Or Update all XResourceDto(s) Locales ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<IEnumerable<XStringDto>> AddByResource(
            XResourceDto item,
            string connectionId = null
        )
        {
            //
            // Validate ...
            bool isValid =
                !item.IsNull() &&
                item.Locales.HasChild() &&
                !item.Resource.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //
            var result = await Task
                .WhenAll(item.Locales
                    .Select(async e => await AddOrUpdateByLocaleResource(e, item.Resource)));

            //
            return result;
        }
        #endregion

        //
        #region Remove Actions ...
        /// <summary>
        /// Remove all Specified Language's Resources ...
        /// </summary>
        /// <param name="language"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task RemoveLanguageResources(
            string language,
            string connectionId = null
        )
        {
            //
            // Validate ...
            bool isValid = !language.IsNullOrEmpty();
            if (!isValid)
            {
                return;
            }

            //
            var entities = await Repository
                .FindManyAsync(e => e.Language.ToNormalString() == language.ToNormalString());

            //
            try
            {
                //
                await Repository.RemoveRangeAsync(entities);

                //
                var entitieIds = entities.Select(e => e.Id);
                await SendCustomPush(
                    action: XBaseEntityHubAction.DeleteMany.GetStringValue(),
                    payLoad: entitieIds.ToJSON(camelCase: true),
                    connectionId: connectionId
                );
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Remove all Specified Resource Ids instances ... 
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<IEnumerable<XStringDto>> RemoveResource(
            string resource,
            string connectionId = null
        )
        {
            //
            // Validate ...
            if (resource.IsNullOrEmpty())
            {
                XException.InvalidArgs.Throw();
            }

            //
            var result = new List<XStringDto>();
            var entities = await Repository.FindManyAsync(e => e.ResourceTitle == resource);
            foreach (var entity in entities)
            {
                //
                var removed = await Repository.RemoveAsync(entity);
                if (!removed.IsNullOrDefault())
                {
                    result.Add(removed.ToXStringDto());
                }
            }

            //
            if (result.HasChild())
            {
                //
                var ids = result.Select(i => i.Id);
                await SendCustomPush(
                    action: XBaseEntityHubAction.DeleteMany.GetStringValue(),
                    payLoad: ids.ToJSON(camelCase: true),
                    connectionId: connectionId
                );
            }

            //
            return result;
        }

        /// <summary>
        /// Remove Specified Resource ...
        /// </summary>
        /// <param name="resource"></param>
        /// <param name="language"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task<bool> Remove(
            string resource,
            string language = null,
            string connectionId = null
        )
        {
            //
            bool result = false;

            //
            // Normalize ...
            if (language.IsNullOrEmpty())
            {
                language = AppConfiguration.DefaultLanguage;
            }

            //
            // Validate ...
            result =
                !language.IsNullOrEmpty() &&
                !resource.IsNullOrEmpty();
            if (!result)
            {
                return result;
            }

            //
            // Check Resource Exists ...
            result = await IsResourceExists(
                language: language,
                resource: resource
            );
            if (!result)
            {
                return result;
            }

            //
            // Retrieve Entity ...
            var entity = await Repository.FindOneAsync(e =>
                e.ResourceTitle == resource &&
                e.Language.ToNormalString() == language.ToNormalString()
            );
            result = !entity.IsNullOrDefault();
            if (!result)
            {
                return result;
            }

            //
            // Delete ...
            entity = await Repository.RemoveAsync(entity.Id);
            result = !entity.IsNullOrDefault();
            if (result)
            {
                //
                await SendPush(
                    action: XBaseEntityHubAction.Delete.GetStringValue(),
                    entityId: entity.Id,
                    connectionId: connectionId
                );
            }

            //
            return result;
        }

        /// <summary>
        /// Remove all Resource of Specified XResourceDto ...
        /// </summary>
        /// <param name="item"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task RemoveByResource(
            XResourceDto item,
            string connectionId = null
        )
        {
            //
            bool isValid =
                !item.IsNullOrDefault() &&
                item.Locales.HasChild() &&
                !item.Resource.IsNullOrEmpty();
            if (!isValid)
            {
                XException.InvalidArgs.Throw();
            }

            //            
            foreach (var locale in item.Locales)
            {
                //
                await Remove(
                    resource: item.Resource,
                    language: locale.Language
                );
            }
        }
        #endregion

        //
        #region Hub Actions ...
        /// <summary>
        /// Send Specified Hub Action Notifications ...
        /// </summary>
        /// <param name="action"></param>
        /// <param name="entityId"></param>
        /// <returns></returns>
        public async Task SendPush(
            string action,
            int entityId,
            string connectionId = null
        )
        {
            //
            var actions = new List<string>
            {
                XBaseEntityHubAction.Add.GetStringValue(),
                XBaseEntityHubAction.Update.GetStringValue(),
                XBaseEntityHubAction.Delete.GetStringValue(),
                XBaseEntityHubAction.AddMany.GetStringValue(),
                XBaseEntityHubAction.DeleteMany.GetStringValue(),
                XBaseEntityHubAction.UpdateMany.GetStringValue(),
                XBaseEntityHubAction.AddOrUpdate.GetStringValue(),
            };

            //
            // Validate ...
            var isValid =
                entityId > 0 &&
                !Hub.IsNull() &&
                !action.IsNullOrEmpty() &&
                actions.Contains(action);
            if (!isValid)
            {
                return;
            }

            //
            // Retrieve and Validate Entity ...
            XString entity = null;
            try
            {
                entity = await Repository.GetAsync(entityId);
            }
            catch { }
            isValid = !entity.IsNullOrDefault();
            if (!isValid)
            {
                return;
            }

            //
            var clients = Hub.Clients.All;
            if (!connectionId.IsNullOrEmpty())
            {
                clients = Hub.Clients.AllExcept(connectionId);
            }
            await clients.SendAsync(action, entity.ToJSON(camelCase: true), connectionId);
        }

        /// <summary>
        /// Send Custom Push Message ...
        /// </summary>
        /// <param name="action"></param>
        /// <param name="payLoad"></param>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public async Task SendCustomPush(
            string action,
            string payLoad,
            string connectionId = null
        )
        {
            //
            var customActions = new List<string>
            {
                XBaseEntityHubAction.DeleteMany.GetStringValue(),
            };

            //
            // Validate ...
            var isValid =
                !Hub.IsNull() && 
                !action.IsNullOrEmpty() &&
                customActions.Contains(action);
            if (!isValid)
            {
                return;
            }

            //
            var clients = Hub.Clients.All;
            if (!connectionId.IsNullOrEmpty())
            {
                clients = Hub.Clients.AllExcept(connectionId);
            }
            await clients.SendAsync(action, payLoad, connectionId);
        }
        #endregion
    }
}