package com.lxzn.ucenter.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lxzn.activiti.service.IActivitiDefinitionService;
import com.lxzn.auth.JwtUtil;
import com.lxzn.framework.domain.activiti.ActivitiDefinition;
import com.lxzn.framework.domain.nc.DevicePermissionStream;
import com.lxzn.framework.domain.nc.PermissionStream;
import com.lxzn.framework.domain.ucenter.*;
import com.lxzn.framework.domain.ucenter.ext.UserDepartExport;
import com.lxzn.framework.domain.ucenter.ext.UserDepartExt;
import com.lxzn.framework.domain.ucenter.ext.UserExt;
import com.lxzn.framework.domain.ucenter.request.UserPasswordRequest;
import com.lxzn.framework.domain.ucenter.request.UserRequest;
import com.lxzn.framework.domain.ucenter.response.UcenterCode;
import com.lxzn.framework.exception.ExceptionCast;
import com.lxzn.framework.model.response.CommonCode;
import com.lxzn.framework.model.response.QueryPageResponseResult;
import com.lxzn.framework.utils.BCryptUtil;
import com.lxzn.framework.utils.ExcelUtils;
import com.lxzn.framework.utils.ValidateUtil;
import com.lxzn.nc.service.IDevicePermissionStreamService;
import com.lxzn.nc.service.IPermissionStreamService;
import com.lxzn.ucenter.dao.UserMapper;
import com.lxzn.ucenter.service.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.servlet.ModelAndView;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    @Autowired
    private IMenuService menuService;
    @Autowired
    private IUserRoleService userRoleService;
    @Autowired
    private IDepartmentUserService departmentUserService;
    @Autowired
    private IRoleService roleService;
    @Autowired
    private IDepartmentService departmentService;
    @Autowired
    private IActivitiDefinitionService activitiDefinitionService;
    @Autowired
    private IPermissionStreamService permissionStreamService;
    @Autowired
    private IDevicePermissionStreamService devicePermissionStreamService;



    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addUser(User user) {
        if(user == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(user.getUsername()))
            ExceptionCast.cast(UcenterCode.UCENTER_USERNAME_NONE);
        if(!ValidateUtil.validateString(user.getPassword()))
            ExceptionCast.cast(UcenterCode.UCENTER_PASSWORD_NONE);
        User en = findByUsername(user.getUsername());
        if(en != null) {
            ExceptionCast.cast(UcenterCode.UCENTER_USER_EXIST);
        }
        user.setPassword(BCryptUtil.encode(user.getPassword()));
        return super.save(user);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editUser(String id, User user) {
        if(!ValidateUtil.validateString(id) || user == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        User en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(UcenterCode.UCENTER_USER_NOT_EXIST);
        user.setUserId(id);
        user.setUsername(null);//不能更新用户名
        //更新密码逻辑处理
        if(!ValidateUtil.validateString(user.getPassword())) {
            user.setPassword(null);
        }else {
            user.setPassword(BCryptUtil.encode(user.getPassword()));
        }
        return super.updateById(user);
    }

    @Override
    public User findByUsername(String username) {
        if(!ValidateUtil.validateString(username))
            return null;
        List<User> list = super.lambdaQuery().eq(User::getUsername, username).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public QueryPageResponseResult<UserDepartExt> findUserPageList(int page, int size, UserRequest userRequest) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<UserDepartExt> pageData = new Page<>(page, size);
        LambdaQueryWrapper<UserDepartExt> lambdaQuery = Wrappers.lambdaQuery();
        if(userRequest != null) {
            if(ValidateUtil.validateString(userRequest.getUsername())) {
                lambdaQuery.like(User::getUsername, userRequest.getUsername());
            }
            if(ValidateUtil.validateString(userRequest.getNickname())) {
                lambdaQuery.like(User::getNickname, userRequest.getNickname());
            }
            if(ValidateUtil.validateString(userRequest.getDepartId())) {
                lambdaQuery.inSql(User::getUserId, "select user_id from sys_depart_user where depart_id=" + userRequest.getDepartId());
            }
            if(ValidateUtil.validateString(userRequest.getAscStr())) {
                String[] ascArr = userRequest.getAscStr().split(",");
                ((Page<UserDepartExt>) pageData).setAsc(ascArr);
            }
            if(ValidateUtil.validateString(userRequest.getDescStr())) {
                String[] descStr = userRequest.getDescStr().split(",");
                ((Page<UserDepartExt>) pageData).setDesc(descStr);
            }
        }
        IPage<UserDepartExt> userIPage = super.getBaseMapper().findUserDepartExtPageList(pageData, lambdaQuery);
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, userIPage);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteUserById(String id) {
        if(!ValidateUtil.validateString(id)) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        User en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(UcenterCode.UCENTER_USER_NOT_EXIST);
        List<ActivitiDefinition> definitionList = activitiDefinitionService.findByUserId(id);
        if(definitionList != null && !definitionList.isEmpty())
            ExceptionCast.cast(UcenterCode.UCENTER_ACT_EXIST);
        List<PermissionStream> permissionStreamList = permissionStreamService.findByUserId(id);
        if(permissionStreamList != null && !permissionStreamList.isEmpty())
            ExceptionCast.cast(UcenterCode.UCENTER_PRODUCT_EXIST);
        List<DevicePermissionStream> devicePermissionStreams = devicePermissionStreamService.findByUserId(id);
        if(devicePermissionStreams != null && !devicePermissionStreams.isEmpty())
            ExceptionCast.cast(UcenterCode.UCENTER_DEVICE_EXIST);
        boolean b = userRoleService.deleteByUserId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = departmentUserService.deleteByUserId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        return super.removeById(id);
    }

    @Override
    public UserExt findUserExtByUsername(String username) {
        if(!ValidateUtil.validateString(username))
            return null;
        QueryWrapper<User> ew = Wrappers.query();
        ew.eq("u.username", username);
        ew.eq("u.delete_flag", 0);
        List<UserExt> list = this.getBaseMapper().findUserExtByUsername(ew);
        if(list == null || list.size() != 1)
            return null;
        UserExt userExt = list.get(0);
        List<Menu> menuList = menuService.findByUserId(userExt.getUserId());
        if(menuList != null && !menuList.isEmpty())
            userExt.setPermissions(menuList);
        return userExt;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean setPassword(UserPasswordRequest userPassword) {
        if(userPassword == null || !ValidateUtil.validateString(userPassword.getUserId()) ||
                !ValidateUtil.validateString(userPassword.getOldPassword()) || !ValidateUtil.validateString(userPassword.getNewPassword()))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        User en = super.getById(userPassword.getUserId());
        if(en == null) {
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        }
        boolean r = BCryptUtil.matches(userPassword.getOldPassword(), en.getPassword());
        if(!r) {
            ExceptionCast.cast(UcenterCode.UCENTER_PASSWORD_ERROR);
        }
        String np = BCryptUtil.encode(userPassword.getNewPassword());
        User up = new User();
        up.setPassword(np);
        up.setUserId(userPassword.getUserId());
        return super.updateById(up);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddRoles(String userId, String[] roleIds) {
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_USER_ID_NONE);
        User user = super.getById(userId);
        if(user == null)
            ExceptionCast.cast(UcenterCode.UCENTER_USER_NOT_EXIST);
        if(roleIds == null || roleIds.length < 1) {
            ExceptionCast.cast(UcenterCode.UCENTER_ROLE_NONE);
        }
        //校验数据
        List<String> roleIdList = new ArrayList<>(roleIds.length);
        Collections.addAll(roleIdList, roleIds);
        Collection<Role> roleList = roleService.listByIds(roleIdList);
        if(roleList == null || roleList.isEmpty() || roleList.size() != roleIds.length)
            ExceptionCast.cast(UcenterCode.UCENTER_ROLE_NONE);
        List<UserRole> userRoleList = new ArrayList<>();
        roleList.forEach(item -> {
            UserRole userRole = userRoleService.getByUserIdAndRoleId(user.getUserId(), item.getRoleId());
            if(userRole == null) {
                userRole = new UserRole();
                userRole.setRoleId(item.getRoleId());
                userRole.setUserId(user.getUserId());
                userRoleList.add(userRole);
            }
        });
        if(!userRoleList.isEmpty()) {
            return userRoleService.saveBatch(userRoleList);
        }
       return false;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveRoles(String userId, String[] roleIds) {
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_USER_ID_NONE);
        User user = super.getById(userId);
        if(user == null)
            ExceptionCast.cast(UcenterCode.UCENTER_USER_NOT_EXIST);
        if(roleIds == null || roleIds.length < 1) {
            ExceptionCast.cast(UcenterCode.UCENTER_ROLE_NONE);
        }
        //校验数据
        List<String> roleIdList = new ArrayList<>(roleIds.length);
        Collections.addAll(roleIdList, roleIds);
        Collection<Role> roleList = roleService.listByIds(roleIdList);
        if(roleList == null || roleList.isEmpty() || roleList.size() != roleIds.length)
            ExceptionCast.cast(UcenterCode.UCENTER_ROLE_NONE);
        List<UserRole> userRoleList = new ArrayList<>();
        roleList.forEach(item -> {
            UserRole userRole = userRoleService.getByUserIdAndRoleId(user.getUserId(), item.getRoleId());
            if(userRole != null) {
                userRoleList.add(userRole);
            }
        });
        if(!userRoleList.isEmpty()) {
            return userRoleService.removeByCollection(userRoleList);
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddDeparts(String userId, String[] departIds) {
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_USER_ID_NONE);
        if(departIds == null || departIds.length < 1)
            ExceptionCast.cast(UcenterCode.UCENTER_DEPART_NONE);
        User user = super.getById(userId);
        if(user == null)
            ExceptionCast.cast(UcenterCode.UCENTER_USER_NOT_EXIST);
        List<String> departIdList = new ArrayList<>(departIds.length);
        Collections.addAll(departIdList, departIds);
        Collection<Department> departmentList = departmentService.listByIds(departIdList);
        if(departmentList == null || departmentList.isEmpty() || departIds.length != departmentList.size())
            ExceptionCast.cast(UcenterCode.UCENTER_DEPART_NONE);
        List<DepartmentUser> departmentUserList = new ArrayList<>();
        departmentList.forEach(item -> {
            DepartmentUser departmentUser = departmentUserService.getByUserIdAndDepartId(user.getUserId(), item.getDepartId());
            if(departmentUser == null) {
                departmentUser = new DepartmentUser();
                departmentUser.setDepartId(item.getDepartId());
                departmentUser.setUserId(user.getUserId());
                departmentUserList.add(departmentUser);
            }
        });
        if(!departmentUserList.isEmpty()) {
            return departmentUserService.saveBatch(departmentUserList);
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveDeparts(String userId, String[] departIds) {
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_USER_ID_NONE);
        if(departIds == null || departIds.length < 1)
            ExceptionCast.cast(UcenterCode.UCENTER_DEPART_NONE);
        User user = super.getById(userId);
        if(user == null)
            ExceptionCast.cast(UcenterCode.UCENTER_USER_NOT_EXIST);
        List<String> departIdList = new ArrayList<>(departIds.length);
        Collections.addAll(departIdList, departIds);
        Collection<Department> departmentList = departmentService.listByIds(departIdList);
        if(departmentList == null || departmentList.isEmpty() || departIds.length != departmentList.size())
            ExceptionCast.cast(UcenterCode.UCENTER_DEPART_NONE);
        List<DepartmentUser> departmentUserList = new ArrayList<>();
        departmentList.forEach(item -> {
            DepartmentUser departmentUser = departmentUserService.getByUserIdAndDepartId(user.getUserId(), item.getDepartId());
            if(departmentUser != null) {
                departmentUserList.add(departmentUser);
            }
        });
        if(!departmentUserList.isEmpty()) {
            return departmentUserService.removeByCollection(departmentUserList);
        }
        return false;
    }

    @Override
    public List<UserDepartExt> findAllUserDepartExtList() {
        return super.getBaseMapper().findAllUserDepartExtList();
    }

    /**
     * 导出用户
     * @return
     */
    @Override
    public ModelAndView exportUser(UserRequest userRequest) {
        List<UserDepartExport> userDepartExports=new ArrayList<>();
        LambdaQueryChainWrapper<User> lambdaQuery = super.lambdaQuery();
        if(userRequest != null) {
            lambdaQuery.eq(StrUtil.isNotEmpty(userRequest.getUsername()),User::getUsername, userRequest.getUsername());
            lambdaQuery.eq(StrUtil.isNotEmpty(userRequest.getNickname()),User::getNickname, userRequest.getNickname());
            lambdaQuery.inSql(StrUtil.isNotEmpty(userRequest.getDepartId()),User::getUserId, "select user_id from sys_depart_user where depart_id=" + userRequest.getDepartId());
        }
        lambdaQuery.orderByDesc(User::getCreateTime);
        List<User> userList = lambdaQuery.list();
        userList.forEach(item -> {
            UserDepartExport userDepartExport = new UserDepartExport();
            BeanUtils.copyProperties(item, userDepartExport);
            List<DepartmentUser> departmentUserList=departmentUserService.list(new QueryWrapper<DepartmentUser>().eq("user_id",item.getUserId()));
            if (!departmentUserList.isEmpty()){
                List<String> departIds=departmentUserList.stream().map(DepartmentUser::getDepartId).collect(Collectors.toList());
                if (!departIds.isEmpty()) {
                    List<String> departNames=departmentService.listByIds(departIds).stream().map(Department::getDepartName).collect(Collectors.toList());
                    //采用逗号分隔
                    userDepartExport.setDepartmentName(String.join(",", departNames));
                    userDepartExports.add(userDepartExport);
                }
            }
        });
        String userId = JwtUtil.getUserId();
        return ExcelUtils.export("用户管理", UserDepartExport.class, userDepartExports,this.getById(userId).getNickname());
    }
}