using System.Linq.Expressions;
using Microsoft.Extensions.Localization;
using SJZY.Expand.ABP.Core.Localization;
using SJZY.Expand.ABP.Core.PublicMethords;
using SJZY.Track.Application.Contract.Dtos.TrackTemplates;
using SJZY.Track.Application.Localization;
using SJZY.Track.Domain.Aggregates.TrackPullAggregate;
using SJZY.Track.Domain.Aggregates.TrackPushAggregate;
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
using SJZY.Track.Domain.Dtos.TrackTemplate;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.Services.TrackTemplates;

/// <summary>
/// 轨迹模版
/// </summary>
[ApiExplorerSettings(GroupName = "轨迹模版")]
[Route("/Track/Template")]
public class TrackTemplateService : ApplicationService, ITransientDependency
{
    private readonly IStringLocalizer<TrackLocalizationResource> _stringLocalizer;
    private readonly ITrackTemplateRepository _trackTemplateRepository;

    /// <inheritdoc/>
    public TrackTemplateService(
        IStringLocalizer<TrackLocalizationResource> stringLocalizer,
        ITrackTemplateRepository trackTemplateRepository
        )
    {
        _stringLocalizer = stringLocalizer;
        _trackTemplateRepository = trackTemplateRepository;
    }

    /// <summary>
    /// 轨迹模版编辑
    /// </summary>
    /// <returns></returns>
    [HttpPost("Edit")]
    public async Task<UnifyResultDto> EditAsync(EditTrackTemplateInput input)
    {
        return input.Options switch
        {
            OptionType.新增 => await AddAsync(input),
            OptionType.修改 => await UpdateAsync(input),
            OptionType.删除 => await DeleteAsync(input),
            _ => throw new BusinessException(message: "当前操作动作不合法")
        };
    }

    /// <summary>
    /// 根据模版id获取轨迹模版
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("GetDetail")]
    public async Task<UnifyResultDto<GetTrackTemplateDetailDto>> GetDetailAsync(int id)
    {
        var detailInfo = await _trackTemplateRepository.GetDetailAsync(id);
        if (detailInfo == null)
        {
            return new UnifyResultDto<GetTrackTemplateDetailDto>(false, null, "未查询到轨迹模版");
        }

        var dto = ObjectMapper.Map<GetTrackTemplateDetailVO, GetTrackTemplateDetailDto>(detailInfo);
        return new UnifyResultDto<GetTrackTemplateDetailDto>("200", "", dto);
    }

    /// <summary>
    /// 获取分页轨迹模版
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("GetList")]
    public async Task<UnifyPageResultDto<GetTrackTemplateListDto>> GetPageTrackTemplate(GetPageTrackTemplateInput input)
    {
        var vo = ObjectMapper.Map<GetPageTrackTemplateInput, GetPageTrackTemplateVO>(input);
        var resultDto = await _trackTemplateRepository.GetPageTrackTemplate(vo);
        var pageResultDto =
            ObjectMapper.Map<UnifyPageResultDto<GetTrackTemplateListVO>, UnifyPageResultDto<GetTrackTemplateListDto>>(
                resultDto);

        return pageResultDto;
    }

    #region 私有方法

    private async Task<UnifyResultDto> AddAsync(EditTrackTemplateInput input)
    {
        #region 业务校验

        //校验模版代码唯一性
        //var templateEntity =
        //    await _trackTemplateRepository.GetFirstAsync(
        //        a => a.SubSystemId == input.SubSystemId && a.Code == input.Code);
        var templateEntitys = await _trackTemplateRepository.GetListAsync(a => a.SubSystemId == input.SubSystemId && (a.Code == input.Code || a.Name == input.Name));
        if (templateEntitys.Any())
        {
            //throw new BusinessException(message: _stringLocalizer["TemplateExist"]);
            //throw new BusinessException(message: "模板代码已存在于当前选择的子系统下");
            var trackTemplateCode = templateEntitys.FirstOrDefault(t => t.Code == input.Code);
            if (trackTemplateCode != null)
            {
                throw new BusinessException(message: "该子系统下模板代码已存在");
            }
            var trackTemplateName = templateEntitys.FirstOrDefault(t => t.Name == input.Name);
            if (trackTemplateName != null)
            {
                throw new BusinessException(message: "该子系统下模板名称已存在");
            }
        }

        #endregion 业务校验

        var entity = ObjectMapper.Map<EditTrackTemplateInput, TrackTemplateEntity>(input);
        var isTrue = await _trackTemplateRepository.InsertAsync(entity);

        return new UnifyResultDto("200", "新增成功", isTrue);
    }

    private async Task<UnifyResultDto> UpdateAsync(EditTrackTemplateInput input)
    {
        #region 业务校验

        var templateEntitys = await _trackTemplateRepository.GetListAsync(a =>
            a.Id != input.Id && a.SubSystemId == input.SubSystemId && (a.Code == input.Code || a.Name == input.Name));
        if (templateEntitys.Any())
        {
            //throw new BusinessException(message: "模板代码已存在于当前选择的子系统下");
            var trackTemplateCode = templateEntitys.FirstOrDefault(t => t.Code == input.Code);
            if (trackTemplateCode != null)
            {
                throw new BusinessException(message: "该子系统下模板代码已存在");
            }
            var trackTemplateName = templateEntitys.FirstOrDefault(t => t.Name == input.Name);
            if (trackTemplateName != null)
            {
                throw new BusinessException(message: "该子系统下模板名称已存在");
            }
        }

        #endregion 业务校验

        var templateEntity = await _trackTemplateRepository.GetFirstAsync(a => a.Id == input.Id);
        ObjectMapper.Map(input, templateEntity);
        var isTrue = await _trackTemplateRepository.UpdateAsync(templateEntity);

        return new UnifyResultDto("200", "修改成功", isTrue);
    }

    private async Task<UnifyResultDto> DeleteAsync(EditTrackTemplateInput input)
    {
        var isTrue = await _trackTemplateRepository.SoftDeleteAsync(x => x.Id == input.Id);

        return new UnifyResultDto("200", "删除成功", isTrue);
    }

    #endregion 私有方法

    /// <summary>
    /// 轨迹模板内容列表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("GetContentPage")]
    public async Task<UnifyPageResultDto<GetTrackTemplateContentPageOutputVO>> GetContentPageAsync(
        [FromBody] GetTrackTemplateContentPageInputVO input)
    {
        return await _trackTemplateRepository.GetContentPageAsync(input);
    }

    /// <summary>
    /// 轨迹模板内容详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("GetContentDetail")]
    public async Task<GetTrackTemplateContentDetailOutputVO> GetContentDetailAsync(int id)
    {
        return await _trackTemplateRepository.GetContentDetailAsync(id);
    }

    /// <summary>
    /// 轨迹模板内容编辑
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("EditContent")]
    public async Task<bool> EditContentAsync([FromBody] EditTrackTemplateContentInput input)
    {
        if (input.Options != OptionTypeNoNull.删除)
        {
            Expression<Func<TrackTemplateContentEntity, bool>> isContentAnyExp = x =>
                x.TrackTemplateId == input.TrackTemplateId && x.TrackContentId == input.TrackContentId;
            if (input.Options == OptionTypeNoNull.修改) isContentAnyExp = isContentAnyExp.And(x => x.Id != input.Id);

            if (await _trackTemplateRepository.IsContentAnyAsync(isContentAnyExp))
                throw new BusinessException(message: _stringLocalizer["IsTrackTemplateContentAny"]);
        }

        switch (input.Options)
        {
            case OptionTypeNoNull.新增:
                {
                    int maxSort = await _trackTemplateRepository.ContentMaxAsync(x => x.Sort, x => x.TrackTemplateId == input.TrackTemplateId);

                    var entity = ObjectMapper.Map<EditTrackTemplateContentInput, TrackTemplateContentEntity>(input);
                    entity.Sort = maxSort + 1;

                    await _trackTemplateRepository.InsertContentAsync(entity);

                    break;
                }

            case OptionTypeNoNull.修改:
                {
                    var entity = await _trackTemplateRepository.GetContentByIdAsync(input.Id!.Value) ??
                                throw new BusinessException(message: _stringLocalizer["NotFindData"]);

                    ObjectMapper.Map(input, entity);

                    await _trackTemplateRepository.UpdateContentAsync(entity);

                    break;
                }

            case OptionTypeNoNull.删除:
                {
                    var entity = await _trackTemplateRepository.GetContentByIdAsync(input.Id!.Value) ??
                                throw new BusinessException(message: _stringLocalizer["NotFindData"]);

                    using (var ts = TransactionScopeHelper.Create())
                    {
                        await _trackTemplateRepository.SoftDeleteContentAsync(input.Id!.Value);

                        await _trackTemplateRepository.UpdateContentAsync(x => x.Sort == x.Sort - 1, x => x.TrackTemplateId == entity.TrackTemplateId && x.Sort > entity.Sort);

                        ts.Complete();
                    }

                    break;
                }

            default:
                throw new BusinessException(message: _stringLocalizer[SjzyBasicLocalization.Validation_IsInEnum,
                    nameof(EditTrackTemplateContentInput.Options)]);
        }

        return true;
    }

    /// <summary>
    /// 轨迹模板内容排序
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("SortContent")]
    public async Task<bool> SortContentAsync([FromBody] SortTrackTemplateContentInput input)
    {
        List<int> ids = input.SortInfo.Select(x => int.Parse(x.Key)).ToList();

        var trackTemplateContentEntities = await _trackTemplateRepository.GetContentListAsync(x => ids.Contains(x.Id));

        trackTemplateContentEntities.ForEach(item =>
        {
            item.Sort = input.SortInfo.Single(x => x.Key == item.Id.ToString()).Value;
        });

        await _trackTemplateRepository.UpdateContentRangeAsync(trackTemplateContentEntities);

        return true;
    }
}