//--------------------------------------------------------------------
//     此代码由T4模板自动生成  byzhouhang 20210918
//	   生成时间 2022-06-07 13:14:38 
//     对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------

using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Application.Contracts;

namespace IRaCIS.Core.Application.Service
{
    /// <summary>
    /// 分配规则
    /// </summary>	
    [ApiExplorerSettings(GroupName = "Trial")]
    public class TaskAllocationRuleService : BaseService, ITaskAllocationRuleService
    {

        private readonly IRepository<TaskAllocationRule> _taskAllocationRuleRepository;
        private readonly IRepository<User> _userRepository;

        private readonly IRepository<Trial> _trialRepository;

        

        public TaskAllocationRuleService(IRepository<TaskAllocationRule> taskAllocationRuleRepository, IRepository<User> userRepository, IRepository<Trial> trialRepository)
        {
            _taskAllocationRuleRepository = taskAllocationRuleRepository;
            _userRepository = userRepository;
            _trialRepository= trialRepository;
        }

        [HttpPost]
        public async Task<(List<TaskAllocationRuleView>,object)> GetTaskAllocationRuleList(TaskAllocationRuleQuery queryTaskAllocationRule)
        {
            var taskAllocationRuleQueryable = _taskAllocationRuleRepository.Where(t=>t.TrialId== queryTaskAllocationRule.TrialId)
                .WhereIf(queryTaskAllocationRule.IsJudgeDoctor!=null  ,t=>t.IsJudgeDoctor== queryTaskAllocationRule.IsJudgeDoctor)
             .ProjectTo<TaskAllocationRuleView>(_mapper.ConfigurationProvider);


            var trialTaskConfig= _trialRepository.Where(t=>t.Id==queryTaskAllocationRule.TrialId).ProjectTo<TrialTaskConfigView>(_mapper.ConfigurationProvider).FirstOrDefault();

            return (await taskAllocationRuleQueryable.ToListAsync(), trialTaskConfig);
        }


        /// <summary>
        /// 获取应用Subject后  医生比率情况
        /// </summary>
        /// <returns></returns>
       [HttpPost]
        public async Task<List<TaskAllocationRuleView>> GetSubjectApplyDoctorTaskStatList(ApplySubjectCommand assignConfirmCommand)
        {
            var taskAllocationRuleQueryable = _taskAllocationRuleRepository.Where(t => t.TrialId == assignConfirmCommand.TrialId)
                .WhereIf(assignConfirmCommand.IsJudgeDoctor != null, t => t.IsJudgeDoctor == assignConfirmCommand.IsJudgeDoctor)
            .ProjectTo<TaskAllocationRuleView>(_mapper.ConfigurationProvider, new { subjectIdList = assignConfirmCommand.SubjectIdList });

            return  await taskAllocationRuleQueryable.ToListAsync();
        }
       


        public async Task<IResponseOutput> AddOrUpdateTaskAllocationRule(TaskAllocationRuleAddOrEdit addOrEditTaskAllocationRule)
        {
            var verifyExp1 = new EntityVerifyExp<TaskAllocationRule>()
            {
                VerifyExp = t => t.DoctorUserId == addOrEditTaskAllocationRule.DoctorUserId && t.TrialId== addOrEditTaskAllocationRule.TrialId,
                VerifyMsg = "已有该医生配置，不允许继续增加"
            };

            var entity = await _taskAllocationRuleRepository.InsertOrUpdateAsync(addOrEditTaskAllocationRule, true, verifyExp1);

            return ResponseOutput.Ok(entity.Id.ToString());

        }


        [HttpDelete("{taskAllocationRuleId:guid}/{isJudgeDoctor:bool}")]
        public async Task<IResponseOutput> DeleteTaskAllocationRule(Guid taskAllocationRuleId, bool isJudgeDoctor )
        {
            if(await _taskAllocationRuleRepository.Where(t => t.Id == taskAllocationRuleId && t.IsJudgeDoctor== isJudgeDoctor).AnyAsync(t => t.DoctorVisitTaskList.Count() > 0))
            {
                return ResponseOutput.NotOk("已分配任务给该医生，不允许删除");
            }

            var success = await _taskAllocationRuleRepository.DeleteFromQueryAsync(t => t.Id == taskAllocationRuleId, true);


            return ResponseOutput.Ok();
        }

        /// <summary>
        /// 获取项目下 医生账户信息下拉
        /// </summary>
        /// <param name="trialId"></param>
        /// <param name="_enrollRepository"></param>
        /// <returns></returns>
        [HttpGet("{trialId:guid}")]
        public async Task<List<TrialDoctorUserSelectView>> GetDoctorUserSelectList(Guid trialId,[FromServices]  IRepository<Enroll> _enrollRepository)
        {
            var query = from enroll in _enrollRepository.Where(t => t.TrialId == trialId)
                        join user in _userRepository.AsQueryable() on enroll.DoctorId equals user.DoctorId
                        select new TrialDoctorUserSelectView()
                        {
                            TrialId = enroll.TrialId,
                            ReadingType=enroll.Trial.ReadingType,
                            DoctorUserId= user.Id,
                            FullName=user.FullName,
                            UserCode=user.UserCode,
                            UserName=user.UserName,
                            UserTypeEnum=user.UserTypeRole.UserTypeEnum
                        };

            return query.ToList();
        }


    }
}