package com.fdkankan.sale.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.common.util.Base64Converter;
import com.fdkankan.common.util.SecurityUtil;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.sale.common.PageInfo;
import com.fdkankan.sale.common.ResultCode;
import com.fdkankan.sale.entity.RepairLog;
import com.fdkankan.sale.entity.SysRole;
import com.fdkankan.sale.entity.SysUser;
import com.fdkankan.sale.entity.User;
import com.fdkankan.sale.exception.BusinessException;
import com.fdkankan.sale.mapper.ISysUserMapper;
import com.fdkankan.sale.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.sale.vo.request.SysUserParam;
import com.fdkankan.sale.vo.response.ManageLoginResponse;
import com.fdkankan.sale.vo.response.RepairerVo;
import com.fdkankan.sale.vo.response.SysRoleVo;
import com.fdkankan.sale.vo.response.SysUserVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-12-09
 */
@Service
public class SysUserServiceImpl extends ServiceImpl<ISysUserMapper, SysUser> implements ISysUserService {

    @Autowired
    private ISysRoleService roleService;
    @Autowired
    private ISysMenuService sysMenuService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private IRepairLogService repairLogService;


    @Override
    public SysUser getByUserName(String userName) {
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUser::getUserName,userName);
        List<SysUser> list = this.list(wrapper);
        if(list == null || list.size() <=0){
            return null;
        }
        return list.get(0);
    }
    @DS("db2")
    public SysUser getByUserNameDb2(String userName) {
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUser::getUserName,userName);
        List<SysUser> list = this.list(wrapper);
        if(list == null || list.size() <=0){
            return null;
        }
        return list.get(0);
    }


    @Override
    public ManageLoginResponse getUserByUserNameAndPassword(String userName, String password) {
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUser::getUserName,userName)
                .eq(SysUser::getPassword,password);
        List<SysUser> list = this.list(wrapper);
        if(list == null || list.size() <=0){
            return null;
        }
        SysUser sysUser = list.get(0);
        SysRole role = roleService.getById(sysUser.getRoleId());
        ManageLoginResponse loginVO = new ManageLoginResponse();
        BeanUtils.copyProperties(sysUser,loginVO);
        loginVO.setRoleId(role.getId());
        loginVO.setRoleName(role.getRoleName());

        sysMenuService.setRoleAndMenuCache(role,sysUser);

        return loginVO;
    }

    @Override
    @DS("db1")
    public void addOrUpdate(SysUser user,SysUserParam param) {
        SysUser user2 = this.getByUserName(param.getUserName());
        if(user2 !=null){
            throw new BusinessException(ResultCode.USER_EXIST);
        }
        user.setManageId(user.getId());
        user.setId(null);
        user.setRoleId(param.getRoleId());
        user.setCreateUserId(param.getCreateUserId());
        user.setUpdateTime(null);
        user.setDingAccount(param.getDingAccount());
        this.save(user);
    }


    @Override
    public PageInfo pageList(SysUserParam param) {
        Page<SysUserVo> page = this.getBaseMapper().pageList(new Page<>(param.getPageNum(),param.getPageSize()),param);
        return PageInfo.PageInfo(page);
    }

    @Override
    public HashMap<Long, Long> groupByRoleId() {
        HashMap<Long, Long>  map = new HashMap<>();
        List<SysRoleVo> roleVos = this.getBaseMapper().groupByRoleId();
        for (SysRoleVo roleVo : roleVos) {
            map.put(roleVo.getId(),roleVo.getAdminCount());
        }
        return map;
    }

    @Override
    public HashMap<Long, SysUser> getByIds(Set<Long> sysUserIds) {
        HashMap<Long, SysUser> map = new HashMap<>();
        if(sysUserIds.size() >0){
            List<SysUser> sysUsers = this.listByIds(sysUserIds);
            sysUsers.forEach(entity-> map.put(entity.getId(),entity));
        }
        return map;
    }

    @Override
    public void saveByRedisKey(String redisKey) {
        String value = redisUtil.get(redisKey);
        if(StringUtils.isBlank(value)){
            return;
        }

        ManageLoginResponse manageLoginResponse = JSONObject.parseObject(value, ManageLoginResponse.class);

        SysUser sysUser = this.getByManageId(manageLoginResponse.getId());
        if(sysUser == null){
            sysUser= new SysUser();
            BeanUtils.copyProperties(manageLoginResponse,sysUser);
            sysUser.setId(null);
            sysUser.setRoleId(null);
            sysUser.setManageId(manageLoginResponse.getId());
            sysUser.setCreateTime(null);
            this.save(sysUser);
        }

    }

    @Override
    public SysUser getByManageId(Long userId) {
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUser::getManageId,userId);
        return this.getOne(wrapper);
    }

    @Override
    public HashMap<Long, SysUser> getMapByIds(Set<Long> userIds) {
        HashMap<Long,SysUser> map = new HashMap<>();
        if(userIds == null || userIds.size() <= 0){
            return map;
        }
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(SysUser::getId,userIds);
        List<SysUser> list = this.list(wrapper);
        list.forEach(entity -> map.put(entity.getId(),entity));
        return map;
    }

    @Override
    @DS("db2")
    public Object allList(String userName) {
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(userName)){
            wrapper.like(SysUser::getUserName,userName);
        }
        wrapper.eq(SysUser::getStatus,1);
        return this.list(wrapper);
    }


    @Override
    public void setSaleNameAndRepairManName(List<RepairerVo> records) {
        Set<Long> saleIds =records.stream().map(RepairerVo::getSaleId).collect(Collectors.toSet());
        Set<Long> repairManIds =records.stream().map(RepairerVo::getRepairManId).collect(Collectors.toSet());
        saleIds.addAll(repairManIds);
        HashMap<Long, SysUser> userHashMap = this.getMapByIds(saleIds);
        for (RepairerVo record : records) {
            if(record.getSaleId() != null && userHashMap.get(record.getSaleId()) !=null){
                record.setSaleName(userHashMap.get(record.getSaleId()).getNickName());
            }
            if(record.getRepairManId() != null && userHashMap.get(record.getRepairManId()) !=null){
                record.setRepairManName(userHashMap.get(record.getRepairManId()).getNickName());
            }
        }
    }

    @Override
    public void delUser(Long id) {
        List<RepairLog> list = repairLogService.getBySysUserId(id);
        HashMap<String,Integer> statusMap = new HashMap<>();
        for (RepairLog repairLog : list) {
            if(statusMap.get(repairLog.getRepairId()) == null){
                statusMap.put(repairLog.getRepairId(),repairLog.getRepairStatus());
            }else {
                Integer status = statusMap.get(repairLog.getRepairId());
                if(repairLog.getRepairStatus() > status ){
                    statusMap.put(repairLog.getRepairId(),repairLog.getRepairStatus());
                }
            }
        }
        for (Integer maxStatus : statusMap.values()) {
            if(maxStatus != null &&  maxStatus <11 ){
                throw new BusinessException(ResultCode.DEL_USER_REPAIR);
            }
        }

        this.removeById(id);
    }

    @Override
    public void updateUser(SysUserParam param) {
        if(param.getId() == null || param.getStatus() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        LambdaUpdateWrapper<SysUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(SysUser::getId,param.getId());
        wrapper.set(SysUser::getStatus,param.getStatus());
        wrapper.set(SysUser::getDingAccount,param.getDingAccount());
        this.update(wrapper);
    }

    @Override
    public List<SysUser> getByRoleType(Integer roleType) {
        List<SysRole> roles = roleService.getByRoleType(roleType);
        if(roles == null || roles.size()<=0){
            return null;
        }
        List<Long> collect = roles.stream().map(SysRole::getId).collect(Collectors.toList());
        LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(SysUser::getRoleId,collect);
        return this.list(wrapper);
    }

    @Override
    public Long getU8UserId() {
        List<SysUser> sysUsers = this.getByRoleType(6);
        if(sysUsers == null || sysUsers.size() <= 0 ){
            return null;
        }
        return sysUsers.get(0).getId();
    }

    @Override
    public void updateByDb2(SysUser data) {
        LambdaUpdateWrapper<SysUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(SysUser::getManageId,data.getId());
        wrapper.set(SysUser::getNickName,data.getNickName());
        this.update(wrapper);
    }
}