using AutoMapper;
using AutoMapper.QueryableExtensions;
using IRaCIS.Application.ExpressionExtend;
using IRaCIS.Application.Interfaces;
using IRaCIS.Application.ViewModels;
using IRaCIS.Core.Application.Contracts.RequestAndResponse;
using IRaCIS.Core.Domain.Interfaces;
using IRaCIS.Core.Domain.Models;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Infra.Data.ExpressionExtend;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace IRaCIS.Application.Services
{
    public class TrialWorkloadService : ITrialWorkloadService
    {
        private readonly ITrialRepository _trialRepository;
        private readonly IEnrollRepository _enrollRepository;
        private readonly IDoctorRepository _doctorRepository;
        private readonly IWorkloadRepository _doctorWorkloadRepository;
        private readonly IAttachmentRepository _attachmentRepository;
        private readonly IPaymentRepository _costStatisticsRepository;
        private readonly ITrialRevenuesPriceRepository _trialRevenuesPriceRepository;
        private readonly ITrialRevenuesPriceVerificationRepository _trialRevenuesPriceVerificationRepository;
        private readonly IMapper _mapper;

        public TrialWorkloadService(ITrialRepository clinicalTrialProjectRepository,
            IEnrollRepository intoGroupRepository,
            IDoctorRepository doctorInfoRepository,
            IWorkloadRepository doctorWorkloadRepository,
            IAttachmentRepository attachmentRepository,
            IPaymentRepository costStatisticsRepository,
            ITrialRevenuesPriceRepository trialRevenuesPriceRepository,
            ITrialRevenuesPriceVerificationRepository trialRevenuesPriceVerificationRepository,
            IMapper mapper)
        {
            _trialRepository = clinicalTrialProjectRepository;
            _enrollRepository = intoGroupRepository;
            _doctorRepository = doctorInfoRepository;
            _doctorWorkloadRepository = doctorWorkloadRepository;
            _attachmentRepository = attachmentRepository;
            _costStatisticsRepository = costStatisticsRepository;
            _trialRevenuesPriceRepository = trialRevenuesPriceRepository;
            _trialRevenuesPriceVerificationRepository = trialRevenuesPriceVerificationRepository;
            _mapper = mapper;
        }

        #region 入组工作量统计列表  具体详情   增删改查相关  上传\删除协议
        /// <summary>
        /// 上传入组后的Ack-SOW
        /// </summary>
        public IResponseOutput UploadReviewerAckSOW(Guid userId, Guid trialId,
            ReviewerAckDTO attachmentViewModel)
        {

            var intoGroupItem = _enrollRepository.GetAll().FirstOrDefault(t => t.TrialId == trialId && t.DoctorId == attachmentViewModel.DoctorId);

            if (intoGroupItem != null)
            {

                if (attachmentViewModel.Id != Guid.Empty)
                {
                    _attachmentRepository.Delete(t => t.Id == attachmentViewModel.Id);
                }

                var attach = _mapper.Map<Attachment>(attachmentViewModel);
                var attachment = _attachmentRepository.Add(attach);

                intoGroupItem.AttachmentId = attachment.Id;
                _enrollRepository.Update(intoGroupItem);


                var success = _enrollRepository.SaveChanges();

                return ResponseOutput.Result(success, attachment.Id.ToString());


            }

            return ResponseOutput.NotOk("Database cannot find enroment data");

        }

        /// <summary>
        /// 删除Ack-SOW
        /// </summary>
        public IResponseOutput DeleteReviewerAckSOW(Guid trialId, Guid doctorId, Guid attachmentId)
        {
            var success1 = _attachmentRepository.Delete(a => a.Id == attachmentId);
            var success2 = _enrollRepository.Update(t => t.TrialId == trialId && t.DoctorId == doctorId, u =>
               new Enroll()
               {
                   AttachmentId = Guid.Empty
               });
            return ResponseOutput.Result(success1 && success2);
        }

        public IResponseOutput UpdateReviewerReadingType(Guid trialId, Guid doctorId, int type)
        {
            var success2 = _enrollRepository.Update(t => t.TrialId == trialId && t.DoctorId == doctorId, u =>
                new Enroll()
                {
                    ReviewerReadingType = type
                });
            return ResponseOutput.Result(success2);
        }

        /// <summary> 
        /// 获取某个项目入组的医生工作量统计列表
        /// </summary>
        public PageOutput<WorkLoadAndAgreementDTO> GetTrialEnrollmentWorkloadStats(WorkLoadDoctorQueryDTO doctorSearchModel)
        {
            //https://blog.csdn.net/sunshineblog/article/details/78636389

            var trialId = doctorSearchModel.TrialId;
            Expression<Func<Enroll, bool>> intoGroupLambda = x => x.TrialId == trialId && x.EnrollStatus >= (int)EnrollStatus.ConfirmIntoGroup;

            Expression<Func<Workload, bool>> workloadLambda = t => t.TrialId == trialId && t.DataFrom == (int)WorkLoadFromStatus.FinalConfirm;

            var doctorIntoGroupQueryable =

                from intoGroup in _enrollRepository.GetAll().Where(intoGroupLambda)
                join doctor in _doctorRepository.GetAll() on intoGroup.DoctorId equals doctor.Id
                join attachmentItem in _attachmentRepository.GetAll() on intoGroup.AttachmentId equals attachmentItem.Id into cc
                from attachment in cc.DefaultIfEmpty()
                join doctorWorkLoad in _doctorWorkloadRepository.GetAll().Where(workloadLambda).GroupBy(t => t.DoctorId).Select(
                    g => new
                    {
                        DoctorId = g.Key,

                        Training = g.Sum(t => t.Training),
                        Downtime = g.Sum(t => t.Downtime),
                        Timepoint = g.Sum(t => t.Timepoint),
                        TimepointIn24H = g.Sum(t => t.TimepointIn24H),
                        TimepointIn48H = g.Sum(t => t.TimepointIn48H),
                        Global = g.Sum(t => t.Global),
                        Adjudication = g.Sum(t => t.Adjudication),
                        AdjudicationIn24H = g.Sum(t => t.AdjudicationIn24H),
                        AdjudicationIn48H = g.Sum(t => t.AdjudicationIn48H),
                        RefresherTraining= g.Sum(t => t.RefresherTraining)
                    }

                ) on intoGroup.DoctorId equals doctorWorkLoad.DoctorId into tt //连接为了得到入组时间
                from doctorWorkLoad in tt.DefaultIfEmpty()//不是每个医生都有工作量          

                select new WorkLoadAndAgreementDTO()
                {

                    DoctorId = doctor.Id,
                    Code = doctor.Code,
                    FirstName = doctor.FirstName,
                    LastName = doctor.LastName,
                    ChineseName = doctor.ChineseName,

                    EnrollTime = intoGroup.EnrollTime,
                    AgreementId = intoGroup.AttachmentId,
                    ReviewerReadingType = intoGroup.ReviewerReadingType,
                    AgreementPath = attachment.Path,

                    Timepoint = doctorWorkLoad.Timepoint,
                    TimepointIn24H = doctorWorkLoad.TimepointIn24H,
                    TimepointIn48H = doctorWorkLoad.TimepointIn48H,

                    Adjudication = doctorWorkLoad.Adjudication,
                    AdjudicationIn24H = doctorWorkLoad.AdjudicationIn24H,
                    AdjudicationIn48H = doctorWorkLoad.AdjudicationIn48H,

                    Global = doctorWorkLoad.Global,

                    RefresherTraining= doctorWorkLoad.RefresherTraining,
                    TrainingTimes = doctorWorkLoad.Training,
                    Downtime = doctorWorkLoad.Downtime

                };

            var count = doctorIntoGroupQueryable.Count();
            if (string.IsNullOrWhiteSpace(doctorSearchModel.SortField))
            {
                doctorIntoGroupQueryable = doctorIntoGroupQueryable.OrderByDescending("EnrollTime").ThenBy(u => u.Code);
            }
            else
            {
                if (doctorSearchModel.SortField == "FirstName" || doctorSearchModel.SortField == "LastName")
                {
                    if (doctorSearchModel.Asc)
                    {
                        doctorIntoGroupQueryable = doctorIntoGroupQueryable.OrderBy("LastName").ThenBy(u => u.FirstName);
                    }
                    else
                    {
                        doctorIntoGroupQueryable = doctorIntoGroupQueryable.OrderByDescending("LastName").ThenByDescending(u => u.FirstName);
                    }
                }
                else
                {
                    var propName = doctorSearchModel.SortField == "" ? "EnrollTime" : doctorSearchModel.SortField;
                    doctorIntoGroupQueryable = doctorSearchModel.Asc
                        ? doctorIntoGroupQueryable.OrderBy(propName)
                        : doctorIntoGroupQueryable.OrderByDescending(propName);
                }
            }
            //分页
            doctorIntoGroupQueryable = doctorIntoGroupQueryable
                .Skip((doctorSearchModel.PageIndex - 1) * doctorSearchModel.PageSize)
                .Take(doctorSearchModel.PageSize);
            //从数据库提取数据
            var intoGroupList = doctorIntoGroupQueryable.ToList();

            return new PageOutput<WorkLoadAndAgreementDTO>(doctorSearchModel.PageIndex,
                         doctorSearchModel.PageSize, count, intoGroupList);

        }

        /// <summary>
        /// 获取入组某个项目的医生的最近几个月的工作量详情（带有填充数据）
        /// </summary>
        public PageOutput<WorkLoadDetailDTO> GetEnrollmentWorkloadStatsDetail(WorkLoadStatsQueryDTO workLoadSearch)
        {
            #region 条件查询
            Expression<Func<Workload, bool>> workloadLambda = x => true;
            if (workLoadSearch.TrialId != Guid.Empty && workLoadSearch.TrialId != null)
            {
                workloadLambda = workloadLambda.And(x => x.TrialId == workLoadSearch.TrialId);
            }
            if (workLoadSearch.DoctorId != Guid.Empty && workLoadSearch.DoctorId != null)
            {
                workloadLambda = workloadLambda.And(t => t.DoctorId == workLoadSearch.DoctorId);
            }
            if (workLoadSearch.SearchBeginDateTime != null)
            {
                var bDate = workLoadSearch.SearchBeginDateTime;
                var eDate = workLoadSearch.SearchEndDateTime.Value.AddMonths(1);
                var beginDate = new DateTime(bDate.Value.Year, bDate.Value.Month, 1);
                DateTime endDate = new DateTime(eDate.Year, eDate.Month, 1);

                workloadLambda = workloadLambda.And(t =>
                    t.WorkTime >= beginDate && t.WorkTime < endDate);
            }



            #endregion

            IQueryable<WorkLoadDetailDTO> workLoadQueryable = default;

            var tempWorkload = new List<WorkLoadDetailDTO>();
            if (workLoadSearch.WorkLoadFromStatus.Contains(1))
            {
                workLoadQueryable = from workLoad in _doctorWorkloadRepository.GetAll().Where(workloadLambda.And(t => t.DataFrom == (int)WorkLoadFromStatus.CRO))
                                    join doctor in _doctorRepository.GetAll() on workLoad.DoctorId equals doctor.Id
                                    join trial in _trialRepository.GetAll() on workLoad.TrialId equals trial.Id

                                    select new WorkLoadDetailDTO()
                                    {
                                        Id = workLoad.Id,
                                        DoctorId = workLoad.DoctorId,
                                        ChineseName = doctor.ChineseName,
                                        FirstName = doctor.FirstName,
                                        LastName = doctor.LastName,

                                        YearMonthStr = workLoad.YearMonth,
                                        CreateTime = workLoad.CreateTime,
                                        WorkTime = workLoad.WorkTime,

                                        DataFrom = workLoad.DataFrom,
                                        TrialId = workLoad.TrialId,
                                        Indication = trial.Indication,
                                        Code = trial.Code,

                                        Timepoint = workLoad.Timepoint,
                                        TimepointIn24H = workLoad.TimepointIn24H,
                                        TimepointIn48H = workLoad.TimepointIn48H,
                                        Global = workLoad.Global,
                                        RefresherTraining = workLoad.RefresherTraining,
                                        Adjudication = workLoad.Adjudication,
                                        AdjudicationIn24H = workLoad.AdjudicationIn24H,
                                        AdjudicationIn48H = workLoad.AdjudicationIn48H,


                                        Training = workLoad.Training,
                                        Downtime = workLoad.Downtime,
                                        IsLock = workLoad.IsLock
                                    };
                tempWorkload.AddRange(workLoadQueryable.ToList());
            }


            if (workLoadSearch.WorkLoadFromStatus.Contains(2))
            {
                workLoadQueryable = from workLoad in _doctorWorkloadRepository.GetAll().Where(workloadLambda.And(t => t.DataFrom == (int)WorkLoadFromStatus.FinalConfirm))
                                    join doctor in _doctorRepository.GetAll() on workLoad.DoctorId equals doctor.Id
                                    join trial in _trialRepository.GetAll() on workLoad.TrialId equals trial.Id

                                    select new WorkLoadDetailDTO()
                                    {
                                        Id = workLoad.Id,
                                        DoctorId = workLoad.DoctorId,
                                        ChineseName = doctor.ChineseName,
                                        FirstName = doctor.FirstName,
                                        LastName = doctor.LastName,

                                        YearMonthStr = workLoad.YearMonth,
                                        CreateTime = workLoad.CreateTime,
                                        WorkTime = workLoad.WorkTime,

                                        DataFrom = workLoad.DataFrom,
                                        TrialId = workLoad.TrialId,
                                        Indication = trial.Indication,
                                        Code = trial.Code,

                                        Timepoint = workLoad.Timepoint,
                                        TimepointIn24H = workLoad.TimepointIn24H,
                                        TimepointIn48H = workLoad.TimepointIn48H,
                                        Global = workLoad.Global,
                                        RefresherTraining = workLoad.RefresherTraining,
                                        Adjudication = workLoad.Adjudication,
                                        AdjudicationIn24H = workLoad.AdjudicationIn24H,
                                        AdjudicationIn48H = workLoad.AdjudicationIn48H,

                                        Training = workLoad.Training,
                                        Downtime = workLoad.Downtime,
                                        IsLock = workLoad.IsLock
                                    };
                tempWorkload.AddRange(workLoadQueryable.ToList());
            }

            if (workLoadSearch.WorkLoadFromStatus.Contains(0))
            {
                workLoadQueryable =
                  from workLoad in (from workLoadItem in _doctorWorkloadRepository.GetAll().Where(workloadLambda.And(t => t.DataFrom == (int)WorkLoadFromStatus.Doctor))
                                    group workLoadItem by new { workLoadItem.YearMonth, workLoadItem.DoctorId, workLoadItem.TrialId, workLoadItem.IsLock } into g
                                    select new
                                    {
                                        Id = Guid.NewGuid(),
                                        DoctorId = g.Key.DoctorId,
                                        DataFrom = 0,
                                        TrialId = g.Key.TrialId,
                                        IsLock = g.Key.IsLock,
                                        YearMonthStr = g.Key.YearMonth,
                                        Timepoint = g.Sum(workLoad => workLoad.Timepoint),
                                        TimepointIn24H = g.Sum(workLoad => workLoad.TimepointIn24H),
                                        TimepointIn48H = g.Sum(workLoad => workLoad.TimepointIn48H),
                                        Global = g.Sum(workLoad => workLoad.Global),
                                        RefresherTraining = g.Sum(workLoad => workLoad.RefresherTraining),
                                        Adjudication = g.Sum(workLoad => workLoad.Adjudication),
                                        AdjudicationIn24H = g.Sum(workLoad => workLoad.AdjudicationIn24H),
                                        AdjudicationIn48H = g.Sum(workLoad => workLoad.AdjudicationIn48H),

                                        Training = g.Sum(workLoad => workLoad.Training),
                                        Downtime = g.Sum(workLoad => workLoad.Downtime)
                                    })
                  join doctor in _doctorRepository.GetAll() on workLoad.DoctorId equals doctor.Id
                  join trial in _trialRepository.GetAll() on workLoad.TrialId equals trial.Id
                  select new WorkLoadDetailDTO()
                  {
                      Id = workLoad.Id,
                      DoctorId = workLoad.DoctorId,
                      ChineseName = doctor.ChineseName,
                      FirstName = doctor.FirstName,
                      LastName = doctor.LastName,
                      YearMonthStr = workLoad.YearMonthStr,

                      DataFrom = workLoad.DataFrom,
                      TrialId = workLoad.TrialId,
                      Indication = trial.Indication,
                      Code = trial.Code,

                      Timepoint = workLoad.Timepoint,
                      TimepointIn24H = workLoad.TimepointIn24H,
                      TimepointIn48H = workLoad.TimepointIn48H,
                      Global = workLoad.Global,
                      RefresherTraining = workLoad.RefresherTraining,
                      Adjudication = workLoad.Adjudication,
                      AdjudicationIn24H = workLoad.AdjudicationIn24H,
                      AdjudicationIn48H = workLoad.AdjudicationIn48H,

                      Training = workLoad.Training,
                      Downtime = workLoad.Downtime,
                      IsLock = workLoad.IsLock
                  };
                tempWorkload.AddRange(workLoadQueryable.ToList());
            }

            //workLoadQueryable = workLoadQueryable.OrderByDescending(t => t.YearMonthStr).ThenBy(t => t.DataFrom);

            //取选取月份的数据
            var month = (workLoadSearch.SearchEndDateTime?.Year - workLoadSearch.SearchBeginDateTime?.Year) * 12 + (workLoadSearch.SearchEndDateTime?.Month - workLoadSearch.SearchBeginDateTime?.Month) + 1;
            var count = (month ?? 1) * workLoadSearch.WorkLoadFromStatus.Count;
            //tempWorkload = tempWorkload.Take(count);
            tempWorkload.OrderByDescending(t => t.YearMonthStr).ThenBy(t => t.DataFrom).Take(count);
            //var workLoadList = workLoadQueryable.ToList();
            return BuildFullData(tempWorkload, workLoadSearch);
        }

        /// <summary>
        /// 获取来自Reviewer自己的数据，某个月添加的多条
        /// </summary>
        public List<WorkLoadDetailViewModel> GetReviewerWorkLoadListDetail(
            WorkLoadDetailQueryDTO workLoadSearch)
        {
            Expression<Func<Workload, bool>> workloadLambda = t => t.DataFrom == (int)WorkLoadFromStatus.Doctor && t.YearMonth == workLoadSearch.YearMonthStr;

            if (workLoadSearch.TrialId != Guid.Empty)
            {
                workloadLambda = workloadLambda.And(x => x.TrialId == workLoadSearch.TrialId);
            }

            if (workLoadSearch.DoctorId != Guid.Empty)
            {
                workloadLambda = workloadLambda.And(t => t.DoctorId == workLoadSearch.DoctorId);
            }

            var workLoadQueryable = from workLoad in _doctorWorkloadRepository.GetAll().Where(workloadLambda)
                                    join doctor in _doctorRepository.GetAll() on workLoad.DoctorId equals doctor.Id
                                    join trial in _trialRepository.GetAll() on workLoad.TrialId equals trial.Id

                                    select new WorkLoadDetailViewModel()
                                    {
                                        Id = workLoad.Id,
                                        DoctorId = workLoad.DoctorId,
                                        ChineseName = doctor.ChineseName,
                                        FirstName = doctor.FirstName,
                                        LastName = doctor.LastName,
                                        YearMonthStr = workLoad.YearMonth,
                                        CreateTime = workLoad.CreateTime,
                                        WorkTime = workLoad.WorkTime,

                                        DataFrom = workLoad.DataFrom,
                                        TrialId = workLoad.TrialId,
                                        Indication = trial.Indication,
                                        Code = trial.Code,

                                        Timepoint = workLoad.Timepoint,
                                        TimepointIn24H = workLoad.TimepointIn24H,
                                        TimepointIn48H = workLoad.TimepointIn48H,
                                        Global = workLoad.Global,
                                        Adjudication = workLoad.Adjudication,
                                        AdjudicationIn24H = workLoad.AdjudicationIn24H,
                                        AdjudicationIn48H = workLoad.AdjudicationIn48H,
                                        RefresherTraining = workLoad.RefresherTraining,

                                        Training = workLoad.Training,
                                        Downtime = workLoad.Downtime,
                                        IsLock = workLoad.IsLock
                                    };

            workLoadQueryable = workLoadQueryable.OrderBy("WorkTime");

            var workLoadList = workLoadQueryable.ToList();

            workLoadList.ForEach(t => t.RowGuid = Guid.NewGuid());

            return workLoadList;

        }

        /// <summary>
        /// 工作量是否存在，用于判断只能添加一条的工作量记录
        /// </summary>
        public IResponseOutput<ExistWorkloadViewModel> WorkloadExist(WorkloadExistQueryDTO param)
        {
            var isExist = false;
            var exist = _doctorWorkloadRepository.FindSingleOrDefault(u => u.TrialId == param.TrialId && u.DoctorId == param.DoctorId
            && u.WorkTime == param.WorkDate && u.DataFrom == 0);
            if (exist != null)
            {
                isExist = true;
            }
            return ResponseOutput.Ok(new ExistWorkloadViewModel
            {
                IsExist = isExist,
                WorkLoad = _mapper.Map<WorkloadDTO>(exist),
            });
        }

        /// <summary>
        /// 添加或更新工作量
        /// </summary>
        public IResponseOutput AddOrUpdateWorkload(WorkloadCommand workLoadAddOrUpdateModel,
            Guid userId)
        {
            var yearMonthStr = workLoadAddOrUpdateModel.WorkTime.ToString("yyyy-MM");


            if (workLoadAddOrUpdateModel.Id == Guid.Empty || workLoadAddOrUpdateModel.Id == null)
            {
                //确定是那个医生 那个项目 那个月份做的
                Expression<Func<Workload, bool>> workloadLambda = x => x.DoctorId == workLoadAddOrUpdateModel.DoctorId && x.TrialId == workLoadAddOrUpdateModel.TrialId && x.YearMonth == yearMonthStr;

                //只要是来自CRO或者最终确认的 只能有一条
                switch (workLoadAddOrUpdateModel.DataFrom)
                {
                    case (int)WorkLoadFromStatus.CRO: //1  来自CRO的
                        workloadLambda = workloadLambda.And(t => t.DataFrom == (int)WorkLoadFromStatus.CRO);
                        break;

                    case (int)WorkLoadFromStatus.FinalConfirm:   //2 最终确认的
                        workloadLambda = workloadLambda.And(t => t.DataFrom == (int)WorkLoadFromStatus.FinalConfirm);

                        var isExist = _costStatisticsRepository.GetAll().Any(u => u.YearMonth == yearMonthStr && u.DoctorId == workLoadAddOrUpdateModel.DoctorId);
                        if (!isExist)
                        {
                            _costStatisticsRepository.Add(new Payment
                            {
                                DoctorId = workLoadAddOrUpdateModel.DoctorId,
                                YearMonth = yearMonthStr,
                                YearMonthDate = DateTime.Parse(yearMonthStr),
                                IsLock = false
                            });
                        }

                        //处理 验证项目收入价格是否都填写了

                        var revenuesPriceExist = _trialRevenuesPriceRepository.GetAll()
                                 .FirstOrDefault(t => t.TrialId == workLoadAddOrUpdateModel.TrialId);

                        //没填写收入价格 插入记录 所有的都是false  
                        if (revenuesPriceExist == null)
                        {
                            _trialRevenuesPriceVerificationRepository.Add(new TrialRevenuesPriceVerification()
                            {
                                TrialId = workLoadAddOrUpdateModel.TrialId,
                                ReviewerId = workLoadAddOrUpdateModel.DoctorId,
                                YearMonth = yearMonthStr,
                                WorkLoadDate = workLoadAddOrUpdateModel.WorkTime
                            });
                        }
                        else //有价格 校验  看全不全
                        {

                            var tpNeedSetPrice = workLoadAddOrUpdateModel.Timepoint > 0 &&
                                                 revenuesPriceExist.Timepoint <= 0;
                            var tp24HNeedSetPrice = workLoadAddOrUpdateModel.TimepointIn24H > 0 &&
                                                    revenuesPriceExist.TimepointIn24H <= 0;
                            var tp48NeedSetPrice = workLoadAddOrUpdateModel.TimepointIn48H > 0 &&
                                                   revenuesPriceExist.TimepointIn48H <= 0;
                            var adNeedSetPrice = workLoadAddOrUpdateModel.Adjudication > 0 &&
                                                 revenuesPriceExist.Adjudication <= 0;
                            var ad24NeedSetPrice = workLoadAddOrUpdateModel.AdjudicationIn24H > 0 &&
                                                   revenuesPriceExist.AdjudicationIn24H <= 0;
                            var ad48NeedSetPrice = workLoadAddOrUpdateModel.AdjudicationIn48H > 0 &&
                                                   revenuesPriceExist.AdjudicationIn48H <= 0;
                            var downtimeNeedSetPrice = workLoadAddOrUpdateModel.Downtime > 0 &&
                                                       revenuesPriceExist.Downtime <= 0;
                            var globalNeedSetPrice = workLoadAddOrUpdateModel.Global > 0 &&
                                                     revenuesPriceExist.Global <= 0;
                            var trainingNeedSetPrice = workLoadAddOrUpdateModel.Training > 0 &&
                                                       revenuesPriceExist.Training <= 0;

                            var refresherTrainingTrainingNeedSetPrice = workLoadAddOrUpdateModel.RefresherTraining > 0 &&
                                                                        revenuesPriceExist.RefresherTraining <= 0;




                            var needAdd = tpNeedSetPrice || tp24HNeedSetPrice || tp48NeedSetPrice || adNeedSetPrice || ad24NeedSetPrice ||
                                ad48NeedSetPrice || downtimeNeedSetPrice || globalNeedSetPrice && trainingNeedSetPrice|| refresherTrainingTrainingNeedSetPrice;

                            //验证不通过 增加
                            if (needAdd)
                            {
                                _trialRevenuesPriceVerificationRepository.Add(new TrialRevenuesPriceVerification()
                                {
                                    TrialId = workLoadAddOrUpdateModel.TrialId,
                                    ReviewerId = workLoadAddOrUpdateModel.DoctorId,
                                    YearMonth = yearMonthStr,
                                    WorkLoadDate = workLoadAddOrUpdateModel.WorkTime,
                                    //需要设置价格和 有价格是相反的   数据库此字段存储的时候对应项是否有价格
                                    Timepoint = !tpNeedSetPrice,
                                    TimepointIn24H = !tp24HNeedSetPrice,
                                    TimepointIn48H = !tp48NeedSetPrice,
                                    Adjudication = !adNeedSetPrice,
                                    AdjudicationIn24H = !ad24NeedSetPrice,
                                    AdjudicationIn48H = !ad48NeedSetPrice,
                                    Downtime = !downtimeNeedSetPrice,
                                    Global = !globalNeedSetPrice,
                                    Training = !trainingNeedSetPrice,
                                    RefresherTraining = !refresherTrainingTrainingNeedSetPrice
                                });
                            }

                        }


                        break;
                }
                if (workLoadAddOrUpdateModel.DataFrom != (int)WorkLoadFromStatus.Doctor)
                {
                    if (_doctorWorkloadRepository.GetAll().Any(workloadLambda))
                    {

                        return ResponseOutput.NotOk("This type of data can only have one");

                    }
                }
                if (workLoadAddOrUpdateModel.DataFrom == (int)WorkLoadFromStatus.Doctor)
                {
                    Expression<Func<Workload, bool>> doctorworkloadLambda = x => x.DoctorId == workLoadAddOrUpdateModel.DoctorId && x.TrialId == workLoadAddOrUpdateModel.TrialId && x.YearMonth == yearMonthStr && workLoadAddOrUpdateModel.WorkTime == x.WorkTime;

                    doctorworkloadLambda = doctorworkloadLambda.And(t => t.DataFrom == (int)WorkLoadFromStatus.Doctor);
                    if (_doctorWorkloadRepository.GetAll().Any(doctorworkloadLambda))
                    {
                        return ResponseOutput.NotOk("This type of data can only have one");
                    }
                }

                var workLoad = _mapper.Map<Workload>(workLoadAddOrUpdateModel);

                workLoad.YearMonth = yearMonthStr;

                _doctorWorkloadRepository.Add(workLoad);

                _enrollRepository.Update(
                    t => t.DoctorId == workLoadAddOrUpdateModel.DoctorId && t.TrialId == workLoadAddOrUpdateModel.TrialId, u => new Enroll()
                    {
                        EnrollStatus = (int)EnrollStatus.DoctorReading,
                        UpdateTime = DateTime.Now
                    });

                var success = _doctorWorkloadRepository.SaveChanges();

                return ResponseOutput.Result(success, workLoad.Id);

            }
            else
            {
                //判断是否已经被锁定
                var isLocked = _costStatisticsRepository.GetAll().Any(u => u.DoctorId == workLoadAddOrUpdateModel.DoctorId &&
                u.YearMonth == yearMonthStr && u.IsLock);
                if (isLocked)
                {

                    return ResponseOutput.NotOk("Expenses have been settled and workload cannot be modified.");

                }

                var success = _doctorWorkloadRepository.Update(t => t.Id == workLoadAddOrUpdateModel.Id,
                    u => new Workload()
                    {
                        Timepoint = workLoadAddOrUpdateModel.Timepoint,
                        TimepointIn24H = workLoadAddOrUpdateModel.TimepointIn24H,
                        TimepointIn48H = workLoadAddOrUpdateModel.TimepointIn48H,

                        Adjudication = workLoadAddOrUpdateModel.Adjudication,
                        AdjudicationIn24H = workLoadAddOrUpdateModel.AdjudicationIn24H,
                        AdjudicationIn48H = workLoadAddOrUpdateModel.AdjudicationIn48H,

                        RefresherTraining = workLoadAddOrUpdateModel.RefresherTraining,

                        Downtime = workLoadAddOrUpdateModel.Downtime,
                        Training = workLoadAddOrUpdateModel.Training,
                        Global = workLoadAddOrUpdateModel.Global,
                        UpdateTime = DateTime.Now,
                        UpdateUserId = userId,

                        WorkTime = workLoadAddOrUpdateModel.WorkTime,
                        YearMonth = yearMonthStr
                    });
                return ResponseOutput.Result(success);

            }
        }




        /// <summary>
        /// 删除工作量
        /// </summary>
        public IResponseOutput DeleteWorkload(Guid workloadId)
        {
            return ResponseOutput.Result(_doctorWorkloadRepository.Delete(t => t.Id == workloadId));
        }

        /// <summary>
        /// 获取工作量详情(用于判断工作量锁定时，调用)
        /// </summary>
        public WorkloadDTO GetWorkloadDetailById(Guid id)
        {
            var workload = _doctorWorkloadRepository.FindSingleOrDefault(u => u.Id == id);
            return _mapper.Map<WorkloadDTO>(workload);
        }

        #endregion

        private PageOutput<WorkLoadDetailDTO> BuildFullData(
            List<WorkLoadDetailDTO> workLoadList, WorkLoadStatsQueryDTO workLoadSearch)
        {
            var doctor = _doctorRepository.GetAll().Where(t => t.Id == workLoadSearch.DoctorId).ProjectTo<DoctorBasicInfo>(_mapper.ConfigurationProvider).FirstOrDefault();
            //查询 1-3月的  共3个月 
            var month = (workLoadSearch.SearchEndDateTime?.Year - workLoadSearch.SearchBeginDateTime?.Year) * 12 +
                (workLoadSearch.SearchEndDateTime?.Month - workLoadSearch.SearchBeginDateTime?.Month) + 1;

            var needCount = month * workLoadSearch.WorkLoadFromStatus.Count ?? 1;

            if (workLoadSearch.WorkLoadFromStatus.Contains((int)WorkLoadFromStatus.FinalConfirm))
            {
                if (workLoadList.Count != needCount)
                {
                    for (int i = 0; i < month; i++)
                    {
                        var yearMonthStr = workLoadSearch.SearchBeginDateTime?.AddMonths(i).ToString("yyyy-MM");
                        if (!workLoadList.Any(t => t.YearMonthStr == yearMonthStr &&
                                                   t.DataFrom == (int)WorkLoadFromStatus.FinalConfirm))
                        {
                            workLoadList.Add(new WorkLoadDetailDTO()
                            {
                                Id = Guid.Empty,
                                DataFrom = (int)WorkLoadFromStatus.FinalConfirm,
                                YearMonthStr = yearMonthStr,
                                ChineseName = doctor.ChineseName,
                                FirstName = doctor.FirstName,
                                LastName = doctor.LastName,
                                Code = doctor.Code
                            });
                        }
                    }
                }
            }
            if (workLoadSearch.WorkLoadFromStatus.Contains((int)WorkLoadFromStatus.CRO))
            {
                if (workLoadList.Count != needCount)
                {
                    for (int i = 0; i < month; i++)
                    {
                        var yearMonthStr = workLoadSearch.SearchBeginDateTime?.AddMonths(i).ToString("yyyy-MM");
                        if (!workLoadList.Any(t => t.YearMonthStr == yearMonthStr &&
                                                   t.DataFrom == (int)WorkLoadFromStatus.CRO))
                        {
                            workLoadList.Add(new WorkLoadDetailDTO()
                            {
                                Id = Guid.Empty,
                                DataFrom = (int)WorkLoadFromStatus.CRO,
                                YearMonthStr = yearMonthStr,
                                ChineseName = doctor.ChineseName,
                                FirstName = doctor.FirstName,
                                LastName = doctor.LastName,
                                Code = doctor.Code
                            });
                        }
                    }
                }
            }
            if (workLoadSearch.WorkLoadFromStatus.Contains((int)WorkLoadFromStatus.Doctor))
            {
                if (workLoadList.Count != needCount)
                {
                    for (int i = 0; i < month; i++)
                    {
                        var yearMonthStr = workLoadSearch.SearchBeginDateTime?.AddMonths(i).ToString("yyyy-MM");
                        if (!workLoadList.Any(t => t.YearMonthStr == yearMonthStr &&
                                                   t.DataFrom == (int)WorkLoadFromStatus.Doctor))
                        {
                            workLoadList.Add(new WorkLoadDetailDTO()
                            {
                                Id = Guid.Empty,
                                DataFrom = (int)WorkLoadFromStatus.Doctor,
                                YearMonthStr = yearMonthStr,
                                ChineseName = doctor.ChineseName,
                                FirstName = doctor.FirstName,
                                LastName = doctor.LastName,
                                Code = doctor.Code
                            });
                        }
                    }
                }

            }

            workLoadList = workLoadList.OrderByDescending(t => t.YearMonthStr).ThenBy(t => t.DataFrom)
                .ToList();
            int tempRowId = 0;
            foreach (var workLoad in workLoadList)
            {
                workLoad.RowGuid = Guid.NewGuid();
                workLoad.RowIntId = tempRowId + 1;
                tempRowId++;
            }

            return new PageOutput<WorkLoadDetailDTO>(1, workLoadList.Count,
                workLoadList.Count, workLoadList);


        }


    }
}