using System;
using System.Linq;
using Zxd.Core.Domain.Impl;
using Zxd.Entity.Zxd;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace Zxd.Core.Domain
{
	public class MeetingDomain : IMeetingDomain
    {
        private readonly IBaseRepository<ZxdDbContext> _zxdRepository;
        private readonly IRedisManager _redisManager;
        private readonly IConfiguration _configuration;
        private readonly IDeptmentDomain _deptmentDomain;
        private readonly IHttpClient _httpClient;
        private readonly IMapper _mapper;
        private readonly SystemConfig _systemConfig;
        private readonly IInneruserDomain _inneruserDomain;

        public MeetingDomain(IBaseRepository<ZxdDbContext> zxdRepository,
            IRedisManager redisManager,
            IConfiguration configuration,
            IDeptmentDomain deptmentDomain,
            IMapper mapper,
            IHttpClient httpClient,
            IInneruserDomain inneruserDomain)
        {
            _zxdRepository = zxdRepository;
            _redisManager = redisManager;
            _deptmentDomain = deptmentDomain;
            _mapper = mapper;
            _httpClient = httpClient;
            _configuration = configuration;
            _inneruserDomain = inneruserDomain;
            _systemConfig = _configuration.GetSection("SystemConfig").Get<SystemConfig>();
        }

        /// <summary>
        /// 分页
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
		public async Task<PageResult<MeetingDto>> GetPage(SearchMeetingDto dto)
		{
            var query = _zxdRepository.GetRepository<Meeting>().Query()
                .If(!string.IsNullOrEmpty(dto.MeetingName), x => x.Where(x => x.MeetingName.Contains(dto.MeetingName)))
                .If(dto.MeetingType != null, x => x.Where(x => x.MeetingType == (MeetingType)dto.MeetingType))
                .If(!string.IsNullOrEmpty(dto.Compere), x => x.Where(x => x.Compere.Contains(dto.Compere)))
                .If(!string.IsNullOrEmpty(dto.CreateUser), x => x.Where(x => x.CreateUser == dto.CreateUser))
                .If(!string.IsNullOrEmpty(dto.Paricipant), x => x.Where(x => x.MeetingParticipants.Any(y => y.Paricipant == dto.Paricipant)))
                .If(dto.CreateTimeForm != null, x => x.Where(x => x.CreateTime >= dto.CreateTimeForm))
                .If(dto.CreateTimeTo != null, x => x.Where(x => x.CreateTime < dto.CreateTimeTo.Value.AddDays(1)))
                .If(dto.MeetingDateForm != null, x => x.Where(x => x.BeginTime >= dto.MeetingDateForm))
                .If(dto.MeetingDateTo != null, x => x.Where(x => x.BeginTime < dto.MeetingDateTo.Value.AddDays(1)))
                .Include(x => x.MeetingParticipants);

            var total = await query.CountAsync();
            var data = await query
                .Select(x => new MeetingDto
                {
                    Id = x.Id,
                    Compere = x.Compere,
                    CreateTime = x.CreateTime,
                    CreateUser = x.CreateUser,
                    MeetingName = x.MeetingName,
                    MeetingSite = x.Site,
                    MeetingTime = $"{x.BeginTime:yyyy.MM.dd}({x.BeginTime:HH:mm}-{x.BeginTime.AddHours(x.ContinueHour).AddMinutes(x.ContinueMinute):HH:mm})",
                    MeetingType = x.MeetingType.GetDescription(),
                    Remark = x.Remark,
                    UpdateTime = x.UpdateTime,
                    UpdateUser = x.UpdateUser
                })
                .Skip((dto.PageIndex - 1) * dto.PageSize)
                .Take(dto.PageSize)
                .ToListAsync();

            return new PageResult<MeetingDto>(dto.PageIndex, dto.PageSize, total, data);
        }

        /// <summary>
        /// 获取会议参与人
        /// </summary>
        /// <param name="meetingId"></param>
        /// <returns></returns>
        /// <exception cref="ApiException"></exception>
        public async Task<List<MeetingParticipantDto>> GetMeetingParticipants(int? meetingId)
        {
            if (meetingId == null)
            {
                throw new ApiException("会议ID不能为空！");
            }
            var data = await _zxdRepository.GetRepository<MeetingParticipant>().Query()
                .Where(x => x.MeetingId == meetingId)
                .Select(x => new MeetingParticipantDto
                {
                    Id = x.Id,
                    Participant = x.Paricipant ?? ""
                })
                .ToListAsync();
            return data;
        }

        /// <summary>
        /// 获取会议附件
        /// </summary>
        /// <param name="meetingId"></param>
        /// <returns></returns>
        /// <exception cref="ApiException"></exception>
        public async Task<MeetingAccessoryDto> GetMeetingAccessory(int? meetingId)
        {
            if (meetingId == null)
            {
                throw new ApiException("会议ID不能为空！");
            }
            var meeting = await _zxdRepository.GetRepository<Meeting>().Query()
                .Where(x => x.Id == meetingId)
                .Where(x => !x.IsDelete)
                .Include(x => x.MeetingAccessories)
                .FirstOrDefaultAsync();

            if (meeting == null)
            {
                throw new ApiException("会议不存或已删除！");
            }

            var data = new MeetingAccessoryDto
            {
                Id = meeting.Id,
                Compere = meeting.Compere,
                MeetingName = meeting.MeetingName,
                MeetingType = meeting.MeetingType.GetDescription()
            };
            foreach (var meetingAccessory in meeting.MeetingAccessories)
            {
                data.Accessories.Add(new AccessoryDto
                {
                    FileName = meetingAccessory.FileName,
                    FileSize = meetingAccessory.FileSize,
                    FileUrl = meetingAccessory.FileUrl,
                    Uploader = meetingAccessory.Uploader,
                    UploadTime = meetingAccessory.UploadTime,
                    Id = meetingAccessory.Id
                });
            }

            return data;
        }

        /// <summary>
        /// 创建或修改会议
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public async Task CreateOrEditMeeting(CreateOrEditMeetingDto dto, int eid)
        {
            var user = await _inneruserDomain.GetInneruser(eid);
            var userName = user.Username;
            if (dto.Id != null && dto.Id > 0)
            {
                var meeting = await _zxdRepository.GetRepository<Meeting>()
                    .FirstOrDefaultAsync(x => x.Id == dto.Id);
                if (meeting == null)
                {
                    throw new ApiException("会议不存或已删除！");
                }
                meeting.BeginTime = dto.BigenTime;
                meeting.Compere = dto.Compere;
                meeting.ContinueHour = dto.ContinueHour;
                meeting.ContinueMinute = dto.ContinueMinute;
                meeting.MeetingName = dto.MeetingName;
                meeting.MeetingType = (MeetingType)dto.MeetingType;
                meeting.Remark = dto.Remark;
                meeting.Site = dto.MeetingSite;
                meeting.UpdateTime = DateTime.Now;
                meeting.UpdateUser = userName;

                await _zxdRepository.GetRepository<Meeting>().UpdateAsync(meeting);
                return;
            }

            var meetingInfo = new Meeting
            {
                BeginTime = dto.BigenTime,
                Compere = dto.Compere,
                ContinueHour = dto.ContinueHour,
                ContinueMinute = dto.ContinueMinute,
                MeetingName = dto.MeetingName,
                MeetingType = (MeetingType)dto.MeetingType,
                Remark = dto.Remark,
                Site = dto.MeetingSite,
                CreateTime = DateTime.Now,
                CreateUser = userName
            };
            await _zxdRepository.GetRepository<Meeting>().InsertAsync(meetingInfo);
        }

        public async Task DeleteMeeting(int? meetingId)
        {
            var meeting = await _zxdRepository.GetRepository<Meeting>().Query()
                .Where(x => x.Id == meetingId)
                .Where(x => !x.IsDelete)
                .FirstOrDefaultAsync();

            if (meeting == null)
            {
                throw new ApiException("会议不存或已删除！");
            }

            meeting.IsDelete = true;
            await _zxdRepository.GetRepository<Meeting>().UpdateAsync(meeting);
        }

        public async Task CreateMeetingAccessory(CreateMeetingAccessoryDto dto, int eid)
        {
            var user = await _inneruserDomain.GetInneruser(eid);
            var meetingAccessory = new MeetingAccessory
            {
                FileName = dto.FileName,
                FileSize = dto.FileSize,
                FileUrl = dto.FileUrl,
                MeetingId = dto.MeetingId,
                UploadEid = eid,
                UploadTime = DateTime.Now,
                Uploader = user.Username
            };

            await _zxdRepository.GetRepository<MeetingAccessory>().InsertAsync(meetingAccessory);
        }
    }
}