package com.xcong.farmer.cms.modules.system.service.Impl;

import cn.hutool.crypto.SecureUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xcong.farmer.cms.common.response.Result;
import com.xcong.farmer.cms.modules.system.dto.AdminAddUserDto;
import com.xcong.farmer.cms.modules.system.dto.AdminUpdateUserDto;
import com.xcong.farmer.cms.modules.system.dto.AdminUserDto;
import com.xcong.farmer.cms.modules.system.entity.*;
import com.xcong.farmer.cms.modules.system.mapper.*;
import com.xcong.farmer.cms.modules.system.service.IUserService;
import com.xcong.farmer.cms.modules.system.util.LoginUserUtil;
import com.xcong.farmer.cms.modules.system.vo.AdminRoleVo;
import com.xcong.farmer.cms.modules.system.vo.AdminSeeUserInfoVo;
import com.xcong.farmer.cms.modules.system.vo.AdminUserMenuVo;
import com.xcong.farmer.cms.modules.system.vo.AdminUserVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.ObjectUtil;

import cn.hutool.core.collection.CollUtil;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;

@Service
@Slf4j
public class UserServiceImpl extends ServiceImpl<UserMapper, UserEntity> implements IUserService {

    @Resource
    private RoleMapper roleMapper;
    @Resource
    private UserRoleMapper userRoleMapper;
    @Resource
    private RoleMenuMapper roleMenuMapper;
    @Resource
    private MenuMapper menuMapper;

    @Override
    public Result getUserInPage(AdminUserDto adminUserDto) {
        Page<AdminUserVo> page = new Page<>(adminUserDto.getPageNum(), adminUserDto.getPageSize());
        UserEntity userEntity = new UserEntity();
        if(StrUtil.isNotEmpty(adminUserDto.getUsername())){
            userEntity.setUsername(adminUserDto.getUsername());
        }
        IPage<AdminUserVo> AdminUserVos = this.baseMapper.selectAdminUserVoInPage(page,userEntity);
        List<AdminUserVo> records = AdminUserVos.getRecords();
        if(CollUtil.isNotEmpty(records)){
            for(AdminUserVo adminUserVo : records){
                List<AdminRoleVo> adminRoleVos = new ArrayList<>();
                QueryWrapper<UserRoleEntity> objectQueryWrapper = new QueryWrapper<>();
                objectQueryWrapper.eq("user_id",adminUserVo.getId());
                List<UserRoleEntity> userRoleEntities = userRoleMapper.selectList(objectQueryWrapper);
                if(CollUtil.isNotEmpty(userRoleEntities)){
                    for(UserRoleEntity userRoleEntity : userRoleEntities){
                        RoleEntity roleEntity = roleMapper.selectById(userRoleEntity.getRoleId());
                        AdminRoleVo adminRoleVo = new AdminRoleVo();
                        adminRoleVo.setId(roleEntity.getId());
                        adminRoleVo.setRoleName(roleEntity.getRoleName());
                        adminRoleVos.add(adminRoleVo);
                    }
                }
                adminUserVo.setAdminRoleVos(adminRoleVos);
            }
        }

        return Result.ok(AdminUserVos);
    }

    @Override
    @Transactional
    public Result addUser(AdminAddUserDto adminAddUserDto) {
        String username = adminAddUserDto.getUsername();
        if(StrUtil.isEmpty(username)){
            return Result.fail("请输入用户名");
        }
        String roleIds = adminAddUserDto.getRoleIds();
        if(StrUtil.isEmpty(roleIds)){
            return Result.fail("请选择用户角色");
        }
        String phone = adminAddUserDto.getPhone();
        if(StrUtil.isEmpty(phone)){
            return Result.fail("请输入联系电话");
        }
        UserEntity userEntity = new UserEntity();
        userEntity.setUsername(username);
        userEntity.setPhone(phone);
        if(StrUtil.isNotEmpty(adminAddUserDto.getNickname())){
            userEntity.setNickname(adminAddUserDto.getNickname());
        }
        if(StrUtil.isNotEmpty(adminAddUserDto.getEmail())){
            userEntity.setEmail(adminAddUserDto.getEmail());
        }
        userEntity.setPassword(SecureUtil.md5(UserEntity.PASSWORD_DEFAULT));
        userEntity.setStatus(UserEntity.STATUS_ENABLE);
        int insert = this.baseMapper.insert(userEntity);
        if(insert > 0){
            saveUserRole(roleIds,userEntity.getId());
            return Result.ok("添加成功");
        }
        return Result.fail("添加失败");
    }

    @Override
    @Transactional
    public Result activeUser(Long id) {
        UserEntity userEntity = this.baseMapper.selectById(id);
        if(ObjectUtil.isEmpty(userEntity)){
            return Result.fail("用户不存在");
        }
        userEntity.setStatus(UserEntity.STATUS_ENABLE);
        this.baseMapper.updateById(userEntity);
        return Result.ok("激活成功");
    }

    @Override
    @Transactional
    public Result forbiddenUser(Long id) {
        UserEntity userEntity = this.baseMapper.selectById(id);
        if(ObjectUtil.isEmpty(userEntity)){
            return Result.fail("用户不存在");
        }
        userEntity.setStatus(UserEntity.STATUS_DISABLED);
        this.baseMapper.updateById(userEntity);
        return Result.ok("禁用成功");
    }

    @Override
    @Transactional
    public Result deleteUser(Long id) {
        UserEntity userEntity = this.baseMapper.selectById(id);
        if(ObjectUtil.isEmpty(userEntity)){
            return Result.fail("用户不存在");
        }
        this.baseMapper.deleteById(id);

        QueryWrapper<UserRoleEntity> objectQueryWrapper = new QueryWrapper<>();
        objectQueryWrapper.eq("user_id",userEntity.getId());
        userRoleMapper.delete(objectQueryWrapper);
        return Result.ok("删除成功");
    }

    @Override
    public Result seeUserInfo(Long id) {
        UserEntity userEntity = this.baseMapper.selectById(id);
        if(ObjectUtil.isEmpty(userEntity)){
            return Result.fail("用户不存在");
        }
        AdminSeeUserInfoVo adminSeeUserInfoVo = new AdminSeeUserInfoVo();
        adminSeeUserInfoVo.setId(userEntity.getId());
        adminSeeUserInfoVo.setUsername(userEntity.getUsername());
        adminSeeUserInfoVo.setNickname(userEntity.getNickname());
        adminSeeUserInfoVo.setPhone(userEntity.getPhone());
        adminSeeUserInfoVo.setEmail(userEntity.getEmail());

        List<AdminRoleVo> adminRoleVos = new ArrayList<>();
        QueryWrapper<UserRoleEntity> objectQueryWrapper = new QueryWrapper<>();
        objectQueryWrapper.eq("user_id",userEntity.getId());
        List<UserRoleEntity> userRoleEntities = userRoleMapper.selectList(objectQueryWrapper);
        if(CollUtil.isNotEmpty(userRoleEntities)){
            for(UserRoleEntity userRoleEntity : userRoleEntities){
                RoleEntity roleEntity = roleMapper.selectById(userRoleEntity.getRoleId());
                AdminRoleVo adminRoleVo = new AdminRoleVo();
                adminRoleVo.setId(roleEntity.getId());
                adminRoleVo.setRoleName(roleEntity.getRoleName());
                adminRoleVos.add(adminRoleVo);
            }
        }
        adminSeeUserInfoVo.setAdminRoleVos(adminRoleVos);
        return Result.ok(adminSeeUserInfoVo);
    }

    @Override
    @Transactional
    public Result updateUser(AdminUpdateUserDto adminUpdateUserDto) {
        String username = adminUpdateUserDto.getUsername();
        if(StrUtil.isEmpty(username)){
            return Result.fail("请输入用户名");
        }
        String roleIds = adminUpdateUserDto.getRoleIds();
        if(StrUtil.isEmpty(roleIds)){
            return Result.fail("请选择用户角色");
        }
        String phone = adminUpdateUserDto.getPhone();
        if(StrUtil.isEmpty(phone)){
            return Result.fail("请输入联系电话");
        }
        UserEntity userEntity =  this.baseMapper.selectById(adminUpdateUserDto.getId());
        if(ObjectUtil.isEmpty(userEntity)){
            return Result.fail("用户不存在");
        }
        userEntity.setUsername(username);
        userEntity.setPhone(phone);
        if(StrUtil.isNotEmpty(adminUpdateUserDto.getNickname())){
            userEntity.setNickname(adminUpdateUserDto.getNickname());
        }
        if(StrUtil.isNotEmpty(adminUpdateUserDto.getEmail())){
            userEntity.setEmail(adminUpdateUserDto.getEmail());
        }
        int insert = this.baseMapper.updateById(userEntity);
        if(insert > 0){
            QueryWrapper<UserRoleEntity> objectQueryWrapper = new QueryWrapper<>();
            objectQueryWrapper.eq("user_id",userEntity.getId());
            userRoleMapper.delete(objectQueryWrapper);

            saveUserRole(roleIds,userEntity.getId());
            return Result.ok("更新成功");
        }
        return Result.fail("更新失败");
    }

    @Override
    @Transactional
    public Result resetPassword(Long id) {
        UserEntity userEntity =  this.baseMapper.selectById(id);
        if(ObjectUtil.isEmpty(userEntity)){
            return Result.fail("用户不存在");
        }
        userEntity.setPassword(SecureUtil.md5(UserEntity.PASSWORD_DEFAULT));
        this.baseMapper.updateById(userEntity);
        return Result.ok("重置成功");
    }

    @Override
    public Result userMenu() {
        Long userId = LoginUserUtil.getLoginUser().getId();
        List<AdminUserMenuVo> adminUserMenuVos = new ArrayList<>();

        QueryWrapper<UserRoleEntity> userRoleQueryWrapper = new QueryWrapper<>();
        userRoleQueryWrapper.eq("user_id",userId);
        List<UserRoleEntity> userRoleEntities = userRoleMapper.selectList(userRoleQueryWrapper);
        if(CollUtil.isNotEmpty(userRoleEntities)){
            List menuIds = new ArrayList<Long>();
            for(UserRoleEntity userRoleEntity : userRoleEntities){
                List<RoleMenuEntity> roleMenuEntities = roleMenuMapper.selectListByRoleId(userRoleEntity.getRoleId());
                if(CollUtil.isNotEmpty(roleMenuEntities)){
                    for(RoleMenuEntity roleMenuEntity : roleMenuEntities){
                        menuIds.add(roleMenuEntity.getMenuId());
                    }
                }
            }
            if(CollUtil.isNotEmpty(menuIds)){
                HashSet hashSet = CollUtil.newHashSet(menuIds);
                List<Long> parentMenuIds = new ArrayList<>();
                List<Long> childMenuIds = new ArrayList<>();
                for(Object s : hashSet){
                    MenuEntity menuEntity = menuMapper.selectById(Long.parseLong(s.toString()));
                    Long parentId = menuEntity.getParentId();
                    if(parentId == 0L){
                        parentMenuIds.add(menuEntity.getId());
                    }else{
                        childMenuIds.add(menuEntity.getId());
                    }
                }
                Map<Long, AdminUserMenuVo> menuMap = new HashMap<>();
                if(CollUtil.isNotEmpty(parentMenuIds)){
                    for(Long parentId : parentMenuIds){
                        AdminUserMenuVo adminUserMenuVo = menuMapper.selectAdminRoleMenuVoById(parentId);
                        menuMap.put(parentId,adminUserMenuVo);
                    }
                }
                if(CollUtil.isNotEmpty(childMenuIds)){
                    for(Long childId : childMenuIds){
                        AdminUserMenuVo adminUserMenuVo = menuMapper.selectAdminRoleMenuVoById(childId);
                        Long parentId = adminUserMenuVo.getParentId();
                        AdminUserMenuVo adminUserMenuVoParent = menuMap.get(parentId);
                        List<AdminUserMenuVo> child = adminUserMenuVoParent.getChild();
                        if(CollUtil.isEmpty(child)){
                            List<AdminUserMenuVo> list = new ArrayList<>();
                            list.add(adminUserMenuVo);
                            adminUserMenuVoParent.setChild(list);
                        }else{
                            child.add(adminUserMenuVo);
                        }
                    }
                }
                Set<Map.Entry<Long, AdminUserMenuVo>> entries = menuMap.entrySet();
                Iterator<Map.Entry<Long, AdminUserMenuVo>> iterator = entries.iterator();
                while (iterator.hasNext()){
                    adminUserMenuVos.add(iterator.next().getValue());
                }

            }
        }
        return Result.ok(adminUserMenuVos);
    }

    private void saveUserRole(String roleIds,Long userId) {
        if (StrUtil.isNotEmpty(roleIds)) {
            String[] roleIdList = roleIds.split(StringPool.COMMA);
            Arrays.stream(roleIdList).forEach(roleId -> {
                UserRoleEntity userRoleEntity = new UserRoleEntity();
                userRoleEntity.setRoleId(Long.valueOf(roleId));
                userRoleEntity.setUserId(userId);
                userRoleMapper.insert(userRoleEntity);
            });
        }
    }

}