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 MassTransit;
using IRaCIS.Core.Application.Service.Reading;
using IRaCIS.Core.Infra.EFCore.Common;
using Panda.DynamicWebApi.Attributes;
using AutoMapper;
using IRaCIS.Core.Application.Contracts;

namespace IRaCIS.Application.Services
{
    /// <summary>
    /// IR影像阅片
    /// </summary>
    [ApiExplorerSettings(GroupName = "Reading")]
    public class ReadingImageTaskService : BaseService, IReadingImageTaskService
    {
        private readonly IMapper mapper;
        private readonly IRepository<NoneDicomStudy> _noneDicomStudyRepository;
        private readonly IRepository<VisitTask> _visitTaskRepository;
        private readonly IRepository<SubjectVisit> _subjectVisitRepository;
        private readonly IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository;
        private readonly IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository;
        private readonly IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository;

        public ReadingImageTaskService(
                 IMapper mapper,
                 IRepository<NoneDicomStudy> noneDicomStudyRepository,
                  IRepository<VisitTask> visitTaskRepository,
                   IRepository<SubjectVisit> subjectVisitRepository,
                 IRepository<ReadingTaskQuestionAnswer> readingTaskQuestionAnswerRepository,
                  IRepository<ReadingQuestionCriterionTrial> readingQuestionCriterionTrialRepository,
                  IRepository<ReadingQuestionTrial> readingQuestionTrialRepository
          )
        {
            this.mapper = mapper;
            this._noneDicomStudyRepository = noneDicomStudyRepository;
            this._visitTaskRepository = visitTaskRepository;
            this._subjectVisitRepository = subjectVisitRepository;
            this._readingTaskQuestionAnswerRepository = readingTaskQuestionAnswerRepository;
            this._readingQuestionCriterionTrialRepository = readingQuestionCriterionTrialRepository;
            this._readingQuestionTrialRepository = readingQuestionTrialRepository;
        }

        /// <summary>
        /// 获取下一个阅片任务
        /// </summary>
        /// <param name="subjectId"></param>
        /// <param name="trialId"></param>
        /// <returns></returns>
        private async Task<GetReadingTaskDto> GetNextTaskId(Guid? subjectId,Guid trialId)
        {
            GetReadingTaskDto? task = new GetReadingTaskDto();
            if (subjectId != null)
            {
                 task = await _visitTaskRepository.Where(x => x.TrialId == trialId && x.ReadingTaskState != ReadingTaskState.HaveSigned && x.SubjectId == subjectId.Value).Select(x => new GetReadingTaskDto()
                {

                    ReadingCategory = x.ReadingCategory,
                    VisistId = x.ReadingCategory == ReadingCategory.Visit ? x.SourceSubjectVisitId.Value : x.ReadModule.SubjectVisitId,
                    VisitNum = x.ReadingCategory == ReadingCategory.Visit ? x.SubjectVisit.VisitNum : x.ReadModule.VisitNum
                }).OrderBy(x => x.VisitNum).ThenBy(x => x.ReadingCategory).FirstOrDefaultAsync();
                task.SubjectId = subjectId.Value;


            }
            else
            {
                task = await _visitTaskRepository.Where(x => x.TrialId == trialId && x.ReadingTaskState != ReadingTaskState.HaveSigned).Select(x => new GetReadingTaskDto()
                {

                    ReadingCategory = x.ReadingCategory,
                    VisistId = x.ReadingCategory == ReadingCategory.Visit ? x.SourceSubjectVisitId.Value : x.ReadModule.SubjectVisitId,
                    VisitNum = x.ReadingCategory == ReadingCategory.Visit ? x.SubjectVisit.VisitNum : x.ReadModule.VisitNum
                }).FirstOrDefaultAsync();

                task.SubjectId = await _subjectVisitRepository.Where(x => x.Id == task.VisistId).Select(x => x.SubjectId).FirstOrDefaultAsync();
            }

            return task;



        

          
        }

        /// <summary>
        /// 获取阅片非Dicom文件
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetReadingImgOutDto>> GetReadingImageFile(GetReadingImgInDto inDto)
        {
            var task=await GetNextTaskId(inDto.SubjectId, inDto.TrialId);
            List<Guid> visitIds = new List<Guid>();
            if (task.ReadingCategory == ReadingCategory.Visit)
            {
                visitIds.Add(task.VisistId);
            }
            else
            {
                // 阅片期取前面所有的图像
                visitIds.AddRange(await _subjectVisitRepository.Where(x => x.VisitNum <= task.VisitNum && x.SubjectId == task.SubjectId).Select(x => x.Id).ToListAsync());
            }
          
          
            List<GetReadingImgOutDto> imgList = await _noneDicomStudyRepository.Where(x => visitIds.Contains(x.SubjectVisitId))
               .SelectMany(x => x.NoneDicomFileList).Select(x => new GetReadingImgOutDto()
               {
                   FileName = x.FileName,
                   Path = x.Path
               }).ToListAsync();
            return imgList;
        }

        /// <summary>
        /// 获取项目已确认的标准
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetTrialConfirmCriterionListOutDto>> GetTrialConfirmCriterionList(GetConfirmCriterionInDto inDto)
        {
            var result= await _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == inDto.TrialId&&x.IsConfirm&&x.IsCompleteConfig)
               .Select(x => new GetTrialConfirmCriterionListOutDto()
               {
                   ReadingQuestionCriterionTrialId = x.Id,
                   ReadingQuestionCriterionTrialName = x.CriterionName
               }).ToListAsync();
            return result;
        }

        /// <summary>
        /// 获取项目的阅片问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetTrialReadingQuestionOutDto>> GetTrialReadingQuestion(GetTrialReadingQuestionInDto inDto)
        {
            var qusetionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId).ToListAsync();

            List<GetTrialReadingQuestionOutDto> groupList = _mapper.Map<List<GetTrialReadingQuestionOutDto>>(qusetionList.Where(x => x.ParentId == null));
            groupList.ForEach(x =>
            {
                FindChildQuestion(x, qusetionList);
            });
            return groupList;
        }


        /// <summary>
        /// 找子问题
        /// </summary>
        /// <param name="trialReadingQuestion"></param>
        /// <param name="questionlists"></param>

        private void FindChildQuestion(GetTrialReadingQuestionOutDto trialReadingQuestion, List<ReadingQuestionTrial> questionlists)
        {
            trialReadingQuestion.Childrens = _mapper.Map<List<GetTrialReadingQuestionOutDto>>(questionlists.Where(x => x.ParentId == trialReadingQuestion.ReadingQuestionTrialId));
            if (trialReadingQuestion.Childrens != null && trialReadingQuestion.Childrens.Count != 0)
            {
                trialReadingQuestion.Childrens.ForEach(x =>
                {
                    FindChildQuestion(x, questionlists);
                });
            }
        }




        /// <summary>
        /// 提交问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [NonDynamicMethod]
        public async Task<IResponseOutput> SubmitVisitTaskQuestions(SubmitVisitTaskQuestionsInDto inDto)
        {
            var subjectId =await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.SubjectId).FirstOrDefaultAsync();
            List<ReadingTaskQuestionAnswer> readingTaskAnswerList = inDto.AnswerList.Select(x => new ReadingTaskQuestionAnswer()
            {
                Id = NewId.NextGuid(),
                SubjectId = subjectId,
                Answer = x.Answer,
                ReadingQuestionCriterionTrialId = inDto.ReadingQuestionCriterionTrialId,
                ReadingQuestionTrialId = x.ReadingQuestionTrialId,
                VisitTaskId = inDto.VisitTaskId,
                TrialId = inDto.TrialId
            }).ToList();
            await _readingTaskQuestionAnswerRepository.AddRangeAsync(readingTaskAnswerList);
            await _visitTaskRepository.UpdatePartialFromQueryAsync(x => x.Id == inDto.VisitTaskId, x => new VisitTask()
            {
                ReadingTaskState = ReadingTaskState.HaveSigned
            });
            var result = await _visitTaskRepository.SaveChangesAsync();
            return ResponseOutput.Ok(result);

        }





    }
}