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

namespace IRaCIS.Core.Application.Trial.WorkloadDistribution
{
    public class WorkloadDistributionService : IWorkloadDistributionService
    {
        private readonly IWorkloadTPRepository _workloadTpRepository;
        private readonly IWorkloadGlobalRepository _workloadGlobalRepository;
        private readonly IWorkloadADRepository _workloadAdRepository;
        private readonly ISubjectVisitRepository _subjectVisitRepository;
        private readonly IDicomStudyRepository _studyRepository;
        private readonly IDoctorRepository _doctorRepository;
        private readonly ISubjectRepository _subjectRepository;
        private readonly ISiteRepository _siteRepository;
        private readonly IWorkloadDetailRepository _workloadDetailRepository;
        private readonly IUserInfo _userInfo;

        public WorkloadDistributionService(IWorkloadTPRepository workloadTpRepository,
            IWorkloadGlobalRepository workloadGlobalRepository,
            IWorkloadADRepository workloadAdRepository,
            ISubjectVisitRepository subjectVisitRepository, IDicomStudyRepository studyRepository,
            IDoctorRepository doctorRepository, ISubjectRepository subjectRepository,
            ISiteRepository siteRepository,
            IWorkloadDetailRepository workloadDetailRepository,
            IUserInfo userInfo)
        {
            _workloadTpRepository = workloadTpRepository;
            _workloadGlobalRepository = workloadGlobalRepository;
            _workloadAdRepository = workloadAdRepository;
            _subjectVisitRepository = subjectVisitRepository;
            _studyRepository = studyRepository;
            _doctorRepository = doctorRepository;
            _subjectRepository = subjectRepository;
            _siteRepository = siteRepository;
            _workloadDetailRepository = workloadDetailRepository;
            _userInfo = userInfo;
        }

        public IResponseOutput DistributeTP(WorkloadTPCommand workloadTPCommand)
        {
            //当前采用的是没有提示到具体的TP，如有需要在修改下
            var studyIdList = workloadTPCommand.TpList.Select(u => u.StudyId);
            var temp = _workloadTpRepository.Find(u => studyIdList.Contains(u.StudyId) && u.ReviewerId == workloadTPCommand.ReviewerId);
            if (temp.Count() > 0)
            {
                return ResponseOutput.NotOk("把相同Study的不同TP 分配给同一个医生了，无法保存");
            }
            var success = false;
            workloadTPCommand.TpList.ForEach(t =>
            {
                _workloadDetailRepository.Add(new WorkloadDetail
                {
                    WorkloadId = t.Id,
                    OptUserName = _userInfo.RealName,
                    OptTime = DateTime.Now,
                    Status = (int)WorkloadStatus.Distributed,
                    ReviewerId = workloadTPCommand.ReviewerId
                });
                _workloadDetailRepository.SaveChanges();
                success = _workloadTpRepository.Update(u => u.Id == t.Id, k => new WorkloadTP()
                {
                    ReviewerId = workloadTPCommand.ReviewerId,
                    Status = (int)WorkloadStatus.Distributed
                });
            });
            return ResponseOutput.Result(success);
        }

        public bool DistributeAD(WorkloadAdCommand workloadTPCommand)
        {
            var success = false;
            workloadTPCommand.IdList.ForEach(t =>
            {
                _workloadDetailRepository.Add(new WorkloadDetail
                {
                    WorkloadId = t,
                    OptUserName = _userInfo.RealName,
                    OptTime = DateTime.Now,
                    Status = (int)WorkloadStatus.Distributed,
                    ReviewerId = workloadTPCommand.ReviewerId
                });
                _workloadDetailRepository.SaveChanges();
                success = _workloadAdRepository.Update(u => u.Id == t, k => new WorkloadAD()
                {
                    ReviewerId = workloadTPCommand.ReviewerId,
                    Status = (int)WorkloadStatus.Distributed
                });
            });
            return success;
        }

        public IResponseOutput DistributeGlobal(WorkloadGlobalCommand workloadGCommand)
        {
            var temp = _workloadGlobalRepository.Find(u => workloadGCommand.GlobalList.Select(s => s.SubjectId).Contains(u.SubjectId)
            && workloadGCommand.GlobalList.Select(s => s.VisitNum).Contains(u.VisitNum) &&
            u.ReviewerId == workloadGCommand.ReviewerId);
            if (temp.Count() > 0)
            {
                return ResponseOutput.NotOk("不能把相同受试者Global分配给相同的Reviewer");
            }

            var success = false;
            workloadGCommand.GlobalList.ForEach(t =>
            {
                _workloadDetailRepository.Add(new WorkloadDetail
                {
                    WorkloadId = t.Id,
                    OptUserName = _userInfo.RealName,
                    OptTime = DateTime.Now,
                    Status = (int)WorkloadStatus.Distributed,
                    ReviewerId = workloadGCommand.ReviewerId
                });
                _workloadDetailRepository.SaveChanges();
                success = _workloadGlobalRepository.Update(u => u.Id == t.Id, k => new WorkloadGlobal()
                {
                    ReviewerId = workloadGCommand.ReviewerId,
                    Status = (int)WorkloadStatus.Distributed
                });
            });
            return ResponseOutput.Result(success);
        }

        public PageOutput<WorkloadGlobalDTO> GetWorkloadGlobalList(WorkloadDistributionQueryParam param)
        {
            IQueryable<WorkloadGlobalDTO> query = null;
            Expression<Func<WorkloadGlobal, bool>> workloadTPLambda = x => x.TrialId == param.TrialId;
            if (param.SiteId != null)
            {
                workloadTPLambda = workloadTPLambda.And(t => t.SiteId == param.SiteId);
            }

            if (param.Status != null)
            {
                workloadTPLambda = workloadTPLambda.And(t => t.Status == param.Status);
            }
            if (!string.IsNullOrEmpty(param.WorkloadCode))
            {
                var globalCode = param.WorkloadCode.Trim();
                workloadTPLambda = workloadTPLambda.And(t => t.GlobalCode.Contains(globalCode));
            }
            if (param.GroupId != null && param.GroupId > 0)
            {
                var groupCode = "G0" + param.GroupId;
                workloadTPLambda = workloadTPLambda.And(t => t.GlobalCode.Contains(groupCode));
            }

            Expression<Func<Subject, bool>> subjectLambda = x => x.TrialId == param.TrialId;
            if (!string.IsNullOrEmpty(param.SubjectCode))
            {
                var subjectCode = param.SubjectCode.Trim();
                subjectLambda = subjectLambda.And(t => t.Code.Contains(subjectCode));
            }
            Expression<Func<Doctor, bool>> doctorLambda = x => true;
            if (!string.IsNullOrEmpty(param.Reviewer))
            {
                var reviewer = param.Reviewer.Trim();

                doctorLambda = doctorLambda.And(t => t.ChineseName.Contains(reviewer)
                                                     || t.FirstName.Contains(reviewer) || t.LastName.Contains(reviewer));
                query = from workloadG in _workloadGlobalRepository.GetAll().Where(workloadTPLambda)
                        join subject in _subjectRepository.GetAll().Where(subjectLambda) on workloadG.SubjectId equals subject.Id
                        join site in _siteRepository.GetAll() on workloadG.SiteId equals site.Id
                        join doctor in _doctorRepository.GetAll().Where(doctorLambda) on workloadG.ReviewerId equals doctor.Id
                        select new WorkloadGlobalDTO()
                        {
                            Id = workloadG.Id,
                            ReviewerCode = doctor.Code,
                            ReviewerChineseName = doctor.ChineseName,
                            ReviewerFirstName = doctor.FirstName,
                            ReviewerId = doctor.Id,
                            ReviewerLastName = doctor.LastName,
                            SiteId = workloadG.SiteId,
                            SiteName = site.SiteName,
                            Status = workloadG.Status,
                            GlobalCode = workloadG.GlobalCode,
                            SubjectCode = subject.Code,
                            VisitId = workloadG.VisitId,
                            UpdateTime = workloadG.UpdateTime,
                            SubjectId = workloadG.SubjectId,
                            VisitNum = workloadG.VisitNum,
                            VisitName = workloadG.VisitName
                        };
            }
            else
            {
                query = from workloadG in _workloadGlobalRepository.GetAll().Where(workloadTPLambda)
                        join subject in _subjectRepository.GetAll().Where(subjectLambda) on workloadG.SubjectId equals subject.Id
                        join site in _siteRepository.GetAll() on workloadG.SiteId equals site.Id
                        join doctor in _doctorRepository.GetAll().Where(doctorLambda) on workloadG.ReviewerId equals doctor.Id into cc
                        from doctor in cc.DefaultIfEmpty()
                        select new WorkloadGlobalDTO()
                        {
                            Id = workloadG.Id,
                            ReviewerCode = doctor.Code,
                            ReviewerChineseName = doctor.ChineseName,
                            ReviewerFirstName = doctor.FirstName,
                            ReviewerId = doctor.Id,
                            ReviewerLastName = doctor.LastName,
                            SiteId = workloadG.SiteId,
                            SiteName = site.SiteName,
                            Status = workloadG.Status,
                            GlobalCode = workloadG.GlobalCode,
                            SubjectCode = subject.Code,
                            VisitId = workloadG.VisitId,
                            UpdateTime = workloadG.UpdateTime,
                            SubjectId = workloadG.SubjectId,
                            VisitNum = workloadG.VisitNum,
                            VisitName = workloadG.VisitName
                        };
            }

            var count = query.Count();

            var propName = param.SortField == string.Empty ? "GlobalCode" : param.SortField;

            query = param.Asc
                ? query.OrderBy(propName).ThenBy(t => t.SiteName).ThenBy(t => t.SubjectCode)
                : query.OrderByDescending(propName).ThenBy(t => t.SiteName).ThenBy(t => t.SubjectCode);

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

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

        public PageOutput<WorkloadADDTO> GetWorkloadADList(WorkloadDistributionQueryParam param)
        {
            IQueryable<WorkloadADDTO> query = null;
            Expression<Func<WorkloadAD, bool>> workloadAdLambda = x => x.TrialId == param.TrialId;
            if (param.SiteId != null)
            {
                workloadAdLambda = workloadAdLambda.And(t => t.SiteId == param.SiteId);
            }

            if (param.Status != null)
            {
                workloadAdLambda = workloadAdLambda.And(t => t.Status == param.Status);
            }
            if (!string.IsNullOrEmpty(param.WorkloadCode))
            {
                var adCode = param.WorkloadCode.Trim();
                workloadAdLambda = workloadAdLambda.And(t => t.ADCode.Contains(adCode));
            }

            Expression<Func<Subject, bool>> subjectLambda = x => x.TrialId == param.TrialId;
            if (!string.IsNullOrEmpty(param.SubjectCode))
            {
                var subjectCode = param.SubjectCode.Trim();
                subjectLambda = subjectLambda.And(t => t.Code.Contains(subjectCode));

            }
            Expression<Func<Doctor, bool>> doctorLambda = x => true;
            if (!string.IsNullOrEmpty(param.Reviewer))
            {
                var reviewer = param.Reviewer.Trim();
                doctorLambda = doctorLambda.And(t => t.ChineseName.Contains(reviewer)
                                                     || t.FirstName.Contains(reviewer) || t.LastName.Contains(reviewer));
                query = from workloadAd in _workloadAdRepository.GetAll().Where(workloadAdLambda)
                        join subject in _subjectRepository.GetAll().Where(subjectLambda) on workloadAd.SubjectId equals subject.Id
                        join site in _siteRepository.GetAll() on workloadAd.SiteId equals site.Id
                        join doctor in _doctorRepository.GetAll().Where(doctorLambda) on workloadAd.ReviewerId equals doctor.Id
                        select new WorkloadADDTO()
                        {
                            Id = workloadAd.Id,
                            ReviewerCode = doctor.Code,
                            ReviewerChineseName = doctor.ChineseName,
                            ReviewerFirstName = doctor.FirstName,
                            ReviewerId = doctor.Id,
                            ReviewerLastName = doctor.LastName,
                            SiteId = workloadAd.SiteId,
                            SiteName = site.SiteName,
                            Status = workloadAd.Status,
                            ADCode = workloadAd.ADCode,
                            SubjectCode = subject.Code,
                            SubjectId = workloadAd.SubjectId,
                            UpdateTime = workloadAd.UpdateTime
                        };
            }
            else
            {
                query = from workloadAd in _workloadAdRepository.GetAll().Where(workloadAdLambda)
                        join subject in _subjectRepository.GetAll().Where(subjectLambda) on workloadAd.SubjectId equals subject.Id

                        join site in _siteRepository.GetAll() on workloadAd.SiteId equals site.Id
                        join doctor in _doctorRepository.GetAll().Where(doctorLambda) on workloadAd.ReviewerId equals doctor.Id into cc
                        from doctor in cc.DefaultIfEmpty()
                        select new WorkloadADDTO()
                        {
                            Id = workloadAd.Id,
                            ReviewerCode = doctor.Code,
                            ReviewerChineseName = doctor.ChineseName,
                            ReviewerFirstName = doctor.FirstName,
                            ReviewerId = doctor.Id,
                            ReviewerLastName = doctor.LastName,
                            SiteId = workloadAd.SiteId,
                            SiteName = site.SiteName,
                            Status = workloadAd.Status,
                            ADCode = workloadAd.ADCode,
                            SubjectCode = subject.Code,
                            SubjectId = workloadAd.SubjectId,
                            UpdateTime = workloadAd.UpdateTime
                        };

            }
            var count = query.Count();

            var propName = param.SortField == string.Empty ? "ADCode" : param.SortField;

            query = param.Asc
                ? query.OrderBy(propName).ThenBy(t => t.SiteName).ThenBy(t => t.SubjectCode)
                : query.OrderByDescending(propName).ThenBy(t => t.SiteName).ThenBy(t => t.SubjectCode);

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

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

        public PageOutput<WorkloadTPDTO> GetWorkloadTPList(WorkloadDistributionQueryParam param)
        {
            IQueryable<WorkloadTPDTO> query = null;
            Expression<Func<WorkloadTP, bool>> workloadTPLambda = x => x.TrialId == param.TrialId;
            if (param.SiteId != null)
            {
                workloadTPLambda = workloadTPLambda.And(t => t.SiteId == param.SiteId);
            }

            if (param.Status != null)
            {
                workloadTPLambda = workloadTPLambda.And(t => t.Status == param.Status);
            }
            if (!string.IsNullOrEmpty(param.WorkloadCode))
            {
                var timepoint = param.WorkloadCode.Trim();

                workloadTPLambda = workloadTPLambda.And(t => t.TimepointCode.Contains(timepoint));
            }
            if (param.GroupId != null && param.GroupId > 0)
            {
                var groupCode = "T0" + param.GroupId;
                workloadTPLambda = workloadTPLambda.And(t => t.TimepointCode.Contains(groupCode));
            }

            Expression<Func<Subject, bool>> subjectLambda = x => x.TrialId == param.TrialId;
            if (!string.IsNullOrEmpty(param.SubjectCode))
            {
                var subjectCode = param.SubjectCode.Trim();
                subjectLambda = subjectLambda.And(t => t.Code.Contains(subjectCode));
            }
            Expression<Func<Doctor, bool>> doctorLambda = x => true;
            if (!string.IsNullOrEmpty(param.Reviewer))
            {
                var reviewer = param.Reviewer.Trim();
                doctorLambda = doctorLambda.And(t => t.ChineseName.Contains(reviewer)
                                                     || t.FirstName.Contains(reviewer) || t.LastName.Contains(reviewer));
                query = from workloadTp in _workloadTpRepository.GetAll().Where(workloadTPLambda)
                        join subject in _subjectRepository.GetAll().Where(subjectLambda) on workloadTp.SubjectId equals subject.Id
                        join subjectVisit in _subjectVisitRepository.GetAll() on workloadTp.SubjectVisitId equals subjectVisit.Id
                        join study in _studyRepository.GetAll() on workloadTp.StudyId equals study.Id
                        join site in _siteRepository.GetAll() on workloadTp.SiteId equals site.Id
                        join doctor in _doctorRepository.GetAll().Where(doctorLambda) on workloadTp.ReviewerId equals doctor.Id

                        select new WorkloadTPDTO()
                        {
                            Id = workloadTp.Id,
                            ReviewerCode = doctor.Code,
                            ReviewerChineseName = doctor.ChineseName,
                            ReviewerFirstName = doctor.FirstName,
                            ReviewerId = doctor.Id,
                            ReviewerLastName = doctor.LastName,
                            SiteId = workloadTp.SiteId,
                            SiteName = site.SiteName,
                            Status = workloadTp.Status,
                            StudyCode = study.StudyCode,
                            StudyId = workloadTp.StudyId,
                            TimepointCode = workloadTp.TimepointCode,
                            SubjectCode = subject.Code,
                            SubjectVisitId = workloadTp.SubjectVisitId,
                            SubjectId = workloadTp.SubjectId,
                            VisitNum = subjectVisit.VisitNum,
                            VisitName = subjectVisit.VisitName,
                            UpdateTime = workloadTp.UpdateTime
                        };
            }
            else
            {
                query = from workloadTp in _workloadTpRepository.GetAll().Where(workloadTPLambda)
                        join subject in _subjectRepository.GetAll().Where(subjectLambda) on workloadTp.SubjectId equals subject.Id
                        join subjectVisit in _subjectVisitRepository.GetAll() on workloadTp.SubjectVisitId equals subjectVisit.Id
                        join study in _studyRepository.GetAll() on workloadTp.StudyId equals study.Id
                        join site in _siteRepository.GetAll() on workloadTp.SiteId equals site.Id
                        join doctor in _doctorRepository.GetAll().Where(doctorLambda) on workloadTp.ReviewerId equals doctor.Id into cc
                        from doctor in cc.DefaultIfEmpty()
                        select new WorkloadTPDTO()
                        {
                            Id = workloadTp.Id,
                            ReviewerCode = doctor.Code,
                            ReviewerChineseName = doctor.ChineseName,
                            ReviewerFirstName = doctor.FirstName,
                            ReviewerId = doctor.Id,
                            ReviewerLastName = doctor.LastName,
                            SiteId = workloadTp.SiteId,
                            SiteName = site.SiteName,
                            Status = workloadTp.Status,
                            StudyCode = study.StudyCode,
                            StudyId = workloadTp.StudyId,
                            TimepointCode = workloadTp.TimepointCode,
                            SubjectCode = subject.Code,
                            SubjectVisitId = workloadTp.SubjectVisitId,
                            SubjectId = workloadTp.SubjectId,
                            VisitNum = subjectVisit.VisitNum,
                            VisitName = subjectVisit.VisitName,
                            UpdateTime = workloadTp.UpdateTime
                        };

            }
            var count = query.Count();

            var propName = param.SortField == string.Empty ? "TimepointCode" : param.SortField;
            query = param.Asc
                ? query.OrderBy(propName).ThenBy(t => t.SiteName).ThenBy(t => t.SubjectCode)
                : query.OrderByDescending(propName).ThenBy(t => t.SiteName).ThenBy(t => t.SubjectCode);
            query = query.Skip((param.PageIndex - 1) * param.PageSize).Take(param.PageSize);
            var list = query.ToList();

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

        public bool UpdateDistributeAD(Guid tpId, Guid reviewerId)
        {
            _workloadDetailRepository.Add(new WorkloadDetail
            {
                WorkloadId = tpId,
                OptUserName = _userInfo.RealName,
                OptTime = DateTime.Now,
                Status = (int)WorkloadStatus.Distributed,
                ReviewerId = reviewerId
            });
            _workloadDetailRepository.SaveChanges();
            return _workloadAdRepository.Update(t => t.Id == tpId, u => new WorkloadAD()
            {
                ReviewerId = reviewerId,
                Status = (int)WorkloadStatus.Distributed
            });
        }

        public IResponseOutput UpdateDistributeGlobal(Guid tpId, Guid reviewerId, Guid subjectId, decimal visitNum)
        {
            var temp = _workloadGlobalRepository.Find(u => u.SubjectId == subjectId &&
            u.VisitNum == visitNum &&
            u.ReviewerId == reviewerId && u.Id != tpId);
            if (temp.Count() > 0)
            {
                return ResponseOutput.NotOk("已经有相同的Global 分配给该医生了，无法继续分配。");
            }

            _workloadDetailRepository.Add(new WorkloadDetail
            {
                WorkloadId = tpId,
                OptUserName = _userInfo.RealName,
                OptTime = DateTime.Now,
                Status = (int)WorkloadStatus.Distributed,
                ReviewerId = reviewerId
            });
            _workloadDetailRepository.SaveChanges();
            return ResponseOutput.Result(_workloadGlobalRepository.Update(t => t.Id == tpId, u => new WorkloadGlobal()
            {
                ReviewerId = reviewerId,
                Status = (int)WorkloadStatus.Distributed
            }));
        }

        public IResponseOutput UpdateDistributeTP(Guid tpId, Guid reviewerId, Guid studyId)
        {
            var temp = _workloadTpRepository.Find(u => u.StudyId == studyId && u.ReviewerId == reviewerId && u.Id != tpId);
            if (temp.Count() > 0)
            {
                return ResponseOutput.NotOk("当前Study的另一个TP已经分配给该Reviewer了，无法继续分配。");
            }

            _workloadDetailRepository.Add(new WorkloadDetail
            {
                WorkloadId = tpId,
                OptUserName = _userInfo.RealName,
                OptTime = DateTime.Now,
                Status = (int)WorkloadStatus.Distributed,
                ReviewerId = reviewerId
            });
            _workloadDetailRepository.SaveChanges();
            return ResponseOutput.Result(_workloadTpRepository.Update(t => t.Id == tpId, u => new WorkloadTP()
            {
                ReviewerId = reviewerId,
                Status = (int)WorkloadStatus.Distributed
            }));
        }

        public IResponseOutput<List<WorkloadDetailDTO>> GetWorkloadDetail(Guid WorkloadId)
        {
            IQueryable<WorkloadDetailDTO> query = null;
            query = from detail in _workloadDetailRepository.GetAll().Where(u => u.WorkloadId == WorkloadId)
                    join doctor in _doctorRepository.GetAll() on detail.ReviewerId equals doctor.Id into cc
                    from doctor in cc.DefaultIfEmpty()
                    select new WorkloadDetailDTO()
                    {
                        OptTime = detail.OptTime,
                        OptUserName = detail.OptUserName,
                        ReviewerChineseName = doctor.ChineseName,
                        ReviewerFirstName = doctor.FirstName,
                        ReviewerLastName = doctor.LastName,
                        Status = detail.Status
                    };
            var list = query.OrderByDescending(u => u.OptTime).ToList();
            return ResponseOutput.Ok(list);
        }

        public IResponseOutput UpdateGlobalStatus(Guid globalId)
        {
            return ResponseOutput.Result(_workloadGlobalRepository.Update(u => u.Id == globalId, t => new WorkloadGlobal()
            {
                Status = 0
            }));
        }

    }
}