using IRaCIS.Application.Interfaces;
using IRaCIS.Core.Infra.EFCore;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Application.Filter;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Service.WorkLoad.DTO;
using Microsoft.AspNetCore.Authorization;
using IRaCIS.Core.Application.Auth;
using IRaCIS.Core.Application.Service.Reading.Dto;
using IRaCIS.Core.Domain.Share.Reading;
using MassTransit;
using IRaCIS.Core.Application.Service.Reading;
using IRaCIS.Core.Infra.EFCore.Common;
using Panda.DynamicWebApi.Attributes;

namespace IRaCIS.Application.Services
{
    /// <summary>
    /// 阅片问题.标准
    /// </summary>
    [ApiExplorerSettings(GroupName = "Reading")]
    public class ReadingQuestionService : BaseService
    {

        private readonly IRepository<SubjectVisit> _subjectVisitRepository;
        private readonly IRepository<ReadingQuestionCriterionSystem> _readingQuestionCriterionSystemRepository;
        private readonly IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository;
        private readonly IRepository<ReadingQuestionSystem> _readingQuestionSystemRepository;
        private readonly IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository;
        private readonly IRepository<ClinicalDataTrialSet> _clinicalDataTrialSetRepository;
        private readonly IRepository<ClinicalDataSystemSet> _clinicalDataSystemSetRepository;
        private readonly IRepository<Dictionary> _dictionaryRepository;
        private readonly IRepository<PreviousPDF> _previousPDFRepository;

        public ReadingQuestionService(
            IRepository<SubjectVisit> subjectVisitRepository,
            IRepository<ReadingQuestionCriterionSystem> readingQuestionCriterionSystemRepository,
            IRepository<ReadingQuestionCriterionTrial> readingQuestionCriterionTrialRepository,
            IRepository<ReadingQuestionSystem> readingQuestionSystemRepository,
            IRepository<ReadingQuestionTrial> readingQuestionTrialRepository,
            IRepository<ClinicalDataTrialSet> ClinicalDataTrialSetRepository,
            IRepository<ClinicalDataSystemSet> ClinicalDataSystemSetRepository,
            IRepository<Dictionary> dictionaryRepository,
            IRepository<PreviousPDF> previousPDFRepository
          )
        {
            this._subjectVisitRepository = subjectVisitRepository;
            this._readingQuestionCriterionSystemRepository = readingQuestionCriterionSystemRepository;
            this._readingQuestionCriterionTrialRepository = readingQuestionCriterionTrialRepository;
            this._readingQuestionSystemRepository = readingQuestionSystemRepository;
            this._readingQuestionTrialRepository = readingQuestionTrialRepository;
            this._clinicalDataTrialSetRepository = ClinicalDataTrialSetRepository;
            this._clinicalDataSystemSetRepository = ClinicalDataSystemSetRepository;
            this._dictionaryRepository = dictionaryRepository;
            this._previousPDFRepository = previousPDFRepository;
        }

        ///// <summary>
        ///// 新增修改系统问题标准
        ///// </summary>
        ///// <param name="indto"></param>
        ///// <returns></returns>
        //[HttpPost]
        //public async Task<IResponseOutput> AddOrUpdateReadingQuestionCriterionSystem(AddOrUpdateReadingQuestionCriterionSystemInDto indto)
        //{
        //    var entity = await _readingQuestionCriterionSystemRepository.InsertOrUpdateAsync(indto,true);
        //    return ResponseOutput.Ok(entity.Id.ToString());
        //}

        /// <summary>
        /// 获取系统问题标准
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<ReadingQuestionCriterionSystemView>> GetReadingQuestionCriterionSystemList(ReadingQuestionCriterionSystemViewInDto inDto)
        {
            await AddSystemQuestionCriterion();
            var query=  _readingQuestionCriterionSystemRepository.AsQueryable()
                 .WhereIf(!inDto.CriterionName.IsNullOrEmpty(), x => x.CriterionName.Contains(inDto.CriterionName))
                 .ProjectTo<ReadingQuestionCriterionSystemView>(_mapper.ConfigurationProvider);
             return  await query.ToPagedListAsync(inDto.PageIndex, inDto.PageSize, inDto.SortField == null ? nameof(ReadingQuestionCriterionSystemView.CriterionName) : inDto.SortField,
              inDto.Asc);
        }

        /// <summary>
        /// 设置系统问题标准是否生效
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> SetSystemReadingQuestionCriterionIsIsEnable(SetSystemReadingQuestionCriterionIsIsEnable inDto)
        {
           await _readingQuestionCriterionSystemRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingQuestionCriterionSystem()
            {
                IsEnable = inDto.IsEnable
            });

            var result =await _readingQuestionCriterionSystemRepository.SaveChangesAsync();

            return ResponseOutput.Ok(result);
        }

        /// <summary>
        /// 添加系统qc问题标准
        /// </summary>
        /// <returns></returns>
        [NonDynamicMethod]
        private async Task AddSystemQuestionCriterion()
        {
            var useSystemQuestionCriterionIds = _readingQuestionCriterionSystemRepository.Select(x => x.CriterionId);
            var dictionaryParentId =await _dictionaryRepository.Where(x => x.Code == "ReadingStandard").Select(x => x.Id).FirstOrDefaultAsync();
            var criterionList = await _dictionaryRepository.Where(x => x.ParentId == dictionaryParentId && !useSystemQuestionCriterionIds.Contains(x.Id))
                .Select(x => new CriterionList()
                {
                    Id = x.Id,
                    Value = x.Value
                }).ToListAsync();
            List<ReadingQuestionCriterionSystem> needAddCriterionList = new List<ReadingQuestionCriterionSystem>();
            criterionList.ForEach(x =>
            {
                needAddCriterionList.Add(new ReadingQuestionCriterionSystem()
                {
                    CriterionId = x.Id,
                    CriterionName = x.Value,
                    IsEnable = false,
                });
            });
           await  _readingQuestionCriterionSystemRepository.AddRangeAsync(needAddCriterionList);
           await _readingQuestionCriterionSystemRepository.SaveChangesAsync();
        }

        ///// <summary>
        ///// 删除系统问题标准
        ///// </summary>
        ///// <param name="readingQuestionCriterionSystemId"></param>
        ///// <returns></returns>
        //[HttpDelete("{readingQuestionCriterionSystemId:guid}")]
        //public async Task<IResponseOutput> DeleteReadingQuestionCriterionSystem(Guid readingQuestionCriterionSystemId)
        //{
        //     await _readingQuestionCriterionSystemRepository.DeleteFromQueryAsync(t => t.Id == readingQuestionCriterionSystemId);
        //    var success = await _readingQuestionCriterionSystemRepository.SaveChangesAsync();
        //    return ResponseOutput.Result(success);
        //}



        /// <summary>
        /// 新增修改系统问题
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingQuestionSystem(AddOrUpdateReadingQuestionSystemInDto indto)
        {
            var entity = await _readingQuestionSystemRepository.InsertOrUpdateAsync(indto, true);
            return ResponseOutput.Ok(entity.Id.ToString());
        }

        /// <summary>
        /// 获取系统问题
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<ReadingQuestionSystemView>> GetReadingQuestionSystemList(ReadingQuestionSystemViewInDto inDto)
        {
            var query = _readingQuestionSystemRepository.AsQueryable()
                .Where(x=>x.ReadingQuestionCriterionSystemId==inDto.ReadingQuestionCriterionSystemId)
                 .WhereIf(!inDto.QuestionName.IsNullOrEmpty(), x => x.QuestionName.Contains(inDto.QuestionName))
                  .WhereIf(!inDto.Type.IsNullOrEmpty(), x => x.Type.Contains(inDto.Type))
                 .ProjectTo<ReadingQuestionSystemView>(_mapper.ConfigurationProvider);
            return await query.ToPagedListAsync(inDto.PageIndex, inDto.PageSize, inDto.SortField == null ? nameof(ReadingQuestionSystemView.QuestionName) : inDto.SortField,
             inDto.Asc);
        }

        /// <summary>
        /// 获取系统标准的其他问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CriterionOtherQuestionOutDto>> GetSystemCriterionOtherQuestion(GetSystemCriterionOtherQuestionInDto inDto)
        {
            var types = new List<string>()
            {
                "select","radio"
            };
            var questionList =await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.ReadingQuestionCriterionSystemId)
                .Where(x=> types.Contains(x.Type))
                .WhereIf(inDto.Id != null, x => x.Id != inDto.Id)
                .Select(x => new CriterionOtherQuestionOutDto()
                {
                    QuestionId = x.Id,
                    QuestionName = x.QuestionName,
                    TypeValue=x.TypeValue,
                }).ToListAsync();

            return questionList;
        }

        /// <summary>
        /// 删除系统问题
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("{id:guid}")]
        public async Task<IResponseOutput> DeleteReadingQuestionSystem(Guid id)
        {
            if (await _readingQuestionSystemRepository.AnyAsync(x => x.ParentId == id))
            {
                return ResponseOutput.NotOk("此问题存在子问题,请先删除子问题");
            }
            await _readingQuestionSystemRepository.DeleteFromQueryAsync(t => t.Id == id);
            var success = await _readingQuestionSystemRepository.SaveChangesAsync();
            return ResponseOutput.Result(success);
        }

        /// <summary>
        /// 添加系统数据到项目里面
        /// </summary>
        /// <returns></returns>  
        [NonDynamicMethod]
        private async Task AddSystemDataToTrila(Guid trialId)
        {
            var trialUsrSystemIds = _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == trialId && x.ReadingQuestionCriterionSystemId != null)
                .Select(x => x.ReadingQuestionCriterionSystemId);
            var needAddSystemDataList = await _readingQuestionCriterionSystemRepository.Where(x => !trialUsrSystemIds.Contains(x.Id)&&x.IsEnable).Include(x=>x.ReadingQuestionSystemList).ToListAsync();
            List<ReadingQuestionCriterionTrial> needAddCriterionList = new List<ReadingQuestionCriterionTrial>();
            List<ReadingQuestionTrial> needAddQuestionList = new List<ReadingQuestionTrial>();
            needAddSystemDataList.ForEach(x =>
            {
                var criterion = new ReadingQuestionCriterionTrial()
                {
                    CriterionName = x.CriterionName,
                    IsEnable = false,
                    ReadingQuestionCriterionSystemId = x.Id,
                    TrialId = trialId,
                    Id = NewId.NextGuid(),
                };
                List<ReadingQuestionSystem> systemQuestionList = x.ReadingQuestionSystemList.Clone();
                List<ReadingQuestionTrial> readingQuestionTrialList = new List<ReadingQuestionTrial>();
                SetChildParentQuestion(criterion.Id, trialId, systemQuestionList, readingQuestionTrialList);
                needAddCriterionList.Add(criterion);
                needAddQuestionList.AddRange(readingQuestionTrialList);
            });
            await _readingQuestionCriterionTrialRepository.AddRangeAsync(needAddCriterionList);
            await _readingQuestionTrialRepository.AddRangeAsync(needAddQuestionList);
            await _readingQuestionTrialRepository.SaveChangesAsync();
        }

        /// <summary>
        /// 设置父子关系
        /// </summary>
        /// <param name="ReadingQuestionCriterionTrialId">项目标准ID</param>
        /// <param name="trialId">项目Id</param>
        /// <param name="systemQuesitonList">系统问题</param>
        /// <param name="needQuestionList">需要添加list</param>
        private void SetChildParentQuestion(Guid ReadingQuestionCriterionTrialId, Guid trialId, List<ReadingQuestionSystem> systemQuesitonList,List<ReadingQuestionTrial> needQuestionList)
        {
            var parentIdIsNullList = systemQuesitonList.Where(x => x.ParentId == null).ToList();
            parentIdIsNullList.ForEach(x =>
            {
                var quesiton = x.Clone();
                var oldId = quesiton.Id;
                var newId = NewId.NextGuid();
                needQuestionList.Add(new ReadingQuestionTrial()
                {
                    Id = newId,
                    ShowOrder = quesiton.ShowOrder,
                    IsEnable = quesiton.IsEnable,
                    IsRequired = quesiton.IsRequired,
                    ParentTriggerValue = quesiton.ParentTriggerValue,
                    QuestionName = quesiton.QuestionName,
                    ReadingQuestionCriterionTrialId = ReadingQuestionCriterionTrialId,
                    TrialId = trialId,
                    Type = quesiton.Type,
                    TypeValue = quesiton.TypeValue,
                });

                CreateQuestionRelation(ReadingQuestionCriterionTrialId, trialId, oldId, newId, systemQuesitonList, needQuestionList);
            });
        }

        /// <summary>
        /// 递归处理父子关系
        /// </summary>
        /// <param name="ReadingQuestionCriterionTrialId"></param>
        /// <param name="trialId"></param>
        /// <param name="oldParentId"></param>
        /// <param name="newParentId"></param>
        /// <param name="systemQuesitonList"></param>
        /// <param name="needQuestionList"></param>
        private void CreateQuestionRelation(Guid ReadingQuestionCriterionTrialId, Guid trialId,Guid oldParentId,Guid newParentId, List<ReadingQuestionSystem> systemQuesitonList, List<ReadingQuestionTrial> needQuestionList)
        {
            var childList = systemQuesitonList.Where(x => x.ParentId == oldParentId).ToList();
            childList.ForEach(x =>
            {
                var quesiton = x.Clone();
                var oldId = quesiton.Id;
                var newId = NewId.NextGuid();
                needQuestionList.Add(new ReadingQuestionTrial()
                {
                    Id = newId,
                    ShowOrder = quesiton.ShowOrder,
                    IsEnable = quesiton.IsEnable,
                    IsRequired = quesiton.IsRequired,
                    ParentId = newParentId,
                    ParentTriggerValue = quesiton.ParentTriggerValue,
                    QuestionName = quesiton.QuestionName,
                    ReadingQuestionCriterionTrialId = ReadingQuestionCriterionTrialId,
                    TrialId = trialId,
                    Type = quesiton.Type,
                    TypeValue = quesiton.TypeValue,
                });

                CreateQuestionRelation(ReadingQuestionCriterionTrialId, trialId, oldId, newId, systemQuesitonList, needQuestionList);
            });

        }

        /// <summary>
        /// 新增修改项目问题标准（项目）
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingQuestionCriterionTrial(AddOrUpdateReadingQuestionCriterionTrialInDto indto)
        {
            var entity = await _readingQuestionCriterionTrialRepository.InsertOrUpdateAsync(indto, true);
            return ResponseOutput.Ok(entity.Id.ToString());
        }


        /// <summary>
        /// 设置项目标准是否生效
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> SetTrialReadingQuestionCriterionIsIsEnable(SetSystemReadingQuestionCriterionIsIsEnable inDto)
        {
            await _readingQuestionCriterionTrialRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingQuestionCriterionTrial()
            {
                IsEnable = inDto.IsEnable
            });

            var result = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();

            return ResponseOutput.Ok(result);
        }

        /// <summary>
        /// 获取项目问题标准（项目）
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<ReadingQuestionCriterionTrialView>> GetReadingQuestionCriterionTrialList(ReadingQuestionCriterionTrialViewInDto inDto)
        {
            await AddSystemDataToTrila(inDto.TrialId);
            var query = _readingQuestionCriterionTrialRepository.AsQueryable()
                .Where(x=>x.TrialId==inDto.TrialId)
                 .WhereIf(!inDto.CriterionName.IsNullOrEmpty(), x => x.CriterionName.Contains(inDto.CriterionName))
                 .ProjectTo<ReadingQuestionCriterionTrialView>(_mapper.ConfigurationProvider);
            return await query.ToPagedListAsync(inDto.PageIndex, inDto.PageSize, inDto.SortField == null ? nameof(ReadingQuestionCriterionTrialView.CriterionName) : inDto.SortField,
             inDto.Asc);
        }

        /// <summary>
        /// 删除项目问题标准（项目）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("{id:guid}")]
        public async Task<IResponseOutput> DeleteReadingQuestionCriterionTrial(Guid id)
        {
            await _readingQuestionCriterionTrialRepository.DeleteFromQueryAsync(t => t.Id == id);
            var success = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();
            return ResponseOutput.Result(success);
        }



        /// <summary>
        /// 新增修改项目问题（项目）
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingQuestionTrial(AddOrUpdateReadingQuestionTrialInDto indto)
        {
            var entity = await _readingQuestionTrialRepository.InsertOrUpdateAsync(indto, true);
            return ResponseOutput.Ok(entity.Id.ToString());
        }

        /// <summary>
        /// 获取项目问题（项目）
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<ReadingQuestionTrialView>> GetReadingQuestionTrialList(ReadingQuestionTrialViewInDto inDto)
        {
            var query = _readingQuestionTrialRepository.AsQueryable()
                .Where(x => x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId)
                 .WhereIf(!inDto.QuestionName.IsNullOrEmpty(), x => x.QuestionName.Contains(inDto.QuestionName))
                  .WhereIf(!inDto.Type.IsNullOrEmpty(), x => x.Type.Contains(inDto.Type))
                 .ProjectTo<ReadingQuestionTrialView>(_mapper.ConfigurationProvider);
            return await query.ToPagedListAsync(inDto.PageIndex, inDto.PageSize, inDto.SortField == null ? nameof(ReadingQuestionTrialView.QuestionName) : inDto.SortField,
             inDto.Asc);
        }



        /// <summary>
        /// 获取项目标准的其他问题(项目)
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CriterionOtherQuestionOutDto>> GetTrialCriterionOtherQuestion(GetTrialCriterionOtherQuestionInDto inDto)
        {
            var types = new List<string>()
            {
                "select","radio"
            };
            var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId)
                   .Where(x => types.Contains(x.Type))
                .WhereIf(inDto.Id != null, x => x.Id != inDto.Id)
                .Select(x => new CriterionOtherQuestionOutDto()
                {
                    QuestionId = x.Id,
                    QuestionName = x.QuestionName,
                    TypeValue = x.TypeValue,
                }).ToListAsync();

            return questionList;
        }

        /// <summary>
        /// 删除项目问题（项目）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("{id:guid}")]
        public async Task<IResponseOutput> DeleteReadingQuestionTrial(Guid id)
        {
            if (await _readingQuestionTrialRepository.AnyAsync(x => x.ParentId == id))
            {
                return ResponseOutput.NotOk("此问题存在子问题,请先删除子问题");
            }
            await _readingQuestionTrialRepository.DeleteFromQueryAsync(t => t.Id == id);
            var success = await _readingQuestionTrialRepository.SaveChangesAsync();
            return ResponseOutput.Result(success);
        }

    }
}