using Microsoft.Extensions.Localization;
using SJZY.Expand.ABP.Core.Localization;
using SJZY.Expand.ABP.Core.PublicMethords;
using SJZY.Track.Application.Contract.Dtos.TrackContents;
using SJZY.Track.Application.Localization;
using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
using SJZY.Track.Domain.Dtos.TrackContents;
using SJZY.Track.Domain.Queries;
using System.Linq.Expressions;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.Services.TrackContents
{
    /// <summary>
    /// 轨迹内容服务
    /// </summary>
    [ApiExplorerSettings(GroupName = "轨迹内容")]
    [Route("/Track/Content")]
    public class TrackContentService : ApplicationService, ITransientDependency
    {
        private readonly IStringLocalizer<TrackLocalizationResource> _stringLocalizer;
        private readonly ITrackContentRepository _trackContentRepository;
        private readonly IBasicQuery<TrackContentMapEntity> _trackContentMapBasicQuery;
        private readonly IBasicQuery<TrackTemplateContentEntity> _trackTemplateContentBasicQuery;

        public TrackContentService(
            IStringLocalizer<TrackLocalizationResource> stringLocalizer,
            ITrackContentRepository trackContentRepository,
            IBasicQuery<TrackContentMapEntity> trackContentMapBasicQuery,
            IBasicQuery<TrackTemplateContentEntity> trackTemplateContentBasicQuery
        )
        {
            this._stringLocalizer = stringLocalizer;
            this._trackContentRepository = trackContentRepository;
            this._trackContentMapBasicQuery = trackContentMapBasicQuery;
            this._trackTemplateContentBasicQuery = trackTemplateContentBasicQuery;
        }

        /// <summary>
        /// 轨迹内容编辑
        /// </summary>
        /// <returns></returns>
        [HttpPost("Edit")]
        public async Task<UnifyResultDto> EditAsync(EditTrackContentInput 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<GetTrackContentDetailDto>> GetDetailAsync(int id)
        {
            var detailInfo = await _trackContentRepository.GetDetailAsync(id);
            if (detailInfo == null)
            {
                return new UnifyResultDto<GetTrackContentDetailDto>(false, null, "未查询到轨迹状态");
            }

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

        /// <summary>
        /// 获取分页轨迹内容
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("GetList")]
        public async Task<UnifyPageResultDto<GetTrackContentListDto>> GetPageTrackContent(
            GetPageTrackContentInput input)
        {
            var vo = ObjectMapper.Map<GetPageTrackContentInput, GetPageTrackContentVO>(input);
            var resultDto = await _trackContentRepository.GetPageTrackContent(vo);
            var pageResultDto =
                ObjectMapper.Map<UnifyPageResultDto<GetTrackContentListVO>, UnifyPageResultDto<GetTrackContentListDto>>(
                    resultDto);

            return pageResultDto;
        }

        #region 私有方法

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

            var trackContentEntitys = await _trackContentRepository.GetListAsync(a =>
                a.SubSystemId == input.SubSystemId && (a.Code == input.Code ||
                                                       a.Content == input.Content || a.EnContent == input.EnContent));
            if (trackContentEntitys.Any())
            {
                //throw new BusinessException(message: _stringLocalizer["TrackContentExist"]);
                var codes = trackContentEntitys.FirstOrDefault(a => a.Code==input.Code);
                if (codes!=null)
                {
                    throw new BusinessException(message: "该子系统下轨迹代码已存在");
                }
                var contents = trackContentEntitys.FirstOrDefault(a => a.Content==input.Content);
                if (contents!=null)
                {
                    throw new BusinessException(message: "该子系统下轨迹内容已存在");
                }
                var contentEns = trackContentEntitys.FirstOrDefault(a => a.EnContent==input.EnContent);
                if (contentEns!=null)
                {
                    throw new BusinessException(message: "该子系统下轨迹内容英文已存在");
                }
                //throw new BusinessException(message: "当前子系统下，轨迹代码或轨迹内容或轨迹内容英文存在");
            }

            #endregion 业务逻辑校验

            var entity = ObjectMapper.Map<EditTrackContentInput, TrackContentEntity>(input);
            var isTrue = await _trackContentRepository.InsertAsync(entity);

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

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

            var trackContentEntitys = await _trackContentRepository.GetListAsync(a => a.Id != input.Id &&
                a.SubSystemId == input.SubSystemId && (a.Code == input.Code ||
                                                       a.Content == input.Content || a.EnContent == input.EnContent));
            if (trackContentEntitys.Any())
            {
                //throw new BusinessException(message: _stringLocalizer["TrackContentExist"]);
                //throw new BusinessException(message: "当前子系统下，轨迹代码或轨迹内容或轨迹内容英文存在");
                var codes = trackContentEntitys.FirstOrDefault(a => a.Code==input.Code);
                if (codes!=null)
                {
                    throw new BusinessException(message: "该子系统下轨迹代码已存在");
                }
                var contents = trackContentEntitys.FirstOrDefault(a => a.Content==input.Content);
                if (contents!=null)
                {
                    throw new BusinessException(message: "该子系统下轨迹内容已存在");
                }
                var contentEns = trackContentEntitys.FirstOrDefault(a => a.EnContent==input.EnContent);
                if (contentEns!=null)
                {
                    throw new BusinessException(message: "该子系统下轨迹内容英文已存在");
                }
            }

            #endregion 业务逻辑校验

            //更新的时候需要覆盖内容映射轨迹代码
            var templateEntity = await _trackContentRepository.GetFirstAsync(a => a.Id == input.Id);

            bool isTrue = false;

            using (var ts = TransactionScopeHelper.Create())
            {
                // 如果轨迹内容的子系统和code发生变化，同步到轨迹映射表
                if (templateEntity.SubSystemId != input.SubSystemId || templateEntity.Code != input.Code)
                {
                    await _trackContentRepository.UpdateMapAsync(x => new TrackContentMapEntity
                    {
                        SubSystemId = input.SubSystemId,
                        TrackContentCode = input.Code
                    }, x => x.TrackContentId == input.Id);

                    await _trackContentRepository.UpdateMapAsync(x => new TrackContentMapEntity
                    {
                        MapSubSystemId = input.SubSystemId,
                        MapTrackContentCode = input.Code
                    }, x => x.MapTrackContentId == input.Id);
                }

                ObjectMapper.Map(input, templateEntity);

                isTrue = await _trackContentRepository.UpdateAsync(templateEntity);

                ts.Complete();
            }

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

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

            //查询是否关联了轨迹模版内容
            var trackTemplateContents = await _trackTemplateContentBasicQuery.GetListAsync(a => a.TrackContentId == input.Id);
            if (trackTemplateContents.Any())
            {
                throw new BusinessException(message: "该轨迹内容关联轨迹模板，禁止删除");
            }

            //需要加个判断，存在内容映射，则出提示
            var trackContentMapEntities = await _trackContentMapBasicQuery.GetListAsync(a => a.TrackContentId == input.Id || a.MapTrackContentId == input.Id);
            if (trackContentMapEntities.Any())
            {
                throw new BusinessException(message: "无法删除该内容，该轨迹内容已在轨迹内容映射中使用了,请检查");
            }

            #endregion 业务校验

            var isTrue = await _trackContentRepository.SoftDeleteAsync(x => x.Id == input.Id);

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

        #endregion 私有方法

        /// <summary>
        /// 轨迹内容映射列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("GetMapPage")]
        public async Task<UnifyPageResultDto<GetTrackContentMapPageOutputVO>> GetMapPageAsync([FromBody] GetTrackContentMapPageInputVO input)
        {
            return await _trackContentRepository.GetMapPageAsync(input);
        }

        /// <summary>
        /// 轨迹内容映射详情
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("GetMapDetail")]
        public async Task<GetTrackContentMapDetailOutputVO> GetMapDetailAsync(int id)
        {
            return await _trackContentRepository.GetMapDetailAsync(id);
        }

        /// <summary>
        /// 轨迹内容映射编辑
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("EditMap")]
        public async Task<bool> EditMapAsync([FromBody] EditTrackContentMapInput input)
        {
            if (input.Options != OptionTypeNoNull.删除)
            {
                if (input.SubSystemId == input.MapSubSystemId) throw new BusinessException(message: _stringLocalizer["NotAllowedToMapSubSystem"]);

                Expression<Func<TrackContentMapEntity, bool>> isMapAnyExp = x =>
                    x.TrackContentId == input.TrackContentId && x.MapTrackContentId == input.MapTrackContentId;
                if (input.Options == OptionTypeNoNull.修改) isMapAnyExp.And(x => x.Id != input.Id);

                if (await _trackContentRepository.IsMapAnyAsync(isMapAnyExp))
                    throw new BusinessException(message: _stringLocalizer["IsTrackContentMapAny"]);
            }

            switch (input.Options)
            {
                case OptionTypeNoNull.新增:
                    {
                        var trackContentMapEntity = ObjectMapper.Map<EditTrackContentMapInput, TrackContentMapEntity>(input);

                        await _trackContentRepository.InsertMapAsync(trackContentMapEntity);
                    }
                    break;

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

                        ObjectMapper.Map(input, oldTrackContentMapEntity);

                        await _trackContentRepository.UpdateMapAsync(oldTrackContentMapEntity);
                    }
                    break;

                case OptionTypeNoNull.删除:
                    await _trackContentRepository.SoftDeleteMapAsync(x => x.Id == input.Id);
                    break;

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

            return true;
        }
    }
}