using Shentun.Peis.Enums;
using Shentun.Peis.HelperDto;
using Shentun.Peis.Models;
using Shentun.Utilities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Domain.Services;

namespace Shentun.Peis.ReferenceRanges
{

    /// <summary>
    /// 参考范围
    /// </summary>
    public class ReferenceRangeManager : DomainService
    {
        private readonly IRepository<Item, Guid> _itemRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<ReferenceRange, Guid> _repository;
        public ReferenceRangeManager(
            IRepository<Item, Guid> itemRepository,
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<ReferenceRange, Guid> repository)
        {
            this._itemRepository = itemRepository;
            this._patientRegisterRepository = patientRegisterRepository;
            _repository = repository;
        }
        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public ReferenceRange CreateAsync(
          ReferenceRange entity
         )
        {
            Verify(entity);
            return new ReferenceRange
            {
                AgeLowerLimit = entity.AgeLowerLimit,
                AgeUpperLimit = entity.AgeUpperLimit,
                CriticalRangeValue = entity.CriticalRangeValue,
                ForSexId = entity.ForSexId,
                ItemId = entity.ItemId,
                LowerDiagnosisId = entity.LowerDiagnosisId,
                ReferenceRangeValue = entity.ReferenceRangeValue,
                UpperDiagnosisId = entity.UpperDiagnosisId,
                ReferenceRangeTypeFlag = entity.ReferenceRangeTypeFlag
            };
        }




        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="sourceEntity"></param>
        /// <param name="targetEntity"></param>
        /// <returns></returns>
        public void UpdateAsync(
           ReferenceRange sourceEntity,
           ReferenceRange targetEntity
          )
        {
            DataHelper.CheckEntityIsNull(targetEntity);
            Verify(sourceEntity);
            targetEntity.AgeLowerLimit = sourceEntity.AgeLowerLimit;
            targetEntity.AgeUpperLimit = sourceEntity.AgeUpperLimit;
            targetEntity.CriticalRangeValue = sourceEntity.CriticalRangeValue;
            targetEntity.ForSexId = sourceEntity.ForSexId;
            targetEntity.ItemId = sourceEntity.ItemId;
            targetEntity.LowerDiagnosisId = sourceEntity.LowerDiagnosisId;
            targetEntity.ReferenceRangeValue = sourceEntity.ReferenceRangeValue;
            targetEntity.UpperDiagnosisId = sourceEntity.UpperDiagnosisId;
            targetEntity.ReferenceRangeTypeFlag = sourceEntity.ReferenceRangeTypeFlag;
        }


        /// <summary>
        /// 更新 字符型
        /// </summary>
        /// <param name="sourceEntity"></param>
        /// <param name="targetEntity"></param>
        /// <returns></returns>
        public void UpdateTextAsync(
           ReferenceRange sourceEntity,
           ReferenceRange targetEntity
          )
        {
            DataHelper.CheckEntityIsNull(targetEntity);
            Verify(sourceEntity);
            targetEntity.ReferenceRangeValue = sourceEntity.ReferenceRangeValue;
            targetEntity.ReferenceRangeTypeFlag = sourceEntity.ReferenceRangeTypeFlag;
        }




        /// <summary>
        /// 验证新增、修改字段
        /// </summary>
        /// <param name="entity"></param>
        /// <exception cref="ArgumentException"></exception>
        private void Verify(ReferenceRange entity)
        {
            DataHelper.CheckEntityIsNull(entity);
            DataHelper.CheckGuidIsDefaultValue(entity.ItemId, "项目编号");
            if (entity.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.None
                && entity.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.Number
                && entity.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.Character
                && entity.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.SexHormone
                )
            {
                throw new ArgumentException($"参考范围类别参数为:{entity.ReferenceRangeTypeFlag},是无效值,只能为'{ItemReferenceRangeTypeFlag.None}','{ItemReferenceRangeTypeFlag.Number}','2{ItemReferenceRangeTypeFlag.Character}','{ItemReferenceRangeTypeFlag.SexHormone}'");
            }

            if (entity.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Character)
            {
                //字符型
                if (string.IsNullOrWhiteSpace(entity.ReferenceRangeValue))
                {
                    throw new ArgumentException("参考范围值不能为空");
                }

                entity.ForSexId = ForSexFlag.All;
                entity.AgeLowerLimit = 0;
                entity.AgeUpperLimit = 200;
            }
            else if (entity.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Number)
            {
                //数字型
                if (entity.ForSexId != ForSexFlag.All
              && entity.ForSexId != ForSexFlag.Male
              && entity.ForSexId != ForSexFlag.Female
              )
                {
                    throw new ArgumentException($"适用性别参数为:{entity.ForSexId},是无效值,只能为'{ForSexFlag.All}','{ForSexFlag.Male}','{ForSexFlag.Female}'");
                }
                if (entity.AgeLowerLimit < 0 || entity.AgeLowerLimit > 200)
                {
                    throw new ArgumentException($"年龄下限参数为:{entity.AgeLowerLimit},是无效值,值只能为0~200之间");
                }
                if (entity.AgeUpperLimit < 0 || entity.AgeUpperLimit > 200)
                {
                    throw new ArgumentException($"年龄上限参数为:{entity.AgeUpperLimit},是无效值,值只能为0~200之间");
                }
                if (entity.AgeLowerLimit > entity.AgeUpperLimit)
                {
                    throw new ArgumentException($"年龄下限不能大于上限值");
                }
            }
        }

        /// <summary>
        /// 获取项目的参考范围，根据登记信息的性别、年龄获取
        /// </summary>
        /// <param name="ItemId">项目ID</param>
        /// <param name="PatientRegisterId">登记表ID</param>
        /// <returns></returns>
        public async Task<ReferenceRange> GetReferenceRangeInSexAge(Guid ItemId, Guid PatientRegisterId)
        {
            var patientRegisterEntity = await _patientRegisterRepository.GetAsync(PatientRegisterId);
            var itemEntity = await _itemRepository.GetAsync(ItemId);
            var referenceRangeList = await _repository.GetListAsync(m => m.ReferenceRangeTypeFlag == itemEntity.ReferenceRangeTypeFlag);


            var SexId = patientRegisterEntity.SexId;
            var Age = patientRegisterEntity.Age;


            if (itemEntity.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Character)
            {
                //字符型

                //判断性别
                if (referenceRangeList.Where(m => m.ForSexId == 'A').Count() == 0)
                {
                    //没有全部类型
                    referenceRangeList = referenceRangeList.Where(m => m.ForSexId == patientRegisterEntity.SexId).ToList();
                }

                //判断年龄
                if (Age != null)
                {
                    referenceRangeList.Where(m => m.AgeLowerLimit <= Age && m.AgeUpperLimit >= Age).ToList();
                }

            }

            return referenceRangeList.FirstOrDefault();
        }




        /// <summary>
        /// 获取项目的参考范围，根据登记信息的性别、年龄获取
        /// </summary>
        /// <param name="ItemId">项目ID</param>
        /// <param name="PatientRegisterId">登记表ID</param>
        /// <returns></returns>
        public ReferenceRange GetReferenceRangeInSexAgeTemp(List<ReferenceRange> referenceRangeList, Item itemEntity, char? SexId, short? Age)
        {


            if (itemEntity != null && referenceRangeList.Any())
            {

                var referenceRangeListNew = referenceRangeList.Where(m => m.ReferenceRangeTypeFlag == itemEntity.ReferenceRangeTypeFlag && m.ItemId == itemEntity.Id);


                if (itemEntity.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Character)
                {
                    //字符型

                    //判断性别
                    if (referenceRangeListNew.Where(m => m.ForSexId == 'A').Count() == 0)
                    {
                        //没有全部类型
                        referenceRangeListNew = referenceRangeListNew.Where(m => m.ForSexId == SexId).ToList();
                    }

                    //判断年龄
                    if (Age != null)
                    {
                        referenceRangeListNew.Where(m => m.AgeLowerLimit <= Age && m.AgeUpperLimit >= Age).ToList();
                    }

                }

                return referenceRangeListNew.FirstOrDefault();


            }
            else
            {
                return null;
            }
        }

    }
}