using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Datory;
using GxPress.Common.Tools;
using GxPress.Entity;
using GxPress.EnumConst;
using GxPress.Repository.Interface;
using GxPress.Repository.Interface.AdminVerify;
using GxPress.Repository.Interface.DepartmentUser;
using GxPress.Request.App.AdminVerify;
using GxPress.Request.App.Middle;
using GxPress.Service.Interface.AdminVerify;
using GxPress.Service.Interface.Middle;
using GxPress.Repository.Interface.Friends;
namespace GxPress.Service.Implement.AdminVerify
{
    public class AdminVerifyInsetService : IAdminVerifyInsertService
    {
        private readonly IAdminVerifyRepository _adminVerifyRepository;
        private readonly IUserRepository _userRepository;
        private readonly IDepartmentRepository _departmentRepository;
        private readonly IMiddleService _middleService;
        private readonly IGroupRepository _groupRepository;
        private readonly IGroupChatRepository _groupChatRepository;
        private readonly IMiddleRepository _middleRepository;
        private readonly IGroupUserRepository _groupUserRepository;
        private readonly IDepartmentUserRepository departmentUserRepository;
        private readonly IFriendsRepository friendsRepository;
        public AdminVerifyInsetService(IAdminVerifyRepository adminVerifyRepository, IUserRepository userRepository,
            IDepartmentRepository departmentRepository, IMiddleService middleService, IGroupRepository groupRepository,
            IGroupChatRepository groupChatRepository, IMiddleRepository middleRepository, IGroupUserRepository groupUserRepository,
            IDepartmentUserRepository departmentUserRepository, IFriendsRepository friendsRepository)
        {
            _adminVerifyRepository = adminVerifyRepository;
            _userRepository = userRepository;
            _departmentRepository = departmentRepository;
            _groupRepository = groupRepository;
            _middleService = middleService;
            _groupChatRepository = groupChatRepository;
            _middleRepository = middleRepository;
            _groupUserRepository = groupUserRepository;
            this.departmentUserRepository = departmentUserRepository;
            this.friendsRepository = friendsRepository;
        }

        /// <summary>
        /// 添加成员
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> InsertAsync(AdminVerifyInsertRequest request)
        {
            var adminVerifys = new List<Entity.AdminVerify>();
            //获取邀请人信息
            var userDto = await _userRepository.GetAsync(request.UserId);
            //获取员工所有信息
            var users = await _userRepository.GetAllAsync(Q.WhereIn(nameof(Entity.User.Id), request.UserIds));
            var departmentUsers = await departmentUserRepository.GetDepartmentUsersByUserIdsAsync(request.UserIds);
            var departments = await _departmentRepository.GetAllAsync(Q.WhereIn(nameof(Entity.Department.Id), departmentUsers.Select(n => n.DepartmentId)));
            //获取小组
            var group = await _groupRepository.GetAsync(request.SourceId);
            var ids = new List<GroupUserRoleTyeConst> { GroupUserRoleTyeConst.Admin, GroupUserRoleTyeConst.SuperAdmin };
            //创建人
            var groupUsers = await _groupUserRepository.GetAllAsync(Q.Where(nameof(GroupUser.GroupId), group.Id).WhereIn(nameof(GroupUser.GroupUserRoleId), ids));
            foreach (var userId in request.UserIds)
            {
                //获取用户
                var user = users.FirstOrDefault(n => n.Id == userId);
                if (user == null)
                    continue;
                var department = new Entity.Department();
                if (departmentUsers.FirstOrDefault(n => n.UserId == user.Id) != null)
                    department = departments.FirstOrDefault(m => m.Id == departmentUsers.FirstOrDefault(n => n.UserId == user.Id).DepartmentId);
                //判断是否是小组成员
                if (request.VerifyType == GroupTypeConst.Group)
                {
                    if (await _groupUserRepository.ExistsAsync(userId, request.SourceId))
                        continue;
                }
                //申请
                if (request.SourceType == 1)
                {
                    foreach (var groupUser in groupUsers)
                    {
                        //设置群主验证
                        //await InsertMiddleVerify(groupUser.UserId);
                        var adminVerify = new Entity.AdminVerify()
                        {
                            AvatarUrl = StringUtils.RemoveDomain(user.AvatarUrl),
                            SourceName = group.Name,
                            Name = user.Name,
                            DisposeType = AdminVerifyTypeConst.UDispose.GetHashCode(),
                            VerifyType = request.VerifyType,
                            AdminId = groupUser.UserId,
                            SourceType = request.SourceType,
                            SourceId = request.SourceId,
                            UserId = userId,
                            IsDelete = false,
                            Remark = request.Remark
                        };
                        adminVerifys.Add(adminVerify);
                    }
                }
                //邀请
                if (request.SourceType == 2)
                {
                    var adminVerify = new Entity.AdminVerify()
                    {
                        AvatarUrl = StringUtils.RemoveDomain(userDto.AvatarUrl),
                        Name = userDto.Name,
                        DisposeType = AdminVerifyTypeConst.UDispose.GetHashCode(),
                        VerifyType = request.VerifyType,
                        AdminId = userId,
                        SourceType = request.SourceType,
                        SourceId = request.SourceId,
                        UserId = request.UserId,
                        SourceName = group.Name,
                        IsDelete = false,
                        //获取部门
                        Remark = department.Name + "-" + userDto.Name
                    };
                    adminVerifys.Add(adminVerify);
                }
            }
            await _adminVerifyRepository.InsertAsync(adminVerifys);
            return true;
        }
        /// <summary>
        /// 设置用户通知验证
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        private async Task InsertMiddleVerify(int userId)
        {
            var middle = await _middleRepository.GetMiddleAsync(Q
                .Where(nameof(Entity.Middle.Middle.AttributeValue), 3)
                .Where(nameof(Entity.Middle.Middle.UserId), userId));
            if (middle == null)
            {
                //添加验证信息
                var middleInsertTypeRequest = new MiddleInsertTypeRequest
                {
                    AttributeValue = 3,
                    FolderId = 0,
                    FolderType = 1,
                    MiddleId = 0,
                    MiddleSonId = 0,
                    UserId = userId
                };
                await _middleService.InsertAsync(middleInsertTypeRequest);
            }
            else if (middle.IsDelete)
            {
                middle.IsDelete = false;
                await _middleRepository.UpdateAsync(middle);
            }
        }
    }
}