using Erp.Languages.Entities;
using Erp.Languages.Localization;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Auditing;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Validation;

namespace Erp.Languages;

public class LanguageTextAppService : CrudAppService<
    LanguageText,
    LanguageTextDto,
    Guid,
    PagedAndSortedResultRequestDto,
    LanguageTextCreateUpdateDto>,
    ILanguageTextAppService
{
    private readonly IRepository<LanguageText, Guid> _repositoryText;
    private readonly IRepository<LanguageKey, Guid> _repositoryKey;

    public LanguageTextAppService(
        IRepository<LanguageText, Guid> repositoryText,
        IRepository<LanguageKey, Guid> repositoryKey
        )
        : base(repositoryText)
    {
        LocalizationResource = typeof(LanguagesResource);
        ObjectMapperContext = typeof(LanguagesApplicationModule);
        _repositoryText = repositoryText;
        _repositoryKey = repositoryKey;
    }

    public override async Task<LanguageTextDto> CreateAsync(LanguageTextCreateUpdateDto input)
    {
        var recordExists = await _repositoryText.AnyAsync(
            a => a.CultureName == input.CultureName &&
            a.Key == input.Key &&
            a.ResourceName == input.ResourceName);
        if (recordExists)
        {
            var validationErrors = new ValidationResult(
                    L["Error:UniqueControl"],
                    new string[] { "CultureName", "Key", "ResourceName" }
                    );
            throw new AbpValidationException(new List<ValidationResult> { validationErrors });
        }

        return await base.CreateAsync(input);
    }

    public async Task UpdateLanguageTextAsync(LanguageTextCreateUpdateDto input)
    {
        var entity = await _repositoryText.GetAsync(
            a => a.CultureName == input.CultureName &&
            a.ResourceName == input.ResourceName &&
            a.Key == input.Key);
        if (entity != null)
        {
            entity.Value = input.Value;

            await _repositoryText.UpdateAsync(entity);
        }
    }

    public async Task<PagedResultDto<LanguageTextTranslatedDto>> GetLanguageTextTranslatedAsync(LanguageTextTranslatedRequestDto input)
    {
        var query = await _repositoryKey.GetQueryableAsync();
        query = query
            .WhereIf(!input.ResourceName.IsNullOrEmpty(), a => a.ResourceName == input.ResourceName)
            .WhereIf(!input.Key.IsNullOrEmpty(), a => a.Key == input.Key);
        var totalCount = await query.CountAsync();
        query = ApplySorting(query, input);
        query = ApplyPaging(query, input);
        var keys = await query.ToListAsync();

        var dtoLanguageTextTranslate = ObjectMapper.Map<List<LanguageKey>, List<LanguageTextTranslatedDto>>(keys);

        var dtoBaseCulturesValue = await _repositoryText.GetListAsync(a => a.CultureName == input.BaseCultureName);
        var dtoTargetCulturesValue = await _repositoryText.GetListAsync(a => a.CultureName == input.TargetCultureName);

        dtoLanguageTextTranslate.ForEach(dto =>
        {
            var baseEntity = dtoBaseCulturesValue.FirstOrDefault(a => a.Key == dto.Key && a.ResourceName == dto.ResourceName);

            dto.BaseCultureName = input.BaseCultureName;
            dto.BaseValue = baseEntity?.Value;

            var targetEntity = dtoTargetCulturesValue.FirstOrDefault(a => a.Key == dto.Key && a.ResourceName == dto.ResourceName);

            dto.TargetCultureName = input.TargetCultureName;
            dto.TargetValue = targetEntity?.Value;
        });

        return new PagedResultDto<LanguageTextTranslatedDto>(totalCount, dtoLanguageTextTranslate);
    }

    public async Task<LanguageTextDto> GetLanguageTextAsync(LanguageTextFilteredDto input)
    {
        var entity = await _repositoryText.FirstOrDefaultAsync(a =>
            a.CultureName == input.CultureName &&
            a.ResourceName == input.ResourceName &&
            a.Key == input.Key);

        return ObjectMapper.Map<LanguageText, LanguageTextDto>(entity);
    }

    public async Task<List<LanguageTextDto>> GetLanguageTextByCultureNameAsync(string CultureName)
    {
        var item = await _repositoryText.GetListAsync(a => a.CultureName == CultureName);
        if (item is null)
        {
            throw new EntityNotFoundException(L["RecordNotFound"]);
        }

        return ObjectMapper.Map<List<LanguageText>, List<LanguageTextDto>>(item);
    }
    
    protected virtual IQueryable<LanguageKey> ApplySorting(IQueryable<LanguageKey> query, LanguageTextTranslatedRequestDto input)
    {
        //Try to sort query if available
        if (input is ISortedResultRequest sortInput)
        {
            if (!sortInput.Sorting.IsNullOrWhiteSpace())
            {
                return query.OrderBy(sortInput.Sorting);
            }
        }

        //IQueryable.Task requires sorting, so we should sort if Take will be used.
        if (input is ILimitedResultRequest)
        {
            return ApplyDefaultSorting(query);
        }

        //No sorting
        return query;
    }

    protected virtual IQueryable<LanguageKey> ApplyDefaultSorting(IQueryable<LanguageKey> query)
    {
        if (typeof(LanguageKey).IsAssignableTo<IHasCreationTime>())
        {
            return query.OrderByDescending(e => ((IHasCreationTime)e).CreationTime);
        }

        throw new AbpException("No sorting specified but this query requires sorting. Override the ApplyDefaultSorting method for your application service derived from AbstractKeyReadOnlyAppService!");
    }

    protected virtual IQueryable<LanguageKey> ApplyPaging(IQueryable<LanguageKey> query, LanguageTextTranslatedRequestDto input)
    {
        //Try to use paging if available
        if (input is IPagedResultRequest pagedInput)
        {
            return query.PageBy(pagedInput);
        }

        //Try to limit query result if available
        if (input is ILimitedResultRequest limitedInput)
        {
            return query.Take(limitedInput.MaxResultCount);
        }

        //No paging
        return query;
    }
}