using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Schedulings;
using Hotline.Share.Dtos.File;
using Hotline.Share.Dtos;
using Microsoft.AspNetCore.Mvc;
using XF.Domain.Authentications;
using XF.Domain.Exceptions;
using XF.Domain.Repository;
using Hotline.Share.Dtos.Schedulings;
using MapsterMapper;
using Hotline.Users;

namespace Hotline.Api.Controllers
{
	public class SchedulingController : BaseController
	{
		private readonly IRepository<Scheduling> _schedulingRepository;
		private readonly IRepository<SchedulingShift> _schedulingShiftRepository;
		private readonly IRepository<SchedulingUser> _schedulingUserRepository;
		private readonly IMapper _mapper;

		public SchedulingController(
			IRepository<Scheduling> schedulingRepository,
			IRepository<SchedulingShift> schedulingShiftRepository,
			IRepository<SchedulingUser> schedulingUserRepository,
			IMapper mapper
			) {
			_schedulingRepository = schedulingRepository;
			_schedulingShiftRepository = schedulingShiftRepository;
			_schedulingUserRepository = schedulingUserRepository;
			_mapper= mapper;
		}
		#region 排班人员

		/// <summary>
		/// 新增排班人员
		/// </summary>
		/// <param name="dtos"></param>
		/// <returns></returns>
		[HttpPost("user")]
		public async Task Add([FromBody] List<SchedulingUserDto> dtos)
		{
			List<SchedulingUser> user = new List<SchedulingUser>();
			foreach (var dto in dtos)
			{
				if (string.IsNullOrEmpty(dto.UserId))
					throw UserFriendlyException.SameMessage("请带上用户信息");

				var model = _mapper.Map<SchedulingUser>(dto);
				user.Add(model);
			}
			await _schedulingUserRepository.AddRangeAsync(user, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 删除排班人员
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpDelete("user")]
		public async Task Delete([FromBody] UserDeleteDto dto)
		{
			foreach (var Id in dto.Ids)
			{
				await _schedulingUserRepository.RemoveAsync(x => x.Id == Id);
			}
		}

		/// <summary>
		/// 更新排班人员
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpPut("user")]
		public async Task Update([FromBody] UserUpdateDto dto)
		{
			var user = await _schedulingUserRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
			if (user is null)
				throw UserFriendlyException.SameMessage("无效排班人员");
			_mapper.Map(dto, user);
			await _schedulingUserRepository.UpdateAsync(user, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 批量更新排班人员
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpPut("batch_user")]
		public async Task Update([FromBody] List<UserUpdateDto> dto)
		{
			List<SchedulingUser> users = new List<SchedulingUser>();
			foreach (var item in dto)
			{
				var user = await _schedulingUserRepository.GetAsync(item.Id, HttpContext.RequestAborted);
				if (user is null)
					throw UserFriendlyException.SameMessage("无效排班人员");
				_mapper.Map(dto, user);
				users.Add(user);
			}
			await _schedulingUserRepository.UpdateRangeAsync(users, HttpContext.RequestAborted);
		}


		/// <summary>
		/// 获取排班人员列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpGet("user_list")]
		public async Task<PagedDto<SchedulingUser>> List([FromQuery] UserListDto dto)
		{
			var (total, items) = await _schedulingUserRepository.Queryable()
				.WhereIF(!string.IsNullOrEmpty(dto.Keyword), x => x.UserName.Contains(dto.Keyword!))
				.OrderByDescending(x => x.CreationTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<SchedulingUser>(total, items);
		}

		/// <summary>
		/// 获取排班人员实体
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[HttpGet("user/{id}")]
		public async Task<SchedulingUser> UserEntity(string id)
		{
			return await _schedulingUserRepository.Queryable()
				.FirstAsync(x => x.Id == id);
		}

		#endregion

		#region 班次管理

		/// <summary>
		/// 新增班次管理
		/// </summary>
		/// <param name="dtos"></param>
		/// <returns></returns>
		[HttpPost("shift")]
		public async Task Add([FromBody] SchedulingShiftDto dto)
		{
			var model = _mapper.Map<SchedulingShift>(dto);
			await _schedulingShiftRepository.AddAsync(model, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 删除班次管理
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpDelete("shift")]
		public async Task Delete([FromBody] ShiftDeleteDto dto)
		{
			foreach (var Id in dto.Ids)
			{
				await _schedulingShiftRepository.RemoveAsync(x => x.Id == Id);
			}
		}

		/// <summary>
		/// 更新班次管理
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpPut("shift")]
		public async Task Update([FromBody] ShiftUpdateDto dto)
		{
			var user = await _schedulingShiftRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
			if (user is null)
				throw UserFriendlyException.SameMessage("无效班次信息");
			_mapper.Map(dto, user);
			await _schedulingShiftRepository.UpdateAsync(user, HttpContext.RequestAborted);
		}


		/// <summary>
		/// 获取班次管理列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpGet("shift_list")]
		public async Task<PagedDto<SchedulingShift>> List([FromQuery] ShiftListDto dto)
		{
			var (total, items) = await _schedulingShiftRepository.Queryable()
				.WhereIF(!string.IsNullOrEmpty(dto.Keyword), x => x.Name.Contains(dto.Keyword!))
				.OrderByDescending(x => x.CreationTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<SchedulingShift>(total, items);
		}

		/// <summary>
		/// 获取班次管理实体
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[HttpGet("shift/{id}")]
		public async Task<SchedulingShift> ShiftEntity(string id)
		{
			return await _schedulingShiftRepository.Queryable()
				.FirstAsync(x => x.Id == id);
		}
		#endregion

		#region 排班管理
		/// <summary>
		/// 新增排班人员
		/// </summary>
		/// <param name="dtos"></param>
		/// <returns></returns>
		[HttpPost]
		public async Task Add([FromBody] List<SchedulingDto> dtos)
		{
			List<Scheduling> schedulings = new List<Scheduling>();
			foreach (var dto in dtos)
			{
				if (string.IsNullOrEmpty(dto.SchedulingUserId))
					throw UserFriendlyException.SameMessage("请传入排班用户信息");
				if (string.IsNullOrEmpty(dto.ShiftId))
					throw UserFriendlyException.SameMessage("请传入排班班次信息");

				var scheduling = _mapper.Map<Scheduling>(dto);
				scheduling.SendOrderNum = 0;
				schedulings.Add(scheduling);
			}
			await _schedulingRepository.AddRangeAsync(schedulings, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 删除排班人员
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpDelete]
		public async Task Delete([FromBody] DeleteDto dto)
		{
			foreach (var Id in dto.Ids)
			{
				await _schedulingRepository.RemoveAsync(x => x.Id == Id);
			}
		}

		/// <summary>
		/// 更新排班人员
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpPut]
		public async Task Update([FromBody] UpdateDto dto)
		{
			var scheduling = await _schedulingRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
			if (scheduling is null)
				throw UserFriendlyException.SameMessage("无效排班信息");
			_mapper.Map(dto, scheduling);
			await _schedulingRepository.UpdateAsync(scheduling, HttpContext.RequestAborted);
		}

		/// <summary>
		/// 批量更新排班人员
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpPut("batch")]
		public async Task Update([FromBody] List<UpdateDto> dto)
		{
			List<Scheduling> schedulings = new List<Scheduling>();
			foreach (var item in dto)
			{
				var scheduling = await _schedulingRepository.GetAsync(item.Id, HttpContext.RequestAborted);
				if (scheduling is null)
					throw UserFriendlyException.SameMessage("无效排班信息");
				_mapper.Map(dto, scheduling);
				schedulings.Add(scheduling);
			}
			await _schedulingRepository.UpdateRangeAsync(schedulings, HttpContext.RequestAborted);
		}


		/// <summary>
		/// 获取排班人员列表
		/// </summary>
		/// <param name="dto"></param>
		/// <returns></returns>
		[HttpGet("list")]
		public async Task<PagedDto<Scheduling>> List([FromQuery] ListDto dto)
		{
			var (total, items) = await _schedulingRepository.Queryable()
				.Includes(x => x.SchedulingUser)
				.Includes(x => x.SchedulingShift)
				.WhereIF(!string.IsNullOrEmpty(dto.Keyword), x => x.ShiftName.Contains(dto.Keyword!))
				.WhereIF(dto.StartTime.HasValue, x => x.SchedulingTime >= dto.StartTime)
				.WhereIF(dto.EndTime.HasValue, x => x.SchedulingTime <= dto.EndTime)
				.OrderByDescending(x => x.CreationTime)
				.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
			return new PagedDto<Scheduling>(total, items);
		}

		/// <summary>
		/// 获取排班人员实体
		/// </summary>
		/// <param name="id"></param>
		/// <returns></returns>
		[HttpGet("{id}")]
		public async Task<Scheduling> Entity(string id)
		{
			return await _schedulingRepository.Queryable()
				.FirstAsync(x => x.Id == id);
		}
		#endregion

	}
}