using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Shentun.Peis.Enums;
using Shentun.Peis.Models;
using Shentun.Peis.OcCheckTypes;
using Shentun.Peis.PatientOccupationalDiseases;
using Shentun.Peis.PatientRegisters;
using Shentun.Peis.SumSummaryReports;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Identity;
using Volo.Abp.ObjectMapping;

namespace Shentun.Peis.OccupationalDiseases
{
    /// <summary>
    /// 职业病业务
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class OccupationalDiseaseAppService : ApplicationService
    {
        private readonly IRepository<PatientOccupationalDisease, Guid> _patientOccupationalDiseaseRepository;
        private readonly IRepository<PatientOccupationalHistory, Guid> _patientOccupationalHistoryRepository;
        private readonly IRepository<PatientPoison> _patientPoisonRepository;
        private readonly IRepository<PatientSymptom> _patientSymptomRepository;
        private readonly IRepository<PatientOccupationalMedicalHistory, Guid> _patientOccupationalMedicalHistoryRepository;
        private readonly PatientOccupationalDiseaseManager _patientOccupationalDiseaseManager;
        private readonly CacheService _cacheService;




        private readonly IRepository<Patient, Guid> _patientRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<IdentityUser, Guid> _identityUserRepository;
        private readonly IRepository<ItemType, Guid> _itemTypeRepository;
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<Item, Guid> _itemRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
        private readonly IRepository<ResultStatus> _resultStatusRepository;
        private readonly IRepository<RegisterCheckSummary, Guid> _registerCheckSummaryRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;





        public OccupationalDiseaseAppService(
            IRepository<PatientOccupationalDisease, Guid> patientOccupationalDiseaseRepository,
            IRepository<PatientOccupationalHistory, Guid> patientOccupationalHistoryRepository,
            IRepository<PatientPoison> patientPoisonRepository,
            IRepository<PatientSymptom> patientSymptomRepository,
            PatientOccupationalDiseaseManager patientOccupationalDiseaseManager,
            CacheService cacheService,
            IRepository<Patient, Guid> patientRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<IdentityUser, Guid> identityUserRepository,
            IRepository<ItemType, Guid> itemTypeRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
            IRepository<Item, Guid> itemRepository,
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerCheckAsbitemRepository,
            IRepository<ResultStatus> resultStatusRepository,
            IRepository<RegisterCheckSummary, Guid> registerCheckSummaryRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<PatientOccupationalMedicalHistory, Guid> patientOccupationalMedicalHistoryRepository)
        {
            _patientOccupationalDiseaseRepository = patientOccupationalDiseaseRepository;
            _patientOccupationalHistoryRepository = patientOccupationalHistoryRepository;
            _patientPoisonRepository = patientPoisonRepository;
            _patientSymptomRepository = patientSymptomRepository;
            _patientOccupationalDiseaseManager = patientOccupationalDiseaseManager;
            _cacheService = cacheService;
            _patientRepository = patientRepository;
            _registerCheckRepository = registerCheckRepository;
            _identityUserRepository = identityUserRepository;
            _itemTypeRepository = itemTypeRepository;
            _registerCheckItemRepository = registerCheckItemRepository;
            _itemRepository = itemRepository;
            _patientRegisterRepository = patientRegisterRepository;
            _registerCheckAsbitemRepository = registerCheckAsbitemRepository;
            _resultStatusRepository = resultStatusRepository;
            _registerCheckSummaryRepository = registerCheckSummaryRepository;
            _asbitemRepository = asbitemRepository;
            _patientOccupationalMedicalHistoryRepository = patientOccupationalMedicalHistoryRepository;
        }

        /// <summary>
        /// 创建职业病信息
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/OccupationalDisease/CreateOccupationalDiseaseWithDetail")]
        public async Task<OccupationalDiseaseWithDetailByPatientRegisterIdDto> CreateOccupationalDiseaseWithDetailAsync(OccupationalDiseaseWithDetailInputDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            if (input.PatientRegisterId == Guid.Empty)
                throw new UserFriendlyException("人员ID不正确");

            #region 基础信息
            if (input.PatientOccupationalDisease == null)
                throw new UserFriendlyException("职业病基础信息有误");

            var patientOccupationalDiseaseInput = ObjectMapper.Map<PatientOccupationalDiseaseInputDto, PatientOccupationalDisease>(input.PatientOccupationalDisease);

            patientOccupationalDiseaseInput.PatientRegisterId = input.PatientRegisterId;

            var patientOccupationalDiseaseEnt = await _patientOccupationalDiseaseRepository.FirstOrDefaultAsync(f => f.PatientRegisterId == input.PatientRegisterId);
            if (patientOccupationalDiseaseEnt == null)
            {

                var entity = _patientOccupationalDiseaseManager.CreateAsync(patientOccupationalDiseaseInput);
                await _patientOccupationalDiseaseRepository.InsertAsync(entity, true);
            }
            else
            {
                _patientOccupationalDiseaseManager.UpdateAsync(patientOccupationalDiseaseInput, patientOccupationalDiseaseEnt);
                await _patientOccupationalDiseaseRepository.UpdateAsync(patientOccupationalDiseaseEnt, true);
            }
            #endregion

            #region 毒害因素

            var patientPoisonsInput = ObjectMapper.Map<List<PatientPoisonInputDto>, List<PatientPoison>>(input.PatientPoisons);
            await _patientPoisonRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);
            List<PatientPoison> patientPoisonList = new List<PatientPoison>();
            foreach (var item in patientPoisonsInput)
            {
                patientPoisonList.Add(new PatientPoison
                {
                    PatientRegisterId = input.PatientRegisterId,
                    PoisonId = item.PoisonId
                });
            }

            await _patientPoisonRepository.InsertManyAsync(patientPoisonList, true);
            #endregion

            #region 症状

            var patientSymptomsInput = ObjectMapper.Map<List<PatientSymptomInputDto>, List<PatientSymptom>>(input.PatientSymptoms);
            await _patientSymptomRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);
            List<PatientSymptom> patientSymptomList = new List<PatientSymptom>();
            foreach (var item in patientSymptomsInput)
            {
                patientSymptomList.Add(new PatientSymptom
                {
                    PatientRegisterId = input.PatientRegisterId,
                    Degree = item.Degree,
                    SymptomId = item.SymptomId,
                    TimeLength = item.TimeLength
                });
            }

            await _patientSymptomRepository.InsertManyAsync(patientSymptomList, true);

            #endregion

            #region 职业病史

            var patientOccupationalMedicalHistorysInput = ObjectMapper.Map<List<PatientOccupationalMedicalHistoryInputDto>, List<PatientOccupationalMedicalHistory>>(input.PatientOccupationalMedicalHistorys);
            await _patientOccupationalMedicalHistoryRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);
            List<PatientOccupationalMedicalHistory> patientOccupationalMedicalHistoryList = new List<PatientOccupationalMedicalHistory>();
            foreach (var item in patientOccupationalMedicalHistorysInput)
            {
                patientOccupationalMedicalHistoryList.Add(new PatientOccupationalMedicalHistory
                {
                    PatientRegisterId = input.PatientRegisterId,
                    DiagnosisDate = item.DiagnosisDate,
                    DiagnosisHospital = item.DiagnosisHospital,
                    IsRecovery = item.IsRecovery,
                    OccupationalDisease = item.OccupationalDisease,
                    TreatmentMethods = item.TreatmentMethods
                });
            }

            await _patientOccupationalMedicalHistoryRepository.InsertManyAsync(patientOccupationalMedicalHistoryList, true);

            #endregion


            #region 职业史

            var patientOccupationalHistorysInput = ObjectMapper.Map<List<PatientOccupationalHistoryInputDto>, List<PatientOccupationalHistory>>(input.PatientOccupationalHistorys);
            await _patientOccupationalHistoryRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);
            List<PatientOccupationalHistory> patientOccupationalHistoryList = new List<PatientOccupationalHistory>();
            foreach (var item in patientOccupationalHistorysInput)
            {
                patientOccupationalHistoryList.Add(new PatientOccupationalHistory
                {
                    PatientRegisterId = input.PatientRegisterId,
                    BeginDate = item.BeginDate,
                    EndDate = item.EndDate,
                    Org = item.Org,
                    Poison = item.Poison,
                    ProtectiveMeasures = item.ProtectiveMeasures,
                    WorkShop = item.WorkShop,
                    WorkType = item.WorkType
                });
            }

            await _patientOccupationalHistoryRepository.InsertManyAsync(patientOccupationalHistoryList, true);

            #endregion

            return await GetOccupationalDiseaseWithDetailByPatientRegisterIdAsync(new PatientRegisterIdInputDto
            {
                PatientRegisterId = input.PatientRegisterId
            });
        }


        /// <summary>
        /// 获取职业病信息 根据人员登记ID
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/OccupationalDisease/GetOccupationalDiseaseWithDetailByPatientRegisterId")]
        public async Task<OccupationalDiseaseWithDetailByPatientRegisterIdDto> GetOccupationalDiseaseWithDetailByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            if (input.PatientRegisterId == Guid.Empty)
                throw new UserFriendlyException("人员ID不正确");

            var result = new OccupationalDiseaseWithDetailByPatientRegisterIdDto();

            #region 基础信息

            var patientOccupationalDiseaseEnt = await _patientOccupationalDiseaseRepository.FirstOrDefaultAsync(f => f.PatientRegisterId == input.PatientRegisterId);
            if (patientOccupationalDiseaseEnt != null)
            {
                result.PatientOccupationalDisease = new PatientOccupationalDiseaseDto
                {
                    AbnormalTimes = patientOccupationalDiseaseEnt.AbnormalTimes,
                    AbortionTimes = patientOccupationalDiseaseEnt.AbortionTimes,
                    ChildrenNum = patientOccupationalDiseaseEnt.ChildrenNum,
                    CreationTime = patientOccupationalDiseaseEnt.CreationTime,
                    CreatorId = patientOccupationalDiseaseEnt.CreatorId,
                    DrinkFlag = patientOccupationalDiseaseEnt.DrinkFlag,
                    DrinkNum = patientOccupationalDiseaseEnt.DrinkNum,
                    DrinkYears = patientOccupationalDiseaseEnt.DrinkYears,
                    FirstMenstruation = patientOccupationalDiseaseEnt.FirstMenstruation,
                    HandleSuggestion = patientOccupationalDiseaseEnt.HandleSuggestion,
                    Id = patientOccupationalDiseaseEnt.Id,
                    JobType = patientOccupationalDiseaseEnt.JobType,
                    LastMenstrualPeriodDate = patientOccupationalDiseaseEnt.LastMenstrualPeriodDate,
                    LastModificationTime = patientOccupationalDiseaseEnt.LastModificationTime,
                    LastModifierId = patientOccupationalDiseaseEnt.LastModifierId,
                    MenstruationCycle = patientOccupationalDiseaseEnt.MenstruationCycle,
                    MenstruationEndAge = patientOccupationalDiseaseEnt.MenstruationEndAge,
                    MenstruationFlag = patientOccupationalDiseaseEnt.MenstruationFlag,
                    MenstruationTimeLength = patientOccupationalDiseaseEnt.MenstruationTimeLength,
                    NoOccupAbSuggestion = patientOccupationalDiseaseEnt.NoOccupAbSuggestion,
                    NoOccupationalAbnormal = patientOccupationalDiseaseEnt.NoOccupationalAbnormal,
                    OcCheckTypeId = patientOccupationalDiseaseEnt.OcCheckTypeId,
                    OccupationalAbnormal = patientOccupationalDiseaseEnt.OccupationalAbnormal,
                    OccupationalAbSuggestion = patientOccupationalDiseaseEnt.OccupationalAbSuggestion,
                    Other = patientOccupationalDiseaseEnt.Other,
                    PoisonWorkTime = patientOccupationalDiseaseEnt.PoisonWorkTime,
                    PrematureBirthTimes = patientOccupationalDiseaseEnt.PrematureBirthTimes,
                    PreviousHistory = patientOccupationalDiseaseEnt.PreviousHistory,
                    SmokeFlag = patientOccupationalDiseaseEnt.SmokeFlag,
                    SmokeNum = patientOccupationalDiseaseEnt.SmokeNum,
                    SmokeYears = patientOccupationalDiseaseEnt.SmokeYears,
                    StillbirthTimes = patientOccupationalDiseaseEnt.StillbirthTimes,
                    TotalWorkTime = patientOccupationalDiseaseEnt.TotalWorkTime,
                    CreatorName = _cacheService.GetSurnameAsync(patientOccupationalDiseaseEnt.CreatorId).Result,
                    LastModifierName = _cacheService.GetSurnameAsync(patientOccupationalDiseaseEnt.LastModifierId).Result
                };
            }

            #endregion

            #region 毒害因素

            List<PatientPoisonDto> patientPoisonDtos = new List<PatientPoisonDto>();
            var patientPoisonList = await _patientPoisonRepository.GetListAsync(d => d.PatientRegisterId == input.PatientRegisterId);

            patientPoisonDtos = patientPoisonList.Select(s => new PatientPoisonDto
            {
                PoisonId = s.PoisonId,
                SuspectedOccupationalDiseaseId = s.SuspectedOccupationalDiseaseId,
                OccupationalContraindicationsId = s.OccupationalContraindicationsId,
                OccupationalAbnormalId = s.OccupationalAbnormalId,
                OtherDiseases = s.OtherDiseases,
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                LastModificationTime = s.LastModificationTime,
                LastModifierId = s.LastModifierId,
                CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).Result
            }).ToList();

            result.PatientPoisonDtos = patientPoisonDtos;

            #endregion

            #region 职业病史

            List<PatientOccupationalMedicalHistoryDto> patientOccupationalMedicalHistoryDtos = new List<PatientOccupationalMedicalHistoryDto>();
            var patientOccupationalMedicalHistoryList = await _patientOccupationalMedicalHistoryRepository.GetListAsync(d => d.PatientRegisterId == input.PatientRegisterId);

            patientOccupationalMedicalHistoryDtos = patientOccupationalMedicalHistoryList.Select(s => new PatientOccupationalMedicalHistoryDto
            {
                DiagnosisDate = s.DiagnosisDate,
                DiagnosisHospital = s.DiagnosisHospital,
                Id = s.Id,
                IsRecovery = s.IsRecovery,
                OccupationalDisease = s.OccupationalDisease,
                TreatmentMethods = s.TreatmentMethods,
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                LastModificationTime = s.LastModificationTime,
                LastModifierId = s.LastModifierId,
                CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).Result
            }).ToList();

            result.PatientOccupationalMedicalHistoryDtos = patientOccupationalMedicalHistoryDtos;

            #endregion

            #region 症状

            var patientSymptomList = await _patientSymptomRepository.GetListAsync(m => m.PatientRegisterId == input.PatientRegisterId);

            List<PatientSymptomDto> patientSymptomDtos = patientSymptomList.Select(s => new PatientSymptomDto
            {
                Degree = s.Degree,
                SymptomId = s.SymptomId,
                TimeLength = s.TimeLength,
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                LastModificationTime = s.LastModificationTime,
                LastModifierId = s.LastModifierId,
                CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).Result
            }).ToList();

            result.PatientSymptomDtos = patientSymptomDtos;

            #endregion

            #region 职业史


            var patientOccupationalHistoryList = await _patientOccupationalHistoryRepository.GetListAsync(d => d.PatientRegisterId == input.PatientRegisterId);

            List<PatientOccupationalHistoryDto> patientOccupationalHistoryDtos = patientOccupationalHistoryList.Select(s => new PatientOccupationalHistoryDto
            {
                BeginDate = s.BeginDate,
                EndDate = s.EndDate,
                Org = s.Org,
                Poison = s.Poison,
                ProtectiveMeasures = s.ProtectiveMeasures,
                WorkShop = s.WorkShop,
                WorkType = s.WorkType,
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                Id = s.Id,
                LastModifierId = s.LastModifierId,
                LastModificationTime = s.LastModificationTime,
                CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).Result
            }).ToList();

            result.PatientOccupationalHistoryDtos = patientOccupationalHistoryDtos;

            #endregion


            return result;
        }


        /// <summary>
        /// 修改检查结论
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/OccupationalDisease/UpdateOccupationalDiseaseInspectionConclusion")]
        public async Task UpdateOccupationalDiseaseInspectionConclusionAsync(OccupationalDiseaseInspectionConclusionInputDto input)
        {
            var patientOccupationalDiseaseEnt = await _patientOccupationalDiseaseRepository.FirstOrDefaultAsync(F => F.PatientRegisterId == input.PatientRegisterId);
            if (patientOccupationalDiseaseEnt == null)
            {
                throw new UserFriendlyException("请先登记职业病信息");
            }

            patientOccupationalDiseaseEnt.NoOccupAbSuggestion = input.NoOccupAbSuggestion;
            patientOccupationalDiseaseEnt.NoOccupationalAbnormal = input.NoOccupationalAbnormal;
            patientOccupationalDiseaseEnt.OccupationalAbnormal = input.OccupationalAbnormal;
            patientOccupationalDiseaseEnt.OccupationalAbSuggestion = input.OccupationalAbSuggestion;
            patientOccupationalDiseaseEnt.HandleSuggestion = input.HandleSuggestion;

            await _patientOccupationalDiseaseRepository.UpdateAsync(patientOccupationalDiseaseEnt);
        }



        /// <summary>
        /// 获取检查结论
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/OccupationalDisease/GetOccupationalDiseaseInspectionConclusion")]
        public async Task<OccupationalDiseaseInspectionConclusionDto> GetOccupationalDiseaseInspectionConclusionAsync(PatientRegisterIdInputDto input)
        {
            var patientOccupationalDiseaseEnt = await _patientOccupationalDiseaseRepository.FirstOrDefaultAsync(F => F.PatientRegisterId == input.PatientRegisterId);
            if (patientOccupationalDiseaseEnt == null)
            {
                throw new UserFriendlyException("暂无职业病信息");
            }

            var entDto = new OccupationalDiseaseInspectionConclusionDto
            {
                HandleSuggestion = patientOccupationalDiseaseEnt.HandleSuggestion,
                NoOccupAbSuggestion = patientOccupationalDiseaseEnt.NoOccupAbSuggestion,
                NoOccupationalAbnormal = patientOccupationalDiseaseEnt.NoOccupationalAbnormal,
                OccupationalAbnormal = patientOccupationalDiseaseEnt.OccupationalAbnormal,
                OccupationalAbSuggestion = patientOccupationalDiseaseEnt.OccupationalAbSuggestion
            };

            return entDto;
        }




        /// <summary>
        /// 获取体征结果
        /// </summary>
        /// <param name="input">人员登记ID</param>
        /// <returns></returns>
        [HttpPost("api/app/OccupationalDisease/GetDetailResults")]
        public async Task<List<SumSummaryReportDetailResultDto>> GetDetailResultsAsync(PatientRegisterIdInputDto input)
        {
            List<SumSummaryReportDetailResultDto> msg = new List<SumSummaryReportDetailResultDto>();

            var userlist = await _identityUserRepository.GetListAsync();
            var resultStatus = await _resultStatusRepository.GetListAsync();
            var list = (from patient in await _patientRepository.GetQueryableAsync()
                        join patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                        on patient.Id equals patientRegister.PatientId
                        join registerCheck in await _registerCheckRepository.GetQueryableAsync()
                        on patientRegister.Id equals registerCheck.PatientRegisterId
                        join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
                        on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                        join registerCheckSummary in await _registerCheckSummaryRepository.GetQueryableAsync()
                        on registerCheck.Id equals registerCheckSummary.RegisterCheckId
                        join asbitem in await _asbitemRepository.GetQueryableAsync()
                        on registerCheckAsbitem.AsbitemId equals asbitem.Id
                        join registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync()
                        on registerCheck.Id equals registerCheckItem.RegisterCheckId
                        join item in await _itemRepository.GetQueryableAsync()
                        on registerCheckItem.ItemId equals item.Id
                        join itemType in await _itemTypeRepository.GetQueryableAsync()
                        on asbitem.ItemTypeId equals itemType.Id
                        where patientRegister.Id == input.PatientRegisterId
                         && registerCheck.CompleteFlag == RegisterCheckCompleteFlag.Checked
                         && asbitem.IsCheck == 'Y'
                        select new
                        {
                            patient,
                            patientRegister,
                            registerCheck,
                            registerCheckSummary,
                            registerCheckAsbitem,
                            asbitem,
                            registerCheckItem,
                            item,
                            itemType

                        }).AsNoTracking().ToList();

            if (!list.Any())
            {
                return null;
            }

            //将子项目类别设置为父项目类别
            var itemTypes = await _itemTypeRepository.GetListAsync();
            foreach (var listItem in list)
            {
                var parentItemType = itemTypes.Where(o => o.Id == listItem.itemType.ParentId).FirstOrDefault();
                if (parentItemType != null)
                {
                    listItem.asbitem.DisplayOrder = listItem.itemType.DisplayOrder * 1000 + listItem.asbitem.DisplayOrder;
                    listItem.itemType.DisplayName = parentItemType.DisplayName;
                    listItem.itemType.DisplayOrder = parentItemType.DisplayOrder;

                }
            }
            var detailedResultsList_Asbitems = new List<SumSummaryReportDetailResultWithAsbitem>();
            var registerCheckIds = list.OrderBy(o => o.itemType.DisplayOrder)
                .OrderBy(o => o.asbitem.DisplayOrder)
                .Select(o => o.registerCheck.Id).Distinct().ToList();
            foreach (var registerCheckId in registerCheckIds)
            {
                var listItem = list.Where(o => o.registerCheck.Id == registerCheckId).First();
                var detailedResultsList_Asbitem = new SumSummaryReportDetailResultWithAsbitem()
                {

                    ItemTypeName = listItem.itemType.DisplayName,
                    AsbitemNames = string.Join(",", list.Where(o => o.registerCheck.Id == registerCheckId)
                            .OrderBy(o => o.itemType.DisplayOrder).OrderBy(o => o.asbitem.DisplayOrder)
                            .Select(o => o.asbitem.DisplayName).Distinct().ToList()),
                    ItemTypeDisplayOrder = listItem.itemType.DisplayOrder,
                    AsbitemDisplayOrder = listItem.asbitem.DisplayOrder,
                    CheckDate = ((DateTime)listItem.registerCheck.CheckDate).Date,
                    CheckDoctorName = EntityHelper.GetCheckDoctorName(listItem.registerCheck.CheckDoctorId, userlist),
                    Items = list.Where(o => o.registerCheck.Id == registerCheckId)
                    .OrderBy(o => o.itemType.DisplayOrder)
                    .OrderBy(o => o.asbitem.DisplayOrder)
                    .OrderBy(o => o.item.DisplayOrder)
                    .GroupBy(o => o.registerCheckItem.ItemId)
                    .Select(o => new SumSummaryReportDetailResultWithItem()
                    {
                        ItemId = o.FirstOrDefault().registerCheckItem.ItemId,
                        ItemName = o.FirstOrDefault().item.DisplayName,
                        ItemResult = o.FirstOrDefault().registerCheckItem.Result,
                        ReferenceRangeValue = o.FirstOrDefault().registerCheckItem.ReferenceRangeValue,
                        CriticalRangeValue = o.FirstOrDefault().registerCheckItem.CriticalRangeValue,
                        Unit = o.FirstOrDefault().registerCheckItem.Unit,
                        ResultStatusId = o.FirstOrDefault().registerCheckItem.ResultStatusId,
                        ResultStatusName = (resultStatus.Where(x => x.Id == o.FirstOrDefault().registerCheckItem.ResultStatusId).FirstOrDefault() == null) ? "" : resultStatus.Where(x => x.Id == o.FirstOrDefault().registerCheckItem.ResultStatusId).FirstOrDefault().ReportPrompt,
                        ReportFontColor = (resultStatus.Where(x => x.Id == o.FirstOrDefault().registerCheckItem.ResultStatusId).FirstOrDefault() == null) ? 0 : resultStatus.Where(x => x.Id == o.FirstOrDefault().registerCheckItem.ResultStatusId).FirstOrDefault().ReportFontColor,
                        ReportBackgroundColor = (resultStatus.Where(x => x.Id == o.FirstOrDefault().registerCheckItem.ResultStatusId).FirstOrDefault() == null) ? 16777215 : resultStatus.Where(x => x.Id == o.FirstOrDefault().registerCheckItem.ResultStatusId).FirstOrDefault().ReportBackgroundColor,
                    }).ToList(),
                    Summarys = list.Where(o => o.registerCheck.Id == registerCheckId)
                               .OrderBy(o => o.registerCheckSummary.DisplayOrder)
                               .GroupBy(o => o.registerCheckSummary.Summary)
                               .Select(o => new SumSummaryReportDetailResultWithSummary()
                               {
                                   Summary = o.FirstOrDefault().registerCheckSummary.Summary
                               })
                                  .ToList<SumSummaryReportDetailResultWithSummary>(),

                };
                detailedResultsList_Asbitem.Summarys = detailedResultsList_Asbitem.Summarys.Distinct().ToList();



                detailedResultsList_Asbitems.Add(detailedResultsList_Asbitem);

            }

            var grouplist = detailedResultsList_Asbitems.OrderBy(o => o.ItemTypeDisplayOrder)
                .OrderBy(o => o.AsbitemDisplayOrder)
                .GroupBy(g => g.ItemTypeName);

            foreach (var g in grouplist)
            {
                var glist = g.OrderBy(o => o.ItemTypeDisplayOrder).OrderBy(o => o.AsbitemDisplayOrder).ToList();
                var resultlist = new SumSummaryReportDetailResultDto
                {
                    ItemTypeDisplayOrder = glist.FirstOrDefault().ItemTypeDisplayOrder,
                    ItemTypeName = glist.FirstOrDefault().ItemTypeName,
                    Asbitems = glist
                };

                msg.Add(resultlist);
            }
            msg = msg.OrderBy(o => o.ItemTypeDisplayOrder).ToList();
            return msg;
        }


        /// <summary>
        /// 删除职业病相关信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/OccupationalDisease/DeleteOccupationalDiseaseWithDetail")]
        public async Task DeleteOccupationalDiseaseWithDetailAsync(PatientRegisterIdInputDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            if (input.PatientRegisterId == Guid.Empty)
                throw new UserFriendlyException("人员ID不正确");

            await _patientOccupationalDiseaseRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);

            await _patientOccupationalHistoryRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);

            await _patientPoisonRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);

            await _patientOccupationalMedicalHistoryRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);

            await _patientSymptomRepository.DeleteAsync(d => d.PatientRegisterId == input.PatientRegisterId);


        }

    }
}