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 StatisticsService : IStatisticsService
    {
        private readonly IDoctorRepository _doctorRepository;
        private readonly ITrialRepository _trialRepository;
        private readonly IEnrollRepository _enrollRepository;
        private readonly IWorkloadRepository _workloadRepository;
        private readonly ICRORepository _croCompanyRepository;
        private readonly IDictionaryRepository _dictionaryRepository;
        private readonly IHospitalRepository _hospitalRepository;
        private readonly IEnrollDetailRepository _enrollDetailRepository;
        private readonly IUserRepository _userRepository;
        private readonly IUserTrialRepository _userTrialRepository;

        public StatisticsService(IDoctorRepository doctorRepository, ITrialRepository trialRepository,
            IEnrollRepository intoGroupRepository, IWorkloadRepository workloadRepository,
             ICRORepository croCompanyRepository,
            IDictionaryRepository dictionaryRepository,
            IHospitalRepository hospitalRepository,
            IEnrollDetailRepository enrollDetailRepository, IUserRepository userRepository,
            IUserTrialRepository userTrialRepository)
        {
            _doctorRepository = doctorRepository;
            _trialRepository = trialRepository;
            _enrollRepository = intoGroupRepository;
            _workloadRepository = workloadRepository;
            _croCompanyRepository = croCompanyRepository;
            _dictionaryRepository = dictionaryRepository;
            _hospitalRepository = hospitalRepository;
            _enrollDetailRepository = enrollDetailRepository;
            _userRepository = userRepository;
            _userTrialRepository = userTrialRepository;
        }

        public PageOutput<WorkloadByTrialAndReviewerDTO> GetWorkloadByTrialAndReviewer(StatisticsWorkloadQueryParam param,
            Guid userId)
        {
            var currentUser = _userRepository.FindSingleOrDefault(u => u.Id == userId);

            var bDate = new DateTime(param.BeginDate.Year, param.BeginDate.Month, param.BeginDate.Day);
            var eDate = new DateTime(param.EndDate.Year, param.EndDate.Month, param.EndDate.Day);
            eDate = eDate.AddDays(1);
            Expression<Func<Workload, bool>> workloadLambda = x => x.DataFrom == (int)WorkLoadFromStatus.FinalConfirm;
            workloadLambda = workloadLambda.And(x => x.WorkTime >= bDate && x.WorkTime < eDate);

            Expression<Func<Trial, bool>> trialLambda = x => true;
            if (currentUser.SuperAdmin) //超级管理员按照条件查询所有
            {
                if (Guid.Empty != param.CroId && param.CroId != null)
                {
                    trialLambda = trialLambda.And(u => u.CROId == param.CroId);
                }
            }
            else if (currentUser.UserType.Contains("CROCoordinator"))  //协调者看CRO下面的
            {
                trialLambda = trialLambda.And(u => u.CROId == currentUser.OrganizationId);
            }
            else  //不管是精鼎的pm还是我们的pm  还是运维人员 只能看到自己参与项目的统计
            {
                List<Guid> trialIdList = _userTrialRepository.Find(u => u.UserId == userId&&u.SiteId==Guid.Empty).Select(u => u.TrialId).ToList();
                trialLambda = trialLambda.And(u => trialIdList.Contains(u.Id));
            }
            if (!string.IsNullOrWhiteSpace(param.TrialCode))
            {
                trialLambda = trialLambda.And(u => u.Code.Contains(param.TrialCode.Trim()));
            }

            Expression<Func<Doctor, bool>> doctorLambda = x => true;
            if (!string.IsNullOrWhiteSpace(param.Reviewer))
            {

                var reviewer = param.Reviewer.Trim();
                doctorLambda = doctorLambda.And(u => u.ChineseName.Contains(reviewer)
                                                     || u.FirstName.Contains(reviewer)
                                                     || u.LastName.Contains(reviewer)
                                                     || u.Code.Contains(reviewer)
                );

            }
            if (Guid.Empty != param.HospitalId && param.HospitalId != null)
            {
                doctorLambda = doctorLambda.And(u => u.HospitalId == param.HospitalId);
            }

            var workloadQuery = from workLoad in _workloadRepository.GetAll().Where(workloadLambda)
                                join trial in _trialRepository.Find(trialLambda)
                                on workLoad.TrialId equals trial.Id
                                join doctor in _doctorRepository.Find(doctorLambda)
                                on workLoad.DoctorId equals doctor.Id
                                group workLoad by new { workLoad.DoctorId, workLoad.TrialId }
                                    into gWorkLoad

                                select new
                                {
                                    DoctorId = gWorkLoad.Key.DoctorId,
                                    TrialId = gWorkLoad.Key.TrialId,
                                    Downtime = gWorkLoad.Sum(t => t.Downtime),
                                    Training = gWorkLoad.Sum(t => t.Training),
                                    Timepoint = gWorkLoad.Sum(t => t.Timepoint),
                                    TimepointIn24H = gWorkLoad.Sum(t => t.TimepointIn24H),
                                    TimepointIn48H = gWorkLoad.Sum(t => t.TimepointIn48H),
                                    Global = gWorkLoad.Sum(t => t.Global),
                                    Adjudication = gWorkLoad.Sum(t => t.Adjudication),
                                    AdjudicationIn24H = gWorkLoad.Sum(t => t.AdjudicationIn24H),
                                    AdjudicationIn48H = gWorkLoad.Sum(t => t.AdjudicationIn48H),
                                    RefresherTraining= gWorkLoad.Sum(t => t.RefresherTraining),

                                };
            var query = from w in workloadQuery
                        join trial in _trialRepository.Find(trialLambda) on w.TrialId equals trial.Id into t
                        from trialItem in t.DefaultIfEmpty()
                        join doctor in _doctorRepository.Find(doctorLambda) on w.DoctorId equals doctor.Id into tt
                        from doctorItem in tt.DefaultIfEmpty()
                        join cro in _croCompanyRepository.GetAll() on trialItem.CROId equals cro.Id into ttt
                        from croItem in ttt.DefaultIfEmpty()
                        select new WorkloadByTrialAndReviewerDTO
                        {
                            Id = Guid.NewGuid(),
                            TrialId = trialItem.Id,
                            Indication = trialItem.Indication,
                            TrialCode = trialItem.Code,
                            CroId = trialItem.CROId,
                            Cro = croItem.CROName,
                            ReviewerCode = doctorItem.Code,
                            ChineseName = doctorItem.ChineseName,
                            FirstName = doctorItem.FirstName,
                            LastName = doctorItem.LastName,
                            Training = w.Training,
                            Timepoint = w.Timepoint,
                            TimepointIn24H = w.TimepointIn24H,
                            TimepointIn48H = w.TimepointIn48H,
                            Adjudication = w.Adjudication,
                            AdjudicationIn24H = w.AdjudicationIn24H,
                            AdjudicationIn48H = w.AdjudicationIn48H,
                            Global = w.Global,
                            Downtime = w.Downtime,
                            RefresherTraining=w.RefresherTraining,

                            PersonalTotal = w.Timepoint + w.TimepointIn24H + w.TimepointIn48H + w.Adjudication + w.AdjudicationIn24H +
                            w.AdjudicationIn48H + w.Global
        };

            var propName = param.SortField == "" ? "ReviewerCode" : param.SortField;
            query = param.Asc
              ? query.OrderBy(propName).ThenBy(t=>t.TrialCode).ThenBy(u=>u.ReviewerCode)
              : query.OrderByDescending(propName).ThenBy(t => t.TrialCode).ThenBy(u => u.ReviewerCode);
            if (propName == "FirstName" || propName == "LastName")
            {
                query = param.Asc
              ? query.OrderBy(t => t.LastName).ThenBy(t => t.FirstName)
              : query.OrderByDescending(t => t.LastName).ThenBy(t => t.FirstName);
            }
            var count = query.Count();

            query = query
                .Skip((param.PageIndex - 1) * param.PageSize)
                .Take(param.PageSize);
            var doctorViewList = query.ToList();

            return new PageOutput<WorkloadByTrialAndReviewerDTO>(param.PageIndex, param.PageSize, count, doctorViewList);
        }
        public PageOutput<EnrollStatByReviewerDTO> GetEnrollStatByReviewer(EnrollStatByReviewerQueryDTO param)
        {
            var bDate = new DateTime(param.BeginDate.Year, param.BeginDate.Month, 1);
            var eDate = new DateTime(param.EndDate.Year, param.EndDate.Month, 1);
            eDate = eDate.AddMonths(1);

            Expression<Func<Enroll, bool>> enrollLambda = x => true;
            enrollLambda = enrollLambda.And(x => x.EnrollTime >= bDate && x.EnrollTime < eDate);

            Expression<Func<Hospital, bool>> hospitalLambda = x => true;
            if (Guid.Empty != param.HospitalId&& param.HospitalId!=null)
            {
                hospitalLambda = hospitalLambda.And(u => u.Id == param.HospitalId);
            }

            Expression<Func<Doctor, bool>> doctorLambda = x => true;
            if (!string.IsNullOrWhiteSpace(param.Reviewer))
            {

                var reviewer = param.Reviewer.Trim();
                doctorLambda = doctorLambda.And(u => u.ChineseName.Contains(reviewer)
                                                     || u.FirstName.Contains(reviewer)
                                                     || u.LastName.Contains(reviewer)
                                                     || u.Code.Contains(reviewer)
                );
            }

            var enrollQueryable =
                from enroll in _enrollRepository.Find(enrollLambda)
                group enroll by new { enroll.DoctorId }
                into g
                select new
                {
                    DoctorId = g.Key.DoctorId,
                    Submitted = g.Sum(t =>
                        t.EnrollStatus == (int)EnrollStatus.HasCommittedToCRO?1:0),
                    Approved = g.Sum(t =>
                        t.EnrollStatus == (int)EnrollStatus.InviteIntoGroup?1:0),
                    Reading = g.Sum(t =>
                        t.EnrollStatus == (int)EnrollStatus.DoctorReading?1:0),
                    Finished = g.Sum(t =>
                        t.EnrollStatus >= (int)EnrollStatus.End?1:0),
                };


            var query = from w in enrollQueryable

                        join doctor in _doctorRepository.Find(doctorLambda) on w.DoctorId equals doctor.Id
                        join hospital in _hospitalRepository.Find(hospitalLambda) on doctor.HospitalId equals hospital.Id
                        select new EnrollStatByReviewerDTO
                        {
                            Id = Guid.NewGuid(),
                            Hospital = hospital.HospitalName,
                            ReviewerCode = doctor.Code,
                            ChineseName = doctor.ChineseName,
                            FirstName = doctor.FirstName,
                            LastName = doctor.LastName,
                            Pending = w.Submitted,
                            Approved = w.Approved,
                            Reading = w.Reading,
                            Finished = w.Finished,

                            Total = w.Submitted+ w.Approved+ w.Reading+ w.Finished
                        };

            if (param.SortField != "EntryRate")
            {
                var propName = param.SortField == "" ? "ReviewerCode" : param.SortField;
                query = param.Asc
                    ? query.OrderBy(propName).ThenBy(u => u.ReviewerCode)
                    : query.OrderByDescending(propName).ThenBy(u => u.ReviewerCode);
                if (propName == "FirstName" || propName == "LastName")
                {
                    query = param.Asc
                        ? query.OrderBy(t => t.LastName).ThenBy(t => t.FirstName)
                        : query.OrderByDescending(t => t.LastName).ThenBy(t => t.FirstName);
                }
            }
            
           
            var count = query.Count();
            query = query
                .Skip((param.PageIndex - 1) * param.PageSize)
                .Take(param.PageSize);
            var list = query.ToList();

            if (param.SortField == "EntryRate")
            {
                list = param.Asc
                    ? list.OrderBy(t => t.EntryRate).ToList()
                    : list.OrderByDescending(t => t.EntryRate).ToList();
            }

            return new PageOutput<EnrollStatByReviewerDTO>(param.PageIndex, param.PageSize, count, list);
        }

        public PageOutput<EnrollStatByTrialDTO> GetEnrollStatByTrial(EnrollStatByTrialQueryDTO param)
        {

            #region 筛选条件 

            Expression<Func<Trial, bool>> trialLambda = x => true;

            if (param.Expedited != null)
            {
                trialLambda = trialLambda.And(o => o.Expedited == param.Expedited);
            }

            if (!string.IsNullOrEmpty(param.TrialCode))
            {
                var code = param.TrialCode.Trim();
                trialLambda = trialLambda.And(o => o.Code.Contains(code));
            }

            if (!string.IsNullOrWhiteSpace(param.Indication))
            {
                var indication = param.Indication.Trim();
                trialLambda = trialLambda.And(o => o.Indication.Contains(indication));
            }

            if (param.CROId != Guid.Empty&& param.CROId != null)
            {
                trialLambda = trialLambda.And(o => o.CROId == param.CROId);
            }


            if (param.BeginDate != null && param.EndDate != null)
            {
                var bDate = new DateTime(param.BeginDate.Value.Year, param.BeginDate.Value.Month, param.BeginDate.Value.Day);
                var eDate = new DateTime(param.EndDate.Value.Year, param.EndDate.Value.Month, param.BeginDate.Value.Day);
                eDate = eDate.AddMonths(1);

                trialLambda = trialLambda.And(o => o.CreateTime>=bDate&&o.CreateTime<eDate);
               
            }

            #endregion

            var trialEnrollStatQuery = _enrollRepository.GetAll()
                .Where(t => t.EnrollStatus >= (int)EnrollStatus.ConfirmIntoGroup).GroupBy(t => t.TrialId).Select(g => new
                {
                    TrialId = g.Key,
                    EnrollCount = g.Count()
                });

            var trialQuery = from trial in _trialRepository.GetAll().Where(trialLambda)
                             join cro in _croCompanyRepository.GetAll() on trial.CROId equals cro.Id into t
                             from cro in t.DefaultIfEmpty()

                             join trialEnroll in trialEnrollStatQuery on trial.Id equals trialEnroll.TrialId
                             select new EnrollStatByTrialDTO
                             {
                                 TrialId= trial.Id,
                                 Cro = cro != null ? cro.CROName : "",
                                 Expedited = trial.Expedited,
                                 Indication = trial.Indication,
                                 TrialCode = trial.Code,
                                 EnrollCount= trialEnroll.EnrollCount,
                                 CreateTime = trial.CreateTime
                             };

            var propName = param.SortField == "" ? "TrialCode" : param.SortField;
            trialQuery = param.Asc
                ? trialQuery.OrderBy(propName)
                : trialQuery.OrderByDescending(propName);
            
            var count = trialQuery.Count();

            trialQuery = trialQuery
                .Skip((param.PageIndex - 1) * param.PageSize)
                .Take(param.PageSize);

            var trialList = trialQuery.ToList();

            var trialIds = trialList.Select(t => t.TrialId).ToList();

            var enrollReviewerQuery = from enroll in _enrollRepository.GetAll()
                    .Where(t => t.EnrollStatus >= (int)EnrollStatus.ConfirmIntoGroup&& trialIds.Contains(t.TrialId))
                        join reviewer in _doctorRepository.GetAll() on enroll.DoctorId equals reviewer.Id
                       
                        select new
                        {
                            TrialId = enroll.TrialId,
                            NameCN = reviewer.ChineseName,
                            Name = reviewer.LastName + " / " + reviewer.FirstName
                        };
            var enrollReviewerByTrialList = enrollReviewerQuery.ToList().GroupBy(t => t.TrialId).Select(g => new
            {
                TrialId = g.Key,
                ReviewerNameCNList = g.Select(t => t.NameCN).ToList(),
                ReviewerNameList = g.Select(t => t.Name).ToList()
            }).ToList();


            trialList.ForEach(t =>
            {
                var trialDoctors = enrollReviewerByTrialList.FirstOrDefault(u => u.TrialId == t.TrialId);

                if (trialDoctors != null)
                {
                    t.ReviewerNameCNList = trialDoctors.ReviewerNameCNList;
                    t.ReviewerNameList = trialDoctors.ReviewerNameList;
                }
            });


            return new PageOutput<EnrollStatByTrialDTO>(param.PageIndex, param.PageSize, count, trialList);

        }


        #region Dashboard 数据统计
        public ReadingDataDTO GetReadingDataByType()
        {
            int tp = 0; int ad = 0; int g = 0;
            var finalConfirmWorkload = _workloadRepository.Find(u => u.DataFrom == (int)WorkLoadFromStatus.FinalConfirm).ToList();
            foreach (var item in finalConfirmWorkload)
            {
                tp += (item.Timepoint + item.TimepointIn24H + item.TimepointIn48H);
                ad += (item.Adjudication + item.AdjudicationIn24H + item.AdjudicationIn48H);
                g += item.Global;
            }
            return new ReadingDataDTO
            {
                Timepoint = tp,
                Adjudication = ad,
                Global = g
            };
        }

        public List<ReadingDataMonthDTO> GetReadingDataByMonth(int monthCount)
        {
            DateTime now = DateTime.Now.AddMonths(-1);
            DateTime eTime = new DateTime(now.Year, now.Month, 20);

            DateTime now6 = now.AddMonths(-1 * (monthCount - 1));
            DateTime bTime = new DateTime(now.AddMonths(-(monthCount - 1)).Year,
                now.AddMonths(-(monthCount - 1)).Month, 1, 0, 0, 0, 0);

            var query = from workload in _workloadRepository
                .Find(u => u.DataFrom == (int)WorkLoadFromStatus.FinalConfirm &&
                u.WorkTime >= bTime && u.WorkTime < eTime)
                        group workload by workload.YearMonth
                                    into gWorkLoad
                        select new ReadingDataMonthDTO
                        {
                            Month = gWorkLoad.Key,
                            Timepoint = gWorkLoad.Sum(t => t.Timepoint) + gWorkLoad.Sum(t => t.TimepointIn24H)
                            + gWorkLoad.Sum(t => t.TimepointIn48H),
                            Adjudication = gWorkLoad.Sum(t => t.Adjudication) + gWorkLoad.Sum(t => t.AdjudicationIn24H)
                            + gWorkLoad.Sum(t => t.AdjudicationIn48H),
                            Global = gWorkLoad.Sum(t => t.Global)
                        };
            var workloadList = query.OrderByDescending(u => u.Month).ToList();
            List<ReadingDataMonthDTO> result = new List<ReadingDataMonthDTO>();

            for (int i = 0; i < monthCount; i++)
            {
                var tempTime = now.AddMonths(-1 * i);
                var existedItem = workloadList.Find(u => u.Month ==
                (tempTime.Year + "-" + tempTime.Month.ToString().PadLeft(2, '0')));
                if (existedItem != null)
                {
                    result.Add(new ReadingDataMonthDTO
                    {
                        Month = existedItem.Month,
                        Timepoint = existedItem.Timepoint,
                        Adjudication = existedItem.Adjudication,
                        Global = existedItem.Global
                    });
                }
                else
                {
                    result.Add(new ReadingDataMonthDTO
                    {
                        Month = tempTime.Year + "-" + tempTime.Month.ToString().PadLeft(2, '0'),
                        Timepoint = 0,
                        Adjudication = 0,
                        Global = 0
                    });
                }
            }
            return result;
        }

        public List<ReadingDataRankDTO> GetReadingDataRank(int topCount)
        {
            var query = from workload in _workloadRepository
                .Find(u => u.DataFrom == (int)WorkLoadFromStatus.FinalConfirm)
                        group workload by workload.DoctorId
                                    into gWorkLoad

                        select new ReadingDataRankDTO
                        {
                            TotalReadingCount = gWorkLoad.Sum(t => t.Timepoint) + gWorkLoad.Sum(t => t.TimepointIn24H)
                            + gWorkLoad.Sum(t => t.TimepointIn48H) + gWorkLoad.Sum(t => t.Adjudication) + gWorkLoad.Sum(t => t.AdjudicationIn24H)
                            + gWorkLoad.Sum(t => t.AdjudicationIn48H) + gWorkLoad.Sum(t => t.Global),
                            ReviewerId = gWorkLoad.Key,
                            Timepoint = gWorkLoad.Sum(t => t.Timepoint) + gWorkLoad.Sum(t => t.TimepointIn24H)
                            + gWorkLoad.Sum(t => t.TimepointIn48H),
                            Adjudication = gWorkLoad.Sum(t => t.Adjudication) + gWorkLoad.Sum(t => t.AdjudicationIn24H)
                            + gWorkLoad.Sum(t => t.AdjudicationIn48H),
                            Global = gWorkLoad.Sum(t => t.Global)
                        };
            var workloadList = query.OrderByDescending(u => u.TotalReadingCount).Take(topCount).ToList();
            var reviewerList = from w in workloadList
                               join doctor in _doctorRepository.Find() on w.ReviewerId equals doctor.Id into tt
                               from doctorItem in tt.DefaultIfEmpty()
                               select new ReadingDataRankDTO
                               {
                                   TotalReadingCount = w.TotalReadingCount,
                                   ReviewerId = w.ReviewerId,
                                   Timepoint = w.Timepoint,
                                   Adjudication = w.Adjudication,
                                   Global = w.Global,
                                   ReviewerCode = doctorItem == null ? string.Empty : doctorItem.Code,
                                   FirstName = doctorItem == null ? string.Empty : doctorItem.FirstName,
                                   LastName = doctorItem == null ? string.Empty : doctorItem.LastName,
                                   ChineseName = doctorItem == null ? string.Empty : doctorItem.ChineseName
                               };
            return reviewerList.ToList();
        }


        public List<RankReviewersDTO> GetReviewersByRank()
        {
            var query = from q in (from reviewer in _doctorRepository.GetAll()
                                       //.Find(u => u.ReviewStatus == 1 && u.CooperateStatus == 1)
                                   group reviewer by reviewer.RankId
                                   into gReviewer
                                   select new
                                   {
                                       RankId = gReviewer.Key,
                                       ReviewerCount = gReviewer.Count()
                                   })

                        join dic in _dictionaryRepository.Find() on q.RankId equals dic.Id into tt
                        from dicItem in tt.DefaultIfEmpty()
                        select new RankReviewersDTO
                        {
                            RankId = q.RankId,
                            ReviewerCount = q.ReviewerCount,
                            RankName = dicItem == null ? "Other" : dicItem.Value
                        };

            var rankList = query.ToList();
            var staffList = rankList.Where(u => u.RankName == "Staff" || u.RankName == "Other");
            int staffCount = 0;
            foreach (var item in staffList)
            {
                staffCount += item.ReviewerCount;
            }
            rankList.RemoveAll(u => u.RankName == "Staff" || u.RankName == "Other");

            rankList.Add(new RankReviewersDTO { RankId = Guid.NewGuid(), RankName = "Staff", ReviewerCount = staffCount });

            return rankList;
        }

        public List<EnrollQuartDataDTO> GetEnrollDataByQuarter(int type, int count)
        {
            //等于0按照月份  否则按照季度
            if (type != 0)
            {
                var quarterCount = count;
                var year = DateTime.Now.AddMonths(-(quarterCount - 1) * 3 - DateTime.Now.Month % 3 + 1).Year;
                var month = DateTime.Now.AddMonths(-(quarterCount - 1) * 3 - DateTime.Now.Month % 3 + 1).Month;

                var beginMonth = new DateTime(year, month, 1);

                var endMonth = DateTime.Now;
                var querySql = from enrollDetail in _enrollDetailRepository.GetAll().Where(t =>
                        t.CreateTime > beginMonth && t.CreateTime < endMonth &&
                        t.EnrollStatus == (int)EnrollStatus.ConfirmIntoGroup)
                               select new
                               {

                                   OptTime = enrollDetail.CreateTime,
                                   Year = enrollDetail.CreateTime.Year,
                                   Month = enrollDetail.CreateTime.Month,
                               };

                var result = querySql.GroupBy(t => new { t.Year, t.Month }).Select(s => new EnrollDataDTO
                {
                    Year = s.Key.Year,
                    Month = s.Key.Month,
                    EnrollCount = s.Count()
                }).ToList();


                #region 填充数据

                List<EnrollDataDTO> returnList = new List<EnrollDataDTO>();
                for (int i = 0; i < DateTime.Now.Month % 3 + (quarterCount - 1) * 3; i++)
                {
                    var tempTime = DateTime.Now.AddMonths(-1 * i);
                    var existedItem = result.FirstOrDefault(u => u.YearMonth == tempTime.ToString("yyyy-MM"));
                    if (existedItem != null)
                    {
                        returnList.Add(new EnrollDataDTO
                        {
                            Month = existedItem.Month,
                            Year = existedItem.Year,
                            EnrollCount = existedItem.EnrollCount
                        });
                    }
                    else
                    {
                        returnList.Add(new EnrollDataDTO
                        {
                            Month = tempTime.Month,
                            Year = tempTime.Year,
                            EnrollCount = 0
                        });
                    }
                }

                #endregion

                var returnResult = returnList.GroupBy(t => t.QuarterStr).Select(u => new EnrollQuartDataDTO()
                {
                    ViewStr = u.Key,
                    EnrollCount = u.Sum(t => t.EnrollCount)
                }).ToList();

                return returnResult;
            }
            else
            {
                var year = DateTime.Now.AddMonths(-(count - 1)).Year;
                var month = DateTime.Now.AddMonths(-(count - 1)).Month;

                var beginMonth = new DateTime(year, month, 1);

                var endMonth = DateTime.Now;
                var querySql = from enrollDetail in _enrollDetailRepository.GetAll().Where(t =>
                        t.CreateTime > beginMonth && t.CreateTime < endMonth &&
                        t.EnrollStatus == (int)EnrollStatus.ConfirmIntoGroup)
                               select new
                               {

                                   OptTime = enrollDetail.CreateTime,
                                   Year = enrollDetail.CreateTime.Year,
                                   Month = enrollDetail.CreateTime.Month,
                               };

                var result = querySql.GroupBy(t => new { t.Year, t.Month }).Select(s => new EnrollDataDTO
                {
                    Year = s.Key.Year,
                    Month = s.Key.Month,
                    EnrollCount = s.Count()
                }).ToList();

                #region 填充数据

                List<EnrollDataDTO> returnList = new List<EnrollDataDTO>();
                for (int i = 0; i < count; i++)
                {
                    var tempTime = DateTime.Now.AddMonths(-1 * i);
                    var existedItem = result.FirstOrDefault(u => u.YearMonth == tempTime.ToString("yyyy-MM"));
                    if (existedItem != null)
                    {
                        returnList.Add(new EnrollDataDTO
                        {
                            Month = existedItem.Month,
                            Year = existedItem.Year,
                            EnrollCount = existedItem.EnrollCount
                        });
                    }
                    else
                    {
                        returnList.Add(new EnrollDataDTO
                        {
                            Month = tempTime.Month,
                            Year = tempTime.Year,
                            EnrollCount = 0
                        });
                    }
                }

                #endregion

                var returnResult = returnList.GroupBy(t => t.YearMonth).Select(u => new EnrollQuartDataDTO()
                {
                    ViewStr = u.Key,
                    EnrollCount = u.Sum(t => t.EnrollCount)
                }).ToList();

                return returnResult;
            }

        }

        public List<TrialDataRankDTO> GetTrialCountRank(int topCount)
        {
            var queryList = (from enrollDetail in _enrollDetailRepository.GetAll().Where(t =>
                    t.EnrollStatus == (int)EnrollStatus.ConfirmIntoGroup)
                             group enrollDetail by enrollDetail.DoctorId
                into g
                             select new
                             {
                                 ReviewerId = g.Key,
                                 TrialCount = g.Count()
                             }).OrderByDescending(u => u.TrialCount).Take(topCount).ToList();

            var trialDataRank = from stat in queryList
                                join doctor in _doctorRepository.GetAll() on stat.ReviewerId equals doctor.Id
                                select new TrialDataRankDTO()
                                {
                                    TrialCount = stat.TrialCount,
                                    ChineseName = doctor.ChineseName,
                                    FirstName = doctor.FirstName,
                                    LastName = doctor.LastName,
                                    ReviewerId = doctor.Id,
                                    ReviewerCode = doctor.Code
                                };
            return trialDataRank.ToList();

        }

        public List<LatestWorkLoadDTO> GetLatestWorkLoadList(int searchCount)
        {
            var workloadList = _workloadRepository.GetAll()
                .Where(t => t.DataFrom == (int)WorkLoadFromStatus.FinalConfirm &&
                            (t.Adjudication + t.AdjudicationIn24H + t.AdjudicationIn48H) > 0 &&
                            (t.Timepoint + t.TimepointIn24H + t.TimepointIn48H) > 0)
                .OrderByDescending(t => t.CreateTime).Take(searchCount).ToList();


            var reviewerList = from w in workloadList
                               join doctor in _doctorRepository.Find() on w.DoctorId equals doctor.Id into tt
                               from doctorItem in tt.DefaultIfEmpty()
                               join trial in _trialRepository.GetAll() on w.TrialId equals trial.Id into cc
                               from trialItem in cc.DefaultIfEmpty()
                               select new LatestWorkLoadDTO
                               {

                                   ReviewerId = w.DoctorId,
                                   Timepoint = w.Timepoint + w.TimepointIn48H + w.TimepointIn24H,
                                   Adjudication = w.Adjudication + w.AdjudicationIn48H + w.AdjudicationIn24H,
                                   Global = w.Global,
                                   ReviewerCode = doctorItem == null ? string.Empty : doctorItem.Code,
                                   FirstName = doctorItem == null ? string.Empty : doctorItem.FirstName,
                                   LastName = doctorItem == null ? string.Empty : doctorItem.LastName,
                                   ChineseName = doctorItem == null ? string.Empty : doctorItem.ChineseName,

                                   TrialCode = trialItem == null ? string.Empty : trialItem.Code
                               };
            return reviewerList.ToList();


        }



        #endregion

    }
}