package com.doumee.biz.system.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.biz.system.SystemUserBiz;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.system.SystemUserMapper;
import com.doumee.dao.system.dto.CreateSystemUserDTO;
import com.doumee.dao.system.dto.CreateUserRoleDTO;
import com.doumee.dao.system.dto.ResetSystemUserPwdDTO;
import com.doumee.dao.system.dto.UpdatePwdDto;
import com.doumee.dao.system.model.*;
import com.doumee.service.system.SystemDepartmentUserService;
import com.doumee.service.system.SystemPositionUserService;
import com.doumee.service.system.SystemUserRoleService;
import com.doumee.service.system.SystemUserService;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Service
public class SystemUserBizImpl implements SystemUserBiz {

    private static String regex = "[1-9][a-z][A-Z]";

    @Autowired
    private SystemUserService systemUserService;

    @Autowired
    private SystemUserRoleService systemUserRoleService;

    @Autowired
    private SystemDepartmentUserService systemDepartmentUserService;

    @Autowired
    private SystemPositionUserService systemPositionUserService;

    @Autowired
    SystemDictDataBiz systemDictDataBiz;

    @Autowired
    private SystemUserMapper systemUserMapper;

    @Override
    public void deleteById(Integer id) {
        SystemUser user = systemUserService.findById(id);
        if (user == null) {
            return;
        }
        if (user.getFixed()) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "请勿删除" + user.getUsername() + "，因为这是固定用户");
        }
        systemUserService.deleteById(id);
    }

    @Override
    @Transactional
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        for (Integer id : ids) {
            this.deleteById(id);
        }
    }

    @Override
    public void updatePwd(UpdatePwdDto dto) {
        SystemUser user = systemUserService.findById(dto.getUserId());
        if (user.getDeleted()) {
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "用户不存在或已被删除");
        }
        // 验证原始密码
        if (!user.getPassword().equals(Utils.Secure.encryptPassword(dto.getOldPwd(), user.getSalt()))) {
            throw new BusinessException(ResponseStatus.PWD_INCORRECT.getCode(), "原始密码不正确");
        }

        // 修改密码
        SystemUser newUser = new SystemUser();
        newUser.setId(dto.getUserId());
        newUser.setPassword(Utils.Secure.encryptPassword(dto.getNewPwd(), user.getSalt()));
        systemUserService.updateById(newUser);
    }

    @Override
    public void resetPwd(ResetSystemUserPwdDTO dto) {
        // 查询用户
//        SystemUser systemUser = systemUserService.findById(dto.getId());
//        if (systemUser == null || systemUser.getDeleted()) {
//            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "用户不存在或已被删除");
//        }
        SystemDictData one = systemDictDataBiz.queryByCode(Constants.SYSTEM,Constants.DEFAULT_PASSWORD);
        String password = StringUtils.isEmpty(dto.getPassword()) ? one.getCode() : dto.getPassword();
        // 修改密码

        if (StringUtils.isNotEmpty(dto.getIds())){

            List<Integer> idList = Arrays.stream(dto.getIds().split(",")).map(s -> Integer.valueOf(s)).collect(Collectors.toList());

            QueryWrapper<SystemUser> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda()
                    .in(SystemUser::getId,idList)
                    .eq(SystemUser::getDeleted,false);
            List<SystemUser> systemUsers = systemUserMapper.selectList(queryWrapper);
            if (idList.size() != systemUsers.size()){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "用户不存在或已被删除");
            }
            systemUsers.forEach(s->{
                SystemUser updateUserDto = new SystemUser();
                updateUserDto.setId(s.getId());
                updateUserDto.setPassword(Utils.Secure.encryptPassword(password, s.getSalt()));
                systemUserMapper.updateById(updateUserDto);
            });
        }else {
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "用户不存在或已被删除");
        }

    }

    @Override
    @Transactional
    public void create(CreateSystemUserDTO systemUser) {
        // 验证用户名
        SystemUser queryUserDto = new SystemUser();
        queryUserDto.setUsername(systemUser.getUsername());
        queryUserDto.setDeleted(Boolean.FALSE);
        SystemUser user = systemUserService.findOne(queryUserDto);
        if (user != null) {
            throw new BusinessException(ResponseStatus.DATA_EXISTS.getCode(), "用户名已存在");
        }
        // 验证工号
        if (StringUtils.isNotBlank(systemUser.getEmpNo())) {
            queryUserDto = new SystemUser();
            queryUserDto.setDeleted(Boolean.FALSE);
            queryUserDto.setEmpNo(systemUser.getEmpNo());
            user = systemUserService.findOne(queryUserDto);
            if (user != null) {
                throw new BusinessException(ResponseStatus.DATA_EXISTS.getCode(), "工号已存在");
            }
        }
        // 生成密码盐
        String salt = RandomStringUtils.randomAlphabetic(6);
        // 生成密码
        systemUser.setPassword(Utils.Secure.encryptPassword(systemUser.getPassword(), salt));
        systemUser.setSalt(salt);
        systemUser.setType(Constants.UserType.SYSTEM.getKey());
        systemUser.setStatus(Constants.ZERO);
        systemUser.setRealname(StringUtils.isNotEmpty(systemUser.getRealname()) ? systemUser.getRealname():systemUser.getUsername());
        // 创建用户记录
        Integer userId = systemUserService.create(systemUser);
        // 设置部门
        if (systemUser.getDepartmentId() != null) {
            SystemDepartmentUser systemDepartmentUser = new SystemDepartmentUser();
            systemDepartmentUser.setDepartmentId(systemUser.getDepartmentId());
            systemDepartmentUser.setUserId(userId);
            systemDepartmentUser.setOperaUser(systemUser.getCreateUser());
            systemDepartmentUser.setOperaTime(new Date());
            systemDepartmentUserService.create(systemDepartmentUser);
        }    
        // 设置岗位
        if (systemUser.getPositionIds() != null && systemUser.getPositionIds().size() > 0) {
            for (Integer positionId : systemUser.getPositionIds()) {
                SystemPositionUser systemPositionUser = new SystemPositionUser();
                systemPositionUser.setPositionId(positionId);
                systemPositionUser.setUserId(userId);
                systemPositionUser.setOperaUser(systemUser.getCreateUser());
                systemPositionUser.setOperaTime(new Date());
                systemPositionUserService.create(systemPositionUser);
            }
        }
    }

    @Override
    public void updateById(CreateSystemUserDTO systemUser) {
        // 验证用户名
        SystemUser queryUserDto = new SystemUser();
        queryUserDto.setUsername(systemUser.getUsername());
        queryUserDto.setDeleted(Boolean.FALSE);
        SystemUser user = systemUserService.findOne(queryUserDto);
        if (user != null && !user.getId().equals(systemUser.getId())) {
            throw new BusinessException(ResponseStatus.DATA_EXISTS.getCode(), "用户名已存在");
        }
        // 验证工号
        if (StringUtils.isNotBlank(systemUser.getEmpNo())) {
            queryUserDto = new SystemUser();
            queryUserDto.setEmpNo(systemUser.getEmpNo());
            queryUserDto.setDeleted(Boolean.FALSE);
            user = systemUserService.findOne(queryUserDto);
            if (user != null && !user.getId().equals(systemUser.getId())) {
                throw new BusinessException(ResponseStatus.DATA_EXISTS.getCode(), "工号已存在");
            }
        }
        // 修改用户
        systemUserService.updateById(systemUser);
        // 设置部门
        SystemDepartmentUser deleteDepartmentDto = new SystemDepartmentUser();
        deleteDepartmentDto.setUserId(systemUser.getId());
        systemDepartmentUserService.delete(deleteDepartmentDto);
        if (systemUser.getDepartmentId() != null) {
            SystemDepartmentUser systemDepartmentUser = new SystemDepartmentUser();
            systemDepartmentUser.setDepartmentId(systemUser.getDepartmentId());
            systemDepartmentUser.setUserId(systemUser.getId());
            systemDepartmentUser.setOperaUser(systemUser.getUpdateUser());
            systemDepartmentUser.setOperaTime(new Date());
            systemDepartmentUserService.create(systemDepartmentUser);
        }
        // 设置岗位
        SystemPositionUser deletePositionDto = new SystemPositionUser();
        deletePositionDto.setUserId(systemUser.getId());
        systemPositionUserService.delete(deletePositionDto);
        if (systemUser.getPositionIds() != null && systemUser.getPositionIds().size() > 0) {
            for (Integer positionId : systemUser.getPositionIds()) {
                SystemPositionUser systemPositionUser = new SystemPositionUser();
                systemPositionUser.setPositionId(positionId);
                systemPositionUser.setUserId(systemUser.getId());
                systemPositionUser.setOperaUser(systemUser.getUpdateUser());
                systemPositionUser.setOperaTime(new Date());
                systemPositionUserService.create(systemPositionUser);
            }
        }
    }



    @Override
    @Transactional
    public void createUserRole(CreateUserRoleDTO dto) {
        // 删除关联角色
        SystemUserRole deleteDto = new SystemUserRole();
        deleteDto.setUserId(dto.getUserId());
        systemUserRoleService.delete(deleteDto);
        // 新增新的角色
        for (Integer roleId : dto.getRoleIds()) {
            SystemUserRole newUserRole = new SystemUserRole();
            newUserRole.setUserId(dto.getUserId());
            newUserRole.setRoleId(roleId);
            systemUserRoleService.create(newUserRole);
        }
    }
}