using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Shentun.Peis.Enums;
using Shentun.Peis.GuideTypes;
using Shentun.Peis.Models;
using Shentun.Peis.ReferenceRanges;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TencentCloud.Ame.V20190916.Models;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Identity;
using Volo.Abp.ObjectMapping;
using Volo.Abp.Users;

namespace Shentun.Peis.RegisterCheckItems
{
    /// <summary>
    /// 检查明细项目记录
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class RegisterCheckItemAppService : ApplicationService
    {
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<ReferenceRange, Guid> _referenceRangeRepository;
        private readonly IRepository<IdentityUser, Guid> _userRepository;
        private readonly IRepository<Unit, Guid> _unitRepository;
        private readonly RegisterCheckItemManager _registerCheckItemManager;
        private readonly ReferenceRangeManager _referenceRangeManager;
        private readonly CacheService _cacheService;
        public RegisterCheckItemAppService(
            IRepository<RegisterCheckItem> registerCheckItemRepository,
               IRepository<IdentityUser, Guid> userRepository,
               RegisterCheckItemManager registerCheckItemManager,
               ReferenceRangeManager referenceRangeManager,
               IRepository<PatientRegister, Guid> patientRegisterRepository,
               IRepository<ReferenceRange, Guid> referenceRangeRepository,
               IRepository<Unit, Guid> unitRepository,
               CacheService cacheService)
        {
            this._registerCheckItemRepository = registerCheckItemRepository;
            this._userRepository = userRepository;
            this._registerCheckItemManager = registerCheckItemManager;
            this._referenceRangeManager = referenceRangeManager;
            this._patientRegisterRepository = patientRegisterRepository;
            this._referenceRangeRepository = referenceRangeRepository;
            _unitRepository = unitRepository;
            _cacheService = cacheService;
        }

        /// <summary>
        /// 获取检查明细项目记录 附带项目名称跟项目结果模板的集合
        /// </summary>
        /// <returns></returns>
        [HttpGet("api/app/registercheckitem/getlistinregistercheckid")]
        public async Task<List<RegisterCheckItemOrItemOrItemResultTemplateDto>> GetListInRegisterCheckIdAsync(Guid RegisterCheckId, Guid PatientRegisterId)
        {


            var entlist = (await _registerCheckItemRepository.GetQueryableAsync())
                .Include(x => x.Item)
                .Include(x => x.Item.ItemResultTemplates)
                .Include(x => x.Item.ItemType)
                .Include(x => x.RegisterCheck)
                .Where(m => m.RegisterCheckId == RegisterCheckId);



            #region 未检查的项目重新更新参考范围、危警值


            var PatientRegisterEnt = await _patientRegisterRepository.GetAsync(PatientRegisterId);

            var referenceRangeList = await _referenceRangeRepository.GetListAsync();

            List<RegisterCheckItem> update_list = new List<RegisterCheckItem>();
            var units = await _unitRepository.GetListAsync();
            foreach (var ent in entlist)
            {
                if (ent.RegisterCheck.CompleteFlag == RegisterCheckCompleteFlag.UnChecked)
                {

                    var referenceRangeEnt = _referenceRangeManager.GetReferenceRangeInSexAgeTemp(referenceRangeList,
                              ent.Item,
                              PatientRegisterEnt.SexId,
                              PatientRegisterEnt.Age);

                    if (referenceRangeEnt != null)
                    {
                        ent.ReferenceRangeValue = referenceRangeEnt.ReferenceRangeValue;
                        ent.CriticalRangeValue = referenceRangeEnt.CriticalRangeValue;
                    }
                    var unit = units.Where(o => o.Id == ent.Item.UnitId).FirstOrDefault();
                    if (unit != null)
                    {
                        ent.Unit = unit.DisplayName;
                    }
                   
                    update_list.Add(ent);
                }
            }

            if (update_list.Any())
            {
                await _registerCheckItemRepository.UpdateManyAsync(update_list, true);
            }



            #endregion




           
            var entdto = entlist.Select(s => new RegisterCheckItemOrItemOrItemResultTemplateDto
            {

                CheckDate = DataHelper.ConversionDateToString(s.CheckDate),
                CheckDoctorName = s.CheckDoctorName,
                CriticalRangeValue = s.CriticalRangeValue,
                CriticalValue = s.CriticalValue,
                ItemId = s.ItemId,
                IsCalculationItem = s.Item.IsCalculationItem,
                ItemName = s.Item.DisplayName,
                itemResultTemplates = s.Item.ItemResultTemplates.Select(si => new ItemResultTemplates.ItemResultTemplateDropDto
                {
                    DiagnosisId = si.DiagnosisId,
                    IsNameIntoSummary = si.IsNameIntoSummary,
                    IsResultIntoSummary = si.IsResultIntoSummary,
                    ItemId = si.ItemId,
                    Result = si.Result,
                    ResultStatusId = si.ResultStatusId,
                    SimpleCode = si.SimpleCode
                }).ToList(),
                ReferenceRangeValue = s.ReferenceRangeValue,
                ReferenceRangeTypeFlag = s.Item.ReferenceRangeTypeFlag,
                RegisterCheckId = RegisterCheckId,
                Result = string.IsNullOrEmpty(s.Result) && s.RegisterCheck.CompleteFlag == RegisterCheckCompleteFlag.UnChecked ? s.Item.DefaultResult : s.Result,
                ResultStatusId = s.ResultStatusId,
                Unit = s.Unit,
                LineModeFlag = s.Item.LineModeFlag == '2' ? (s.Item.ItemType.IsWrap == 'N' ? '0' : '1') : s.Item.LineModeFlag,
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                LastModificationTime = s.LastModificationTime,
                LastModifierId = s.LastModifierId,
                CreatorName = _cacheService.GetUserNameAsync(s.CreatorId).Result,
                LastModifierName = _cacheService.GetUserNameAsync(s.LastModifierId).Result,
                InputCheck = s.Item.InputCheck
            }).ToList();

            return entdto;
        }


        ///// <summary>
        ///// 修改结果内容
        ///// </summary>
        ///// <param name="RegisterCheckId">RegisterCheck表ID</param>
        ///// <param name="ItemId">项目ID</param>
        ///// <param name="input"></param>
        ///// <returns></returns>
        //[HttpPost("api/app/registercheckitem/updateresult")]
        //public async Task<RegisterCheckItemDto> UpdateResultAsync(Guid RegisterCheckId, Guid ItemId, UpdateRegisterCheckItemResultDto input)
        //{
        //    var ent = await _registerCheckItemRepository.GetAsync(m => m.RegisterCheckId == RegisterCheckId && m.ItemId == ItemId);
        //    ent.Result = input.Result;
        //    ent.CheckDoctorName = input.CheckDoctorName;
        //    ent.CriticalValue = input.CriticalValue;
        //    ent.CheckDate = PageHelper.ConvertDate(input.CheckDate);
        //    var entnew = await _registerCheckItemRepository.UpdateAsync(ent);
        //    return ObjectMapper.Map<RegisterCheckItem, RegisterCheckItemDto>(entnew);
        //}


        /// <summary>
        /// 批量修改检查明细项目记录
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/registercheckitem/updateregistercheckitemmany")]
        public async Task<List<RegisterCheckItemDto>> UpdateRegisterCheckItemManyAsync(List<UpdateRegisterCheckItemManyDto> input)
        {
            throw new Exception("禁止");
            if (!input.Any())
            {
                throw new UserFriendlyException("请求参数有误");
            }

            List<RegisterCheckItemDto> msg = new List<RegisterCheckItemDto>();

            foreach (var item in input)
            {
                var entity = await _registerCheckItemRepository.GetAsync(m => m.RegisterCheckId == item.RegisterCheckId && m.ItemId == item.ItemId);
                var entitydto = ObjectMapper.Map<UpdateRegisterCheckItemManyDto, RegisterCheckItem>(item);
                var newentity = await _registerCheckItemManager.UpdateRegisterCheckItemAsync(entitydto, entity);
                msg.Add(ObjectMapper.Map<RegisterCheckItem, RegisterCheckItemDto>(newentity));
            }
            return msg;
        }


        /// <summary>
        /// 删除检查明细项目记录
        /// </summary>
        /// <param name="RegisterCheckId"></param>
        /// <param name="ItemId"></param>
        /// <returns></returns>
        [HttpPost("api/app/registercheckitem/deleteregistercheckitem")]
        public async Task DeleteRegisterCheckItemAsync(Guid RegisterCheckId, Guid ItemId)
        {
            //  await _registerCheckItemRepository.DeleteAsync(m => m.RegisterCheckId == RegisterCheckId && m.ItemId == ItemId);

            await _registerCheckItemManager.CheckAndDeleteAsync(RegisterCheckId, ItemId);
        }

    }
}