using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using NPOI.SS.Formula.Functions;
using NPOI.Util;
using Shentun.Peis.ColumnReferenceCodes;
using Shentun.Peis.DiagnosisFunctions;
using Shentun.Peis.Enums;
using Shentun.Peis.Items;
using Shentun.Peis.LisRequests;
using Shentun.Peis.Models;
using Shentun.Peis.PatientRegisters;
using Shentun.Peis.PlugIns.ImportLisResults;
using Shentun.Peis.PlugIns.LisRequests;
using Shentun.Peis.ReferenceRanges;
using Shentun.Peis.RegisterCheckItems;
using Shentun.Peis.RegisterChecks;
using Shentun.Peis.SysParmValues;
using Shentun.Peis.Units;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Guids;
using Volo.Abp.Identity;
using Volo.Abp.Users;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace Shentun.Peis.ImportLisResults
{
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class ImportLisResultAppService : ApplicationService, IImportLisResultAppService
    {
        private readonly IRepository<ThirdInterface> _thirdInterfaceRepository;
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<ReferenceRange, Guid> _referenceRangeRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
        private readonly IRepository<LisRequest, Guid> _lisRequestRepository;
        private readonly IRepository<Item, Guid> _itemRepository;
        private readonly IRepository<RegisterCheckSummary, Guid> _registerCheckSummaryRepository;
        private readonly IRepository<RegisterCheckSuggestion, Guid> _registerCheckSuggestionRepository;
        private readonly IRepository<IdentityUser, Guid> _userRepository;
        private readonly IRepository<Unit, Guid> _unitRepository;
        private readonly RegisterCheckManager _registerCheckManager;
        private readonly RegisterCheckItemManager _registerCheckItemManager;
        private readonly CacheService _cacheService;
        private readonly IGuidGenerator _guidGenerator;
        private readonly IConfiguration _configuration;
        private readonly ICurrentUser _currentUser;
        private readonly IRepository<UserItemType> _userItemTypeRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly DiagnosisFunctionAppService _diagnosisFunctionAppService;
        private readonly ReferenceRangeManager _referenceRangeManager;
        private readonly ItemManager _itemManager;
        private readonly UnitManager _unitManager;
        private readonly RegisterCheckAppService _registerCheckAppService;
        private List<Unit> _units;
        private List<ReferenceRange> _referenceRanges;
        private static bool _isRunning = false;
        private static readonly object lockObject = new object();
        private readonly ColumnReferenceCodeManager _columnReferenceCodeManager;
        private readonly SysParmValueManager _sysParmValueManager;
        public ImportLisResultAppService(IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
             IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<ReferenceRange, Guid> referenceRangeRepository,
             IRepository<RegisterCheckSummary, Guid> registerCheckSummaryRepository,
            IRepository<RegisterCheckSuggestion, Guid> registerCheckSuggestionRepository,
            IRepository<IdentityUser, Guid> userRepository,
            RegisterCheckManager registerCheckManager,
            RegisterCheckItemManager registerCheckItemManager,
            CacheService cacheService,
            IGuidGenerator guidGenerator,
            IConfiguration configuration,
            ICurrentUser currentUser,
            IRepository<UserItemType> userItemTypeRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerCheckAsbitemRepository,
            IRepository<LisRequest, Guid> lisRequestRepository,
            IRepository<Unit, Guid> unitRepository,
             DiagnosisFunctionAppService diagnosisFunctionAppService,
             ReferenceRangeManager referenceRangeManager,
             IRepository<Item, Guid> itemRepository,
             ItemManager itemManager,
             UnitManager unitManager,
             RegisterCheckAppService registerCheckAppService,
             IRepository<ThirdInterface> thirdInterfaceRepository,
             ColumnReferenceCodeManager columnReferenceCodeManager,
             SysParmValueManager sysParmValueManager)
        {
            _registerCheckRepository = registerCheckRepository;
            _userRepository = userRepository;
            _registerCheckManager = registerCheckManager;
            _patientRegisterRepository = patientRegisterRepository;
            _referenceRangeRepository = referenceRangeRepository;
            _registerCheckItemRepository = registerCheckItemRepository;
            _registerCheckSummaryRepository = registerCheckSummaryRepository;
            _registerCheckSuggestionRepository = registerCheckSuggestionRepository;
            _registerCheckItemManager = registerCheckItemManager;
            _cacheService = cacheService;
            _guidGenerator = guidGenerator;
            _configuration = configuration;
            _currentUser = currentUser;
            _userItemTypeRepository = userItemTypeRepository;
            _asbitemRepository = asbitemRepository;
            _registerCheckAsbitemRepository = registerCheckAsbitemRepository;
            _lisRequestRepository = lisRequestRepository;
            _diagnosisFunctionAppService = diagnosisFunctionAppService;
            _referenceRangeManager = referenceRangeManager;
            _itemRepository = itemRepository;
            _itemManager = itemManager;
            _unitRepository = unitRepository;
            _units = _unitRepository.GetListAsync().Result;
            _unitManager = unitManager;
            _registerCheckAppService = registerCheckAppService;
            _thirdInterfaceRepository = thirdInterfaceRepository;
            _columnReferenceCodeManager = columnReferenceCodeManager;
            _sysParmValueManager = sysParmValueManager;
        }
        /// <summary>
        /// 从第三方接口导入结果
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/ImportLisResult/ImportResult")]
        public async Task ImportResultAsync(List<CreateImportLisResultDto> input)
        {
            //设置结果

            var list = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                        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 registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync()
                        on registerCheck.Id equals registerCheckItem.RegisterCheckId
                        join item in await _itemRepository.GetQueryableAsync()
                        on registerCheckItem.ItemId equals item.Id
                        join lisRequest in await _lisRequestRepository.GetQueryableAsync()
                        on registerCheckAsbitem.LisRequestId equals lisRequest.Id
                        where input.Select(o => o.LisRequestNo).ToList().Contains(lisRequest.LisRequestNo)
                        select new
                        {
                            patientRegister,
                            registerCheck,
                            registerCheckAsbitem,
                            registerCheckItem,
                            item,
                            lisRequest,
                        }).ToList();

            var lisRequestNos = input.Select(o => o.LisRequestNo).Distinct().ToList();
            var registerChecks = new List<RegisterCheck>();
            _referenceRanges = _referenceRangeRepository.GetListAsync().Result;

            input = input.Where(o => !string.IsNullOrWhiteSpace(o.Result)
                                     && !string.IsNullOrWhiteSpace(o.LisRequestNo)
                                     && o.ItemId != Guid.Empty).ToList();

            foreach (var inputItem in input)
            {
                if (string.IsNullOrWhiteSpace(inputItem.CheckDoctorName))
                {
                    throw new UserFriendlyException("检查医生不能为空");
                }
                var lisRequestItems = list.Where(o => o.lisRequest.LisRequestNo == inputItem.LisRequestNo
                             && o.registerCheckItem.ItemId == inputItem.ItemId).ToList();
                foreach (var lisRequestItem in lisRequestItems)
                {
                    if (lisRequestItem == null)
                    {
                        continue;
                    }
                    lisRequestItem.registerCheckItem.Result = inputItem.Result;
                    //var itemSource = new RegisterCheckItem()
                    //{
                    //    Result = inputItem.Result,
                    //    ReferenceRangeValue = inputItem.ReferenceRangeValue,
                    //    Unit = inputItem.Unit,
                    //    CriticalRangeValue = inputItem.CriticalRangeValue
                    //};

                    //项目如果是性激素参考范围,不更新
                    if (lisRequestItem.item.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.SexHormone)
                    {
                        //修改参考范围
                        await UpdateItemReferenceRangeValueAsync(inputItem.ItemId, lisRequestItem.patientRegister.SexId,
                            lisRequestItem.patientRegister.Age, inputItem.ReferenceRangeValue, inputItem.CriticalRangeValue);
                    }
                    //修改单位
                    await UpdateItemUnitAsync(inputItem.ItemId, inputItem.Unit);

                    //await _registerCheckItemManager.UpdateRegisterCheckItemAsync(itemSource, lisRequestItem.registerCheckItem);
                    //await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem,true);
                    if (!registerChecks.Where(o => o.Id == lisRequestItem.registerCheck.Id).ToList().Any())
                    {
                        lisRequestItem.registerCheck.CheckDoctorId = inputItem.CheckDoctorName;
                        lisRequestItem.registerCheck.CheckDate = inputItem.CheckDate;
                        lisRequestItem.registerCheck.ExecOrganizationUnitId = inputItem.ExecOrganizationUnitId;
                        lisRequestItem.registerCheck.AuditorName = inputItem.AuditorName;
                        lisRequestItem.registerCheck.LisSampleNo = inputItem.LisSampleNo;
                        lisRequestItem.registerCheck.AuditorTime = inputItem.AuditorTime;
                        lisRequestItem.registerCheck.SubmissionTime = inputItem.SubmissionTime;
                        registerChecks.Add(lisRequestItem.registerCheck);
                    }
                }


            }

            List<RegisterCheckAsbitem> updateRegisterCheckAsbitem = new List<RegisterCheckAsbitem>();

            //更新参考范围和单位
            foreach (var registerCheck in registerChecks)
            {
                var lisRequestItems = list.Where(o => o.registerCheck.Id == registerCheck.Id).ToList();
                foreach (var lisRequestItem in lisRequestItems)
                {
                    var referenceRange = _referenceRangeManager.GetReferenceRangeBySexAgeTemp(_referenceRanges,
                        lisRequestItem.item, lisRequestItem.patientRegister.SexId, lisRequestItem.patientRegister.Age, lisRequestItem.patientRegister.SexHormoneTermId);
                    if (referenceRange != null)
                    {
                        lisRequestItem.registerCheckItem.ReferenceRangeValue = referenceRange.ReferenceRangeValue;
                        lisRequestItem.registerCheckItem.CriticalRangeValue = referenceRange.CriticalRangeValue;
                    }
                    else
                    {
                        lisRequestItem.registerCheckItem.ReferenceRangeValue = "";
                        lisRequestItem.registerCheckItem.CriticalRangeValue = "";
                    }
                    var unit = _units.Where(o => o.Id == lisRequestItem.item.UnitId).FirstOrDefault();
                    if (unit != null)
                    {
                        lisRequestItem.registerCheckItem.Unit = unit.DisplayName;
                    }
                    else
                    {
                        lisRequestItem.registerCheckItem.Unit = "";
                    }
                    await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem);
                }

            }
            await CurrentUnitOfWork.SaveChangesAsync();
            //保存结果

            foreach (var registerCheck in registerChecks)
            {
                var updateCheckResultDto = new UpdateCheckResultDto()
                {
                    RegisterCheckId = registerCheck.Id,
                    CheckDoctorId = registerCheck.CheckDoctorId,
                    CheckDate = registerCheck.CheckDate,
                    ExecOrganizationUnitId = registerCheck.ExecOrganizationUnitId,
                    RegisterCheckItems = list.Where(o => o.registerCheck.Id == registerCheck.Id)
                    .Select(o => new UpdateRegisterCheckItemDetail()
                    {
                        ItemId = o.registerCheckItem.ItemId,
                        Result = o.registerCheckItem.Result,

                    }).ToList(),
                    LisSampleNo = registerCheck.LisSampleNo,
                    AuditorName = registerCheck.AuditorName,
                    AuditorTime = registerCheck.AuditorTime,
                    SubmissionTime = registerCheck.SubmissionTime
                };

                var getDiagnosisResultRequestDto = new GetDiagnosisResultRequestDto()
                {
                    RegisterCheckId = registerCheck.Id,
                    Items = list.Where(o => o.registerCheck.Id == registerCheck.Id)
                    .Select(o => new GetDiagnosisResultRequest_Item()
                    {
                        ItemId = o.registerCheckItem.ItemId,
                        Result = o.registerCheckItem.Result,
                    }).ToList()
                };
                //生成小结
                var summarry = await _diagnosisFunctionAppService.GetDoctorCheckDiagnosisResultAsync(getDiagnosisResultRequestDto);

                for (var i = 0; i < summarry.DiagnosisResultDetails.Count; i++)
                {
                    updateCheckResultDto.Summarys.Add(new UpdateRegisterCheckSummaryDetail()
                    {
                        Summary = summarry.DiagnosisResultDetails[i].DiagnosisResult,
                        SummaryFlag = '0'
                    });
                }

                await _registerCheckAppService.UpdateCheckResult(updateCheckResultDto);
            }

        }
        /// <summary>
        /// 导入某个人的结果
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ImportLisResult/ImportResultByPatientRegisterId")]
        public async Task ImportResultByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {
            var patientRegister = await _patientRegisterRepository.GetAsync(input.PatientRegisterId);
            var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o =>
            o.ThirdInterfaceType == ThirdInterfaceTypeFlag.ImportLisResult
            && o.MedicalCenterId == patientRegister.MedicalCenterId
            && o.IsActive == 'Y');
            foreach (var thirdInterface in thirdInterfaces)
            {
                var parmValue = thirdInterface.ParmValue;
                var configurationBuilder = new ConfigurationBuilder()
                   .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
                var config = configurationBuilder.Build();
                var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
                var className = config.GetSection("Interface").GetSection("ClassName").Value;
                object[] objects = new object[] { input.PatientRegisterId };
                var pluginsOut = await Utilities.ReflectionHelper.InvokeAsync<ImportLisResultPlugInsOut>(assemblyName,
                    className, [thirdInterface.Id], "ImportResultByPatientRegisterIdAsync", objects);

            }
        }


        /// <summary>
        /// 导入迪安、艾迪康结果 外检
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/ImportLisResult/ImportDianResultByPatientRegisterId")]
        public async Task ImportDianResultByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {
            var patientRegister = await _patientRegisterRepository.GetAsync(input.PatientRegisterId);
            var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o =>
            o.ThirdInterfaceType == ThirdInterfaceTypeFlag.OutSend
            && o.MedicalCenterId == patientRegister.MedicalCenterId
            && o.IsActive == 'Y');
            foreach (var thirdInterface in thirdInterfaces)
            {
                var parmValue = thirdInterface.ParmValue;
                var configurationBuilder = new ConfigurationBuilder()
                   .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
                var config = configurationBuilder.Build();
                var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
                var className = config.GetSection("Interface").GetSection("ClassName").Value;
                object[] objects = new object[] { input.PatientRegisterId };

                var pluginsOut = await Utilities.ReflectionHelper.InvokeAsync<ImportLisResultPlugInsOut>(assemblyName,
                    className, [thirdInterface.Id], "ImportOueSendResultByPatientRegisterIdAsync", objects);

            }
        }


        /// <summary>
        /// 根据lis传过来的参考范围更新体检系统的值
        /// </summary>
        /// <param name="itemId"></param>
        /// <param name="sexId"></param>
        /// <param name="age"></param>
        /// <param name="referenceRangeValue"></param>
        /// <param name="criticalRangeValue"></param>
        /// <returns></returns>
        private async Task UpdateItemReferenceRangeValueAsync(Guid itemId, char sexId, int? age, string referenceRangeValue, string criticalRangeValue)
        {
            var referenceRanges = _referenceRanges.Where(o => o.ItemId == itemId).ToList();
            if (age == null) age = 30;
            if (string.IsNullOrWhiteSpace(referenceRangeValue))
            {
                return;
            }
            var item = await _itemRepository.GetAsync(itemId);
            ReferenceRange referenceRange = null;
            if (_referenceRangeManager.IsNumberReferenceRange(referenceRangeValue))
            {
                //数字型
                item.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number;
                await _itemRepository.UpdateAsync(item);

                referenceRange = referenceRanges.Where(o => o.ForSexId == sexId
                && age >= o.AgeLowerLimit && age <= o.AgeUpperLimit
                && o.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Number).FirstOrDefault();
                if (referenceRange != null)
                {
                    referenceRange.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number;
                    referenceRange.ReferenceRangeValue = referenceRangeValue;
                    if (!string.IsNullOrWhiteSpace(criticalRangeValue))
                    {
                        referenceRange.CriticalRangeValue = criticalRangeValue;
                        referenceRange.FollowUpRangeValue = criticalRangeValue;
                    }
                    await _referenceRangeRepository.UpdateAsync(referenceRange);
                    return;
                }

                referenceRange = referenceRanges.Where(o => o.ForSexId == ForSexFlag.All
                 && age >= o.AgeLowerLimit && age <= o.AgeUpperLimit
                 && o.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Number).FirstOrDefault();
                if (referenceRange != null)
                {
                    referenceRange.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number;
                    referenceRange.ReferenceRangeValue = referenceRangeValue;
                    if (!string.IsNullOrWhiteSpace(criticalRangeValue))
                    {
                        referenceRange.CriticalRangeValue = criticalRangeValue;
                        referenceRange.FollowUpRangeValue = criticalRangeValue;
                    }
                    await _referenceRangeRepository.UpdateAsync(referenceRange);
                    return;
                }
                referenceRange = new ReferenceRange()
                {
                    ItemId = itemId,
                    AgeLowerLimit = 0,
                    AgeUpperLimit = 200,
                    ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number,
                    ReferenceRangeValue = referenceRangeValue,
                    CriticalRangeValue = criticalRangeValue,
                    ForSexId = ForSexFlag.All
                };
                referenceRange = _referenceRangeManager.Create(referenceRange);
                await _referenceRangeRepository.InsertAsync(referenceRange);
                referenceRanges.Add(referenceRange);
                return;
            }

            item.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Character;
            await _itemRepository.UpdateAsync(item);
            referenceRange = referenceRanges.Where(o => o.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Character).FirstOrDefault();
            if (referenceRange != null)
            {
                referenceRange.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Character;
                referenceRange.ReferenceRangeValue = referenceRangeValue;
                await _referenceRangeRepository.UpdateAsync(referenceRange);
                return;
            }

            referenceRange = new ReferenceRange()
            {
                ItemId = itemId,
                AgeLowerLimit = 0,
                AgeUpperLimit = 200,
                ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Character,
                ReferenceRangeValue = referenceRangeValue,
                ForSexId = ForSexFlag.All
            };
            referenceRange = _referenceRangeManager.Create(referenceRange);
            await _referenceRangeRepository.InsertAsync(referenceRange);
            referenceRanges.Add(referenceRange);
            return;
        }

        private async Task UpdateItemUnitAsync(Guid itemId, string unitName)
        {
            if (string.IsNullOrWhiteSpace(unitName))
            {
                return;
            }
            unitName = unitName.Trim();
            var item = await _itemRepository.GetAsync(itemId);
            var unit = _units.Where(o => o.DisplayName.Trim().ToLower() == unitName.ToLower()).FirstOrDefault();
            if (unit != null)
            {
                if (item.UnitId == unit.Id)
                {
                    return;
                }
                item.UnitId = unit.Id;
                await _itemRepository.UpdateAsync(item);
                return;
            }
            unit = new Unit()
            {
                DisplayName = unitName,

            };
            unit = await _unitManager.CreateAsync(unit);
            await _unitRepository.InsertAsync(unit);
            _units.Add(unit);
        }


        #region 蓝豚lis结果导入
        /// <summary>
        ///  根据lis检验单号导入结果
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/ImportLisResult/ImportResultByLisRequestNo")]
        public async Task ImportResultByLisRequestNoAsync(List<ImportResultByLisRequestNoInputDto> input)
        {
            if (!input.Any())
                throw new UserFriendlyException("请求参数无效");


            var thirdInterface = await _thirdInterfaceRepository.FirstOrDefaultAsync(o => o.ThirdInterfaceType == ThirdInterfaceTypeFlag.ImportLisResult);
            if (thirdInterface == null)
                throw new UserFriendlyException($"未配置检验导入的参数");

            var parmValue = thirdInterface.ParmValue;
            var configurationBuilder = new ConfigurationBuilder()
               .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
            var config = configurationBuilder.Build();
            Guid execOrganizationUnitId = Guid.Parse(config.GetSection("Interface").GetSection("ExecOrganizationUnitId").Value);
            Guid columnReferenId = Guid.Parse(config.GetSection("Interface").GetSection("ColumnReferenId").Value);
            Guid userColumnReferenId = Guid.Parse(config.GetSection("Interface").GetSection("UserColumnReferenId").Value);

            List<CreateImportLisResultDto> inputDtoList = new List<CreateImportLisResultDto>();

            foreach (var item in input)
            {
                var codeValues = await _columnReferenceCodeManager.GetColumnReferenCodeValueAsync(columnReferenId, item.ItemId);
                if (!codeValues.Any())
                {
                    throw new UserFriendlyException($"项目编号:{item.ItemId}没有对照");
                }

                //转换检查医生ID
                var checkDoctorUserId = (await _columnReferenceCodeManager.GetColumnReferenCodeValueAsync(userColumnReferenId, item.CheckDoctorName)).FirstOrDefault();
                if (!string.IsNullOrWhiteSpace(checkDoctorUserId))
                {
                    item.CheckDoctorName = checkDoctorUserId;
                }

                //转换审核医生ID
                var lisAuditorDoctorUserId = (await _columnReferenceCodeManager.GetColumnReferenCodeValueAsync(userColumnReferenId, item.AuditorName)).FirstOrDefault();
                if (!string.IsNullOrWhiteSpace(lisAuditorDoctorUserId))
                {
                    item.AuditorName = lisAuditorDoctorUserId;
                }

                foreach (var codeValue in codeValues)
                {
                    Guid itemId = Guid.Parse(codeValue);
                    var inputDto = new CreateImportLisResultDto
                    {
                        CheckDate = item.CheckDate,
                        CheckDoctorName = item.CheckDoctorName,
                        CriticalRangeValue = item.CriticalRangeValue,
                        CriticalValue = item.CriticalValue,
                        ExecOrganizationUnitId = execOrganizationUnitId,
                        ItemId = itemId,
                        ItemName = item.ItemName,
                        LisRequestNo = item.LisRequestNo,
                        ReferenceRangeValue = item.ReferenceRangeValue,
                        ReportPrompt = "",
                        ResultStatusId = null,
                        Result = item.Result,
                        Unit = item.Unit,
                        AuditorName = item.AuditorName,
                        LisSampleNo = item.LisSampleNo,
                        AuditorTime = item.AuditorTime,
                        SubmissionTime = item.SubmissionTime
                    };
                    inputDtoList.Add(inputDto);
                }


            }

            var lisRequestNoPrintMode = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "lis_request_no_print_mode");
            if (string.IsNullOrWhiteSpace(lisRequestNoPrintMode))
                lisRequestNoPrintMode = "0";

            if (lisRequestNoPrintMode == "0")
                await ImportResultAsync(inputDtoList);
            else
                await ImportResultByPatientRegisterNoAsync(inputDtoList);
        }

        /// <summary>
        /// 从第三方接口导入结果
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        private async Task ImportResultByPatientRegisterNoAsync(List<CreateImportLisResultDto> input)
        {
            //设置结果

            var list = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                        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 registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync()
                        on registerCheck.Id equals registerCheckItem.RegisterCheckId
                        join item in await _itemRepository.GetQueryableAsync()
                        on registerCheckItem.ItemId equals item.Id
                        join lisRequest in await _lisRequestRepository.GetQueryableAsync()
                        on registerCheckAsbitem.LisRequestId equals lisRequest.Id
                        where input.Select(o => o.LisRequestNo).FirstOrDefault() == patientRegister.PatientRegisterNo
                        select new
                        {
                            patientRegister,
                            registerCheck,
                            registerCheckAsbitem,
                            registerCheckItem,
                            item,
                            lisRequest,
                        }).ToList();


            var registerChecks = new List<RegisterCheck>();
            _referenceRanges = _referenceRangeRepository.GetListAsync().Result;

            input = input.Where(o => !string.IsNullOrWhiteSpace(o.Result)
                                     && !string.IsNullOrWhiteSpace(o.LisRequestNo)
                                     && o.ItemId != Guid.Empty).ToList();

            foreach (var inputItem in input)
            {
                if (string.IsNullOrWhiteSpace(inputItem.CheckDoctorName))
                {
                    throw new UserFriendlyException("检查医生不能为空");
                }
                var lisRequestItems = list.Where(o => o.patientRegister.PatientRegisterNo == inputItem.LisRequestNo
                             && o.registerCheckItem.ItemId == inputItem.ItemId).ToList();
                foreach (var lisRequestItem in lisRequestItems)
                {
                    if (lisRequestItem == null)
                    {
                        continue;
                    }
                    lisRequestItem.registerCheckItem.Result = inputItem.Result;
                    //var itemSource = new RegisterCheckItem()
                    //{
                    //    Result = inputItem.Result,
                    //    ReferenceRangeValue = inputItem.ReferenceRangeValue,
                    //    Unit = inputItem.Unit,
                    //    CriticalRangeValue = inputItem.CriticalRangeValue
                    //};
                    if (lisRequestItem.item.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.SexHormone)
                    {
                        //修改参考范围
                        await UpdateItemReferenceRangeValueAsync(inputItem.ItemId, lisRequestItem.patientRegister.SexId,
                        lisRequestItem.patientRegister.Age, inputItem.ReferenceRangeValue, inputItem.CriticalRangeValue);
                    }
                    //修改单位
                    await UpdateItemUnitAsync(inputItem.ItemId, inputItem.Unit);

                    //await _registerCheckItemManager.UpdateRegisterCheckItemAsync(itemSource, lisRequestItem.registerCheckItem);
                    //await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem,true);
                    if (!registerChecks.Where(o => o.Id == lisRequestItem.registerCheck.Id).ToList().Any())
                    {
                        lisRequestItem.registerCheck.CheckDoctorId = inputItem.CheckDoctorName;
                        lisRequestItem.registerCheck.CheckDate = inputItem.CheckDate;
                        lisRequestItem.registerCheck.ExecOrganizationUnitId = inputItem.ExecOrganizationUnitId;
                        lisRequestItem.registerCheck.AuditorName = inputItem.AuditorName;
                        lisRequestItem.registerCheck.LisSampleNo = inputItem.LisSampleNo;
                        lisRequestItem.registerCheck.SubmissionTime = inputItem.SubmissionTime;
                        lisRequestItem.registerCheck.AuditorTime = inputItem.AuditorTime;
                        registerChecks.Add(lisRequestItem.registerCheck);
                    }
                }


            }

            List<RegisterCheckAsbitem> updateRegisterCheckAsbitem = new List<RegisterCheckAsbitem>();

            //更新参考范围和单位
            foreach (var registerCheck in registerChecks)
            {
                var lisRequestItems = list.Where(o => o.registerCheck.Id == registerCheck.Id).ToList();
                foreach (var lisRequestItem in lisRequestItems)
                {
                    var referenceRange = _referenceRangeManager.GetReferenceRangeBySexAgeTemp(_referenceRanges,
                        lisRequestItem.item, lisRequestItem.patientRegister.SexId, lisRequestItem.patientRegister.Age, lisRequestItem.patientRegister.SexHormoneTermId);
                    if (referenceRange != null)
                    {
                        lisRequestItem.registerCheckItem.ReferenceRangeValue = referenceRange.ReferenceRangeValue;
                        lisRequestItem.registerCheckItem.CriticalRangeValue = referenceRange.CriticalRangeValue;
                    }
                    else
                    {
                        lisRequestItem.registerCheckItem.ReferenceRangeValue = "";
                        lisRequestItem.registerCheckItem.CriticalRangeValue = "";
                    }
                    var unit = _units.Where(o => o.Id == lisRequestItem.item.UnitId).FirstOrDefault();
                    if (unit != null)
                    {
                        lisRequestItem.registerCheckItem.Unit = unit.DisplayName;
                    }
                    else
                    {
                        lisRequestItem.registerCheckItem.Unit = "";
                    }
                    await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem);
                }

            }
            await CurrentUnitOfWork.SaveChangesAsync();
            //保存结果

            foreach (var registerCheck in registerChecks)
            {
                var updateCheckResultDto = new UpdateCheckResultDto()
                {
                    RegisterCheckId = registerCheck.Id,
                    CheckDoctorId = registerCheck.CheckDoctorId,
                    CheckDate = registerCheck.CheckDate,
                    ExecOrganizationUnitId = registerCheck.ExecOrganizationUnitId,
                    RegisterCheckItems = list.Where(o => o.registerCheck.Id == registerCheck.Id)
                    .Select(o => new UpdateRegisterCheckItemDetail()
                    {
                        ItemId = o.registerCheckItem.ItemId,
                        Result = o.registerCheckItem.Result,

                    }).ToList(),
                    LisSampleNo = registerCheck.LisSampleNo,
                    AuditorName = registerCheck.AuditorName,
                    AuditorTime = registerCheck.AuditorTime,
                    SubmissionTime = registerCheck.SubmissionTime
                };

                var getDiagnosisResultRequestDto = new GetDiagnosisResultRequestDto()
                {
                    RegisterCheckId = registerCheck.Id,
                    Items = list.Where(o => o.registerCheck.Id == registerCheck.Id)
                    .Select(o => new GetDiagnosisResultRequest_Item()
                    {
                        ItemId = o.registerCheckItem.ItemId,
                        Result = o.registerCheckItem.Result,
                    }).ToList()
                };
                //生成小结
                var summarry = await _diagnosisFunctionAppService.GetDoctorCheckDiagnosisResultAsync(getDiagnosisResultRequestDto);

                for (var i = 0; i < summarry.DiagnosisResultDetails.Count; i++)
                {
                    updateCheckResultDto.Summarys.Add(new UpdateRegisterCheckSummaryDetail()
                    {
                        Summary = summarry.DiagnosisResultDetails[i].DiagnosisResult,
                        SummaryFlag = '0'
                    });
                }

                await _registerCheckAppService.UpdateCheckResult(updateCheckResultDto);
            }

        }
        #endregion

        #region 批量导入lis结果   需要单独对照

        /// <summary>
        /// 按excel批量导入检验结果
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/ImportLisResult/ImportResultExcelByLisRequestNo")]
        public async Task ImportResultExcelByLisRequestNoAsync(ImportResultExcelByLisRequestNoInputDto input)
        {
            List<CreateImportLisResultDto> inputDtoList = new List<CreateImportLisResultDto>();

            //对照主表Id
            var columnReferenceId = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "import_file_lis_result");
            if (string.IsNullOrWhiteSpace(columnReferenceId))
                throw new UserFriendlyException("未找到对照主表Id，请到系统参数配置");
            foreach (var item in input.Details)
            {
                var codeValues = await _columnReferenceCodeManager.GetColumnReferenCodeValueAsync(Guid.Parse(columnReferenceId), item.ItemName);
                if (!codeValues.Any())
                {
                    throw new UserFriendlyException($"项目名称:{item.ItemName}没有对照");
                }


                foreach (var codeValue in codeValues)
                {
                    Guid itemId = Guid.Parse(codeValue);
                    var inputDto = new CreateImportLisResultDto
                    {
                        CheckDate = string.IsNullOrWhiteSpace(item.CheckDate) ? null : Convert.ToDateTime(item.CheckDate),
                        CheckDoctorName = item.CheckDoctorName,
                        CriticalRangeValue = "",
                        CriticalValue = "",
                        ExecOrganizationUnitId = Guid.Empty,
                        ItemId = itemId,
                        ItemName = item.ItemName,
                        LisRequestNo = input.BarCode,
                        ReferenceRangeValue = "",
                        ReportPrompt = "",
                        ResultStatusId = null,
                        Result = item.ItemResult,
                        Unit = "",
                        AuditorName = "",
                        LisSampleNo = input.SampleNo
                    };
                    inputDtoList.Add(inputDto);
                }


            }

            if (input.BarcodeMode == '0')
            {
                if (await _patientRegisterRepository.CountAsync(f => f.PatientRegisterNo == input.BarCode) == 0)
                    throw new UserFriendlyException($"条码号{input.BarCode}不正确");
                await ImportResultByPatientRegisterNoAsync(inputDtoList);
            }
            else if (input.BarcodeMode == '1')
            {
                var isBarCode = await (from registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
                                       join lisRequest in await _lisRequestRepository.GetQueryableAsync() on registerCheckAsbitem.LisRequestId equals lisRequest.Id
                                       where lisRequest.LisRequestNo == input.BarCode
                                       select lisRequest.LisRequestNo).CountAsync();
                if (isBarCode == 0)
                    throw new UserFriendlyException($"条码号{input.BarCode}不正确");
                await ImportResultAsync(inputDtoList);
            }
        }

        #endregion
    }
}