using FellowOakDicom;
using IRaCIS.Application.Contracts;
using IRaCIS.Application.Interfaces;
using IRaCIS.Core.Application.Contracts.DTO;
using IRaCIS.Core.Application.Filter;
using IRaCIS.Core.Domain.Models;
using IRaCIS.Core.Domain.Share;
using MassTransit.Serialization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore.Storage.Json;
using System;

namespace IRaCIS.Core.Application.Service
{
    [ApiExplorerSettings(GroupName = "Trial")]
    public class TrialMaintenanceService(IRepository<TrialUserRole> _trialUseRoleRepository, IRepository<TrialIdentityUser> _trialIdentityUserRepository,
        IRepository<UserRole> _userRoleRepository,
        IRepository<TrialSiteUserRole> _trialSiteUserRoleRepository,
        IRepository<SubjectVisit> _subjectVisitRepository,
        IRepository<Trial> _trialRepository, IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer) : BaseService, ITrialMaintenanceService
    {

        [HttpGet]
        public async Task<List<TrialIdentityUserBasicInfo>> GetTrialUserList(Guid trialId)
        {
            return await _trialIdentityUserRepository.Where(t => t.TrialId == trialId, ignoreQueryFilters: true)
                  .Select(t => new TrialIdentityUserBasicInfo() { FullName = t.IdentityUser.FullName, IdentityUserId = t.IdentityUserId, UserName = t.IdentityUser.UserName })
                  .ToListAsync();
        }

        #region 多账户调整已修改
        /// <summary>
        /// Setting页面    获取项目参与人员列表
        /// </summary>
        /// <param name="inQuery"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<TrialIdentityUserDto>> GetMaintenanceUserList(TrialMaintenanceQuery inQuery)
        {
            var query = _trialIdentityUserRepository.Where(t => t.TrialId == inQuery.TrialId).IgnoreQueryFilters()
              .WhereIf(inQuery.UserTypeId != null, t => t.TrialUserRoleList.Any(t => t.UserRole.UserTypeId == inQuery.UserTypeId))
              .WhereIf(!string.IsNullOrWhiteSpace(inQuery.UserName), t => t.IdentityUser.UserName.Contains(inQuery.UserName))

               .WhereIf(inQuery.IsDeleted != null, t => t.IsDeleted == inQuery.IsDeleted)
              .WhereIf(!string.IsNullOrWhiteSpace(inQuery.OrganizationName), t => t.IdentityUser.OrganizationName.Contains(inQuery.OrganizationName))
              .WhereIf(!string.IsNullOrWhiteSpace(inQuery.UserRealName), t => (t.IdentityUser.FullName).Contains(inQuery.UserRealName))
              .Select(t => new TrialIdentityUserDto()
              {
                  Id = t.Id,
                  TrialId = t.TrialId,
                  IsDeleted = t.IsDeleted,
                  CreateTime = t.CreateTime,
                  EMail = t.IdentityUser.EMail,
                  FullName = t.IdentityUser.FullName,
                  IdentityUserId = t.IdentityUserId,
                  JoinTime = t.JoinTime,
                  OrganizationName = t.IdentityUser.OrganizationName,
                  Phone = t.IdentityUser.Phone,
                  UpdateTime = t.UpdateTime,
                  UserName = t.IdentityUser.UserName,
                  RemoveTime = t.RemoveTime,
                  Status = t.IdentityUser.Status,
                  TrialUserRoleList = t.TrialUserRoleList.Select(ur => new TrialIdentityUserRoleDto()
                  {
                      Id = ur.Id,
                      UserTypeShortName = ur.UserRole.UserTypeRole.UserTypeShortName,
                      IsUserRoleDisabled = ur.UserRole.IsUserRoleDisabled,
                      IsDeleted = ur.IsDeleted,
                      CreateTime = ur.CreateTime,
                      UserTypeEnum = ur.UserRole.UserTypeEnum,
                      UpdateTime = ur.UpdateTime
                  }).ToList()
              });

            return await query.ToPagedListAsync(inQuery, nameof(TrialIdentityUserDto.UpdateTime));
        }

        [TrialGlobalLimit("AfterStopCannNotOpt")]
        //[Authorize(Policy = IRaCISPolicy.PM_APM)]
        [HttpPut]
        public async Task<IResponseOutput> UpdateTrialUser(UpdateTrialUserCommand updateTrialUserCommand)
        {
            var trialUser = await _trialIdentityUserRepository.Where(t => t.Id == updateTrialUserCommand.Id, true, true).FirstOrDefaultAsync();

            if (trialUser == null) return Null404NotFound(trialUser);


            if (updateTrialUserCommand.IsDeleted)
            {
                //可以直接退出，不管中心下的CRC CRA 状态
                //if (await _trialSiteUserRoleRepository.AnyAsync(t => t.UserRole.IdentityUserId == trialUser.IdentityUserId && t.TrialId == trialUser.TrialId))
                //{
                //    // ----人员已加入现场维护
                //    return ResponseOutput.NotOk(_localizer["TrialMaint_PersonnelJoined"]);
                //}

                var findQC = await _trialUseRoleRepository.FirstOrDefaultAsync(t => t.UserRole.IdentityUserId == trialUser.IdentityUserId && t.UserRole.UserTypeEnum == UserTypeEnum.IQC);

                if (findQC != null)
                {
                    await _subjectVisitRepository.BatchUpdateNoTrackingAsync(t => t.CurrentActionUserId == findQC.Id && t.TrialId == trialUser.TrialId && t.IsTake, u => new SubjectVisit() { CurrentActionUserId = null, CurrentActionUserExpireTime = null, IsTake = false });
                }

            }

            _mapper.Map(updateTrialUserCommand, trialUser);

            await _trialUseRoleRepository.SaveChangesAsync();

            return ResponseOutput.Ok();


        }


        [HttpPut]
        public async Task<IResponseOutput> UpdateTrialUserRole(UpdateTrialUserRoleCommand updateCommand)
        {

            DateTime? deleteTime = updateCommand.IsDeleted ? DateTime.Now : null;

            await _trialUseRoleRepository.UpdatePartialFromQueryAsync(t => updateCommand.IdList.Contains(t.Id), u => new TrialUserRole() { IsDeleted = updateCommand.IsDeleted, DeletedTime = deleteTime }, true, true);

            return ResponseOutput.Ok();
        }

        /// <summary>
        /// 项目人员 邮件过期 重新发送邀请邮件
        /// </summary>
        /// <param name="incommand"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> TrialUserSendJoinEmail(TrialUserSendJoinEmailCommand incommand, [FromServices] IMailVerificationService _mailVerificationService)
        {

            var userTypeList = _trialIdentityUserRepository.Where(t => t.TrialId == incommand.TrialId && t.IdentityUserId == incommand.IdentityUserId).SelectMany(t => t.TrialUserRoleList).Select(t => t.UserRole.UserTypeRole.UserTypeName).ToList();

            var usertyps = string.Join(',', userTypeList);

            await _mailVerificationService.ExternalUserJoinEmail(incommand.TrialId, incommand.IdentityUserId, usertyps, incommand.BaseUrl, incommand.RouteUrl);

            return ResponseOutput.Ok();
        }



        /// <summary> Setting页面   项目参与人员勾选列表   </summary>
        [HttpPost]
        public async Task<PageOutput<TrialUserRoleScreeningDto>> GetTrialUserScreeningList(TrialUserQuery inQuery)
        {
            var trialType = _trialRepository.Where(t => t.Id == inQuery.TrialId).Select(t => t.TrialType).FirstOrDefault();

            var userTypeEnums = new List<UserTypeEnum>() { UserTypeEnum.ClinicalResearchCoordinator, UserTypeEnum.CRA, UserTypeEnum.IQC, UserTypeEnum.APM, UserTypeEnum.MIM, UserTypeEnum.QA, UserTypeEnum.MW, UserTypeEnum.MC };

            //if (_userInfo.UserTypeEnumInt == (int)UserTypeEnum.SuperAdmin)
            {
                userTypeEnums.Add(UserTypeEnum.ProjectManager);
            }


            //之前已经选择的用户 不放在列表中，现在又要改回去 废弃
            var query = _userRoleRepository.Where(t => t.UserTypeEnum != UserTypeEnum.SuperAdmin && t.IdentityUser.Status == UserStateEnum.Enable).IgnoreQueryFilters()

                 //正式或者培训的项目  不能允许测试用户（必须正式用户）  同时必须是内部的用户
                 .WhereIf(trialType == TrialType.OfficialTrial || trialType == TrialType.Training, t => t.IdentityUser.IsTestUser == false
                                                                                                && (t.IdentityUser.IsZhiZhun
                                                                                                  || t.UserTypeRole.UserTypeEnum == UserTypeEnum.IQC
                                                                                                  || t.UserTypeRole.UserTypeEnum == UserTypeEnum.MIM))

                 //测试项目 可以加入 测试用户  或者内部正式用户
                 .WhereIf(trialType == TrialType.NoneOfficial, t => t.IdentityUser.IsTestUser == true || (t.IdentityUser.IsTestUser == false && t.IdentityUser.IsZhiZhun))
                 .Where(t => userTypeEnums.Contains(t.UserTypeEnum))
                 .WhereIf(inQuery.UserTypeEnum != null, t => t.UserTypeEnum == inQuery.UserTypeEnum)
                 .WhereIf(!string.IsNullOrWhiteSpace(inQuery.UserRealName), t => t.IdentityUser.FullName.Contains(inQuery.UserRealName))
                 .WhereIf(!string.IsNullOrWhiteSpace(inQuery.UserName), t => t.IdentityUser.UserName.Contains(inQuery.UserName))
                  .WhereIf(!string.IsNullOrWhiteSpace(inQuery.EMail), t => t.IdentityUser.EMail.Contains(inQuery.EMail))
                 .WhereIf(!string.IsNullOrWhiteSpace(inQuery.OrganizationName), t => t.IdentityUser.OrganizationName.Contains(inQuery.OrganizationName))
                  .WhereIf(inQuery.IsUserRoleDisabled != null, t => t.IsUserRoleDisabled == inQuery.IsUserRoleDisabled)
                 .Select(t => new TrialUserRoleScreeningDto()
                 {
                     Id = t.Id,
                     TrialId = inQuery.TrialId,
                     IdentityUserId = t.IdentityUserId,
                     EMail = t.IdentityUser.EMail,
                     FullName = t.IdentityUser.FullName,
                     OrganizationName = t.IdentityUser.OrganizationName,
                     Phone = t.IdentityUser.Phone,
                     UserName = t.IdentityUser.UserName,
                     UserTypeShortName = t.UserTypeRole.UserTypeShortName,
                     IsSelect = t.UserRoleTrials.Any(t => t.TrialId == inQuery.TrialId),
                 });


            return await query.ToPagedListAsync(inQuery, nameof(TrialUserRoleScreeningDto.EMail));

        }

        #endregion


        /// <summary>
        /// Setting页面   批量添加项目参与人员
        /// </summary>
        /// <param name="userTrialCommands"></param>
        /// <returns></returns>
        //[TrialAudit(AuditType.TrialAudit, AuditOptType.AddTrialStaff)]
        [HttpPost]
        [TrialGlobalLimit("AfterStopCannNotOpt")]
        //[Authorize(Policy = IRaCISPolicy.PM_APM)]
        public async Task<IResponseOutput> AddTrialUsers(TrialUserAddCommand[] userTrialCommands)
        {
            foreach (var item in userTrialCommands.GroupBy(t => t.IdentityUserId))
            {
                var currentUserRoleList = item.ToList();

                var first = currentUserRoleList.FirstOrDefault();

                var findTrialuser = await _trialIdentityUserRepository.Where(t => t.TrialId == first.TrialId && t.IdentityUserId == item.Key, true, true).Include(t => t.TrialUserRoleList).FirstOrDefaultAsync();

                if (findTrialuser == null)
                {
                    var currentUser = new TrialIdentityUser()
                    {
                        TrialId = first.TrialId,
                        IdentityUserId = item.Key,
                        JoinTime = DateTime.Now,
                        TrialUserRoleList = currentUserRoleList.Select(t => new TrialUserRole() { UserId = t.UserId, TrialId = t.TrialId }).ToList()
                    };


                    await _trialIdentityUserRepository.AddAsync(currentUser);
                }
                else
                {
                    if (findTrialuser.IsDeleted == true)
                    {
                        findTrialuser.IsDeleted = false;
                        findTrialuser.DeletedTime = null;
                        findTrialuser.JoinTime = DateTime.Now;
                        findTrialuser.RemoveTime = null;
                    }

                    findTrialuser.TrialUserRoleList.AddRange(currentUserRoleList.Select(t => new TrialUserRole() { UserId = t.UserId, TrialId = t.TrialId, TrialUserId = findTrialuser.Id }).ToList());
                }



                var success = await _trialIdentityUserRepository.SaveChangesAsync();

            }

            return ResponseOutput.Ok();

        }





        /// <summary> Setting页面  为 site 勾选CRC用户列表</summary> 
        [HttpPost]
        public async Task<PageOutput<AssginSiteCRCListDTO>> GetSiteCRCScreeningList(SiteCRCQuery inQuery)
        {
            // 最开始过滤site已经选择的用户 现在又改回去。。。 

            var query = _trialUseRoleRepository.Where(t => t.TrialId == inQuery.TrialId).IgnoreQueryFilters()
                .Where(t => t.UserRole.UserTypeEnum == UserTypeEnum.ClinicalResearchCoordinator || t.UserRole.UserTypeEnum == UserTypeEnum.CRA)
                 .WhereIf(inQuery.UserTypeId != null, t => t.UserRole.UserTypeId == inQuery.UserTypeId)
                .WhereIf(!string.IsNullOrWhiteSpace(inQuery.UserRealName), t => (t.UserRole.IdentityUser.FullName).Contains(inQuery.UserRealName))
                .WhereIf(!string.IsNullOrWhiteSpace(inQuery.OrganizationName), t => t.UserRole.IdentityUser.OrganizationName.Contains(inQuery.OrganizationName))
                .ProjectTo<AssginSiteCRCListDTO>(_mapper.ConfigurationProvider, new { trialSiteId = inQuery.TrialSiteId });

            return await query.ToPagedListAsync(inQuery);

        }




    }
}