package com.lxzn.ucenter.service.impl;

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.base.service.ISingleDictionaryService;
import com.lxzn.framework.domain.activiti.ActivitiDefinition;
import com.lxzn.framework.domain.base.SingleDictionary;
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.UserDepartExt;
import com.lxzn.framework.domain.ucenter.ext.UserExt;
import com.lxzn.framework.domain.ucenter.request.PasswordUpdateRequest;
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.model.response.ResponseResult;
import com.lxzn.framework.model.response.ResultCode;
import com.lxzn.framework.utils.BCryptUtil;
import com.lxzn.framework.utils.ValidateUtil;
import com.lxzn.framework.utils.date.DateUtil;
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.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@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;
    @Autowired
    private ISingleDictionaryService singleDictionaryService;



    @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
    @Transactional(rollbackFor = {Exception.class})
    public boolean editPasswordUser(String userId) {
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        User en = super.getById(userId);
        if(en == null) {
            ExceptionCast.cast(UcenterCode.UCENTER_USER_NOT_EXIST);
        }
        String np = BCryptUtil.encode("Abc.123456");
        en.setPassword(np);
        en.setUserStatus(1);
        en.setPasswordType(1);
        return super.updateById(en);
    }

    @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
    public QueryPageResponseResult<User> findUserPageListDept(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<User> userIPage = super.getBaseMapper().findUserDepartExtPage(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());
        up.setPasswordType(2);
        return super.updateById(up);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean setPasswordUpdate(PasswordUpdateRequest userPassword) {
        if(userPassword == null || !ValidateUtil.validateString(userPassword.getUserName()) ||
                !ValidateUtil.validateString(userPassword.getOldPassword()) || !ValidateUtil.validateString(userPassword.getNewPassword()))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        User user = findByUsername(userPassword.getUserName());
        boolean r = BCryptUtil.matches(userPassword.getOldPassword(), user.getPassword());
        if(!r) {
            ExceptionCast.cast(UcenterCode.UCENTER_PASSWORD_ERROR);
        }
        String np = BCryptUtil.encode(userPassword.getNewPassword());
        if (user == null) {
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        }
        user.setPassword(np);
        user.setPasswordType(2);
        user.setPasswordCycle(DateUtil.getNow());
        return super.updateById(user);
    }

    @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
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveDepartId(String userId, String departId) {
        if(!ValidateUtil.validateString(userId) || !ValidateUtil.validateString(departId)) {
            ExceptionCast.cast(UcenterCode.UCENTER_USER_ID_NONE);
        }
        User user = super.getById(userId);
        if(user == null) {
            ExceptionCast.cast(UcenterCode.UCENTER_USER_NOT_EXIST);
        }
        DepartmentUser departmentUser = departmentUserService.getByUserIdAndDepartId(user.getUserId(), departId);
        if(departmentUser != null) {
            return departmentUserService.removeById(departmentUser.getDepartUserId());
        }
        return false;
    }

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

    @Override
    public ResponseResult findUserAndPassword(String userName, String password) {
        User user = findByUsername(userName);
        if (user == null) {
            return new ResponseResult(CommonCode.UCENTER_USER_ID_NONE);
        }
        boolean r = BCryptUtil.matches(password, user.getPassword());
        if (user.getPasswordType() != null && user.getPasswordType() ==1 &&  r ) {
            return new ResponseResult(CommonCode.UCENTER_PASSWORD_TYPE);
        }

        //密码周期设置启动
        Integer  passwordCycleStop= 2;
        List<SingleDictionary> passwordCyclesStop = singleDictionaryService.findListFromTypeCode("PASSWORD_CYCLE_STOP");
        if (passwordCyclesStop != null && !passwordCyclesStop.isEmpty()) {
            passwordCycleStop = passwordCyclesStop.get(0).getDicValue();
        }
        //密码周期设置(天)
        Integer passwordCycle = 1;
        List<SingleDictionary> passwordCycles = singleDictionaryService.findListFromTypeCode("PASSWORD_CYCLE");
        if (passwordCycles != null && !passwordCycles.isEmpty()) {
            passwordCycle = passwordCycles.get(0).getDicValue();
        }
        //密码错误时长启停
        Integer passwordStop = 1;
        List<SingleDictionary> passwordTypeStops = singleDictionaryService.findListFromTypeCode("PASSWORD_TYPE_STOP");
        if (passwordTypeStops != null && !passwordTypeStops.isEmpty()) {
            passwordStop = passwordTypeStops.get(0).getDicValue();
        }

        //账号锁定时长（秒）
        List<SingleDictionary> passwordTypes = singleDictionaryService.findListFromTypeCode("PASSWORD_TYPE");
        Integer passwordType = 60;
        if (passwordTypes != null && !passwordTypes.isEmpty()) {
            passwordType = passwordTypes.get(0).getDicValue();
        }
        //账号密码错误次数设置
        List<SingleDictionary> errorPasswordNumbers = singleDictionaryService.findListFromTypeCode("ERROR_PASSWORD_NUMBER");
        Integer errorPasswordNumber = 3;
        if (errorPasswordNumbers != null && !errorPasswordNumbers.isEmpty()) {
            errorPasswordNumber = errorPasswordNumbers.get(0).getDicValue();
        }
        //账号密码错误次数设置启停
        Integer errorPasswordNumberStop = 2;
        List<SingleDictionary> errorPasswordNumberStops = singleDictionaryService.findListFromTypeCode("ERROR_PASSWORD_NUMBER_TSOP");
        if (errorPasswordNumberStops != null && !errorPasswordNumberStops.isEmpty()) {
            errorPasswordNumberStop = errorPasswordNumberStops.get(0).getDicValue();
        }
        //密码正确情况
        if (r) {
            //是否超过周期是否启动
            if (passwordCycleStop ==1){
                if (user.getPasswordCycle() != null){
                    Date date = DateUtil.addDay(user.getPasswordCycle(),passwordCycle);
                    Date endTime = DateUtil.getNow();
                    if (!DateUtil.greater(date,endTime)) {
                        user.setPasswordNumber(0);
                        updateById(user);
                        return new ResponseResult(CommonCode.UCENTER_PASSWORD_TYPE);
                    }
                }
            }
            //  账号密码错误次数设置启停
            if (errorPasswordNumberStop == 1) {
                if (user.getPasswordNumber() != null && user.getPasswordNumber() >= errorPasswordNumber) {
                    if (user.getUpdateTime() != null) {
                        if (passwordStop == 1) {
                            Date date = DateUtil.addSeconds(user.getUpdateTime(),passwordType);
                            Date endTime = DateUtil.getNow();
                            if (!DateUtil.greater(date,endTime)) {
                                user.setPasswordNumber(0);
                                String np = BCryptUtil.encode("Abc.123456");
                                user.setPassword(np);
                                updateById(user);
                                return new ResponseResult(CommonCode.SUCCESS);
                            } else {
                                return new ResponseResult(CommonCode.UCENTER_PASSWORD_NUMBER);
                            }
                        }

                    }
                }
            }
            user.setPasswordNumber(0);
            updateById(user);
            return new ResponseResult(CommonCode.SUCCESS);
        } else {
            //密码错误情况
            Integer psNumber = user.getPasswordNumber();
            if (errorPasswordNumberStop == 1) { // 账号密码错误次数设置启停
                if (psNumber == null || psNumber < errorPasswordNumber) {
                    if (psNumber == null) {
                        user.setPasswordNumber( 1);
                    } else {
                        user.setPasswordNumber(psNumber + 1);
                    }
                    updateById(user);
                    return new ResponseResult(CommonCode.UCENTER_CREDENTIAL_ERROR);
                } else if (psNumber >= errorPasswordNumber) {
                    if (passwordStop == 1) { //密码时长设置
                        Date date = DateUtil.addSeconds(user.getUpdateTime(),passwordType);
                        Date endTime = DateUtil.getNow();
                        if (!DateUtil.greater(date,endTime)) {
                            user.setPasswordNumber(0);
                            String np = BCryptUtil.encode("Abc.123456");
                            user.setPassword(np);
                            updateById(user);
                            return new ResponseResult(CommonCode.SUCCESS);
                        } else {
                            updateById(user);
                            return new ResponseResult(CommonCode.UCENTER_PASSWORD_NUMBER);
                        }
                    }
                }
            }
        }
        return new ResponseResult(CommonCode.SUCCESS);
    }
}