package com.glxp.api.controller.auth;


import cn.dev33.satoken.annotation.SaCheckPermission;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.github.pagehelper.PageInfo;
import com.glxp.api.annotation.Log;
import com.glxp.api.common.enums.ResultEnum;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.BusinessType;
import com.glxp.api.controller.BaseController;
import com.glxp.api.entity.auth.*;
import com.glxp.api.req.auth.AuthUserSaveRequest;
import com.glxp.api.req.auth.FilterAuthUserRequest;
import com.glxp.api.req.auth.FilterDeptUserReqeust;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.auth.AuthAdminResponse;
import com.glxp.api.res.auth.DeptUserResponse;
import com.glxp.api.service.auth.*;
import com.glxp.api.util.PasswordUtils;
import com.glxp.api.util.StreamUtils;
import com.glxp.api.util.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 用户信息
 *
 * @author Lion Li
 */
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/system/user")
@Transactional(rollbackFor = Exception.class)
public class SysUserController extends BaseController {

    private final AuthAdminService userService;
    private final ISysRoleService roleService;
    @Resource
    ISysRoleService sysRoleService;

    @Resource
    private CustomerInfoService customerInfoService;

    @Resource
    private AuthAdminService authAdminService;

    @GetMapping("/list")
    public BaseResponse list(FilterAuthUserRequest filterAuthUserRequest, BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        List<AuthAdmin> authAdminList = userService.listAdminPage(filterAuthUserRequest);
        //查询对应角色和部门
        List<AuthAdminResponse> authAdminResponseList = authAdminList.stream().map(item -> {
            AuthAdminResponse authAdminResponse = new AuthAdminResponse();
            BeanUtil.copyProperties(item, authAdminResponse);
            List<Long> roles = sysRoleService.selectRoleListByUserId(authAdminResponse.getId());
            List<DeptUserResponse> deptUserResponses = null;
            if ("key".equals(filterAuthUserRequest.getKey())) {
                deptUserResponses = deptUserService.selectByUserIdKey(authAdminResponse.getId());
            } else {
                deptUserResponses = deptUserService.selectByUserId(authAdminResponse.getId());
            }
            if (CollUtil.isNotEmpty(deptUserResponses)) {
                List<Long> depts = new ArrayList<>();
                String deptName = "";
                for (DeptUserResponse deptUserResponse : deptUserResponses) {
                    if (deptUserResponse.getDeptId() != 1) {
                        depts.add(deptUserResponse.getDeptId());
                        deptName = deptName + "," + deptUserResponse.getDeptName();
                    }
                }
                if (deptName.length() != 0) {
                    authAdminResponse.setDeptName(deptName.substring(1));
                } else {
                    authAdminResponse.setDeptName(deptName);
                }
                authAdminResponse.setDepts(depts);
            }
            authAdminResponse.setRoles(roles);
            return authAdminResponse;
        }).collect(Collectors.toList());

        PageInfo<AuthAdmin> authAdminPageInfo = new PageInfo<>(authAdminList);
        PageSimpleResponse<AuthAdminResponse> authAdminPageSimpleResponse = new PageSimpleResponse<>();
        authAdminPageSimpleResponse.setTotal(authAdminPageInfo.getTotal());
        authAdminPageSimpleResponse.setList(authAdminResponseList);

        return ResultVOUtils.success(authAdminPageSimpleResponse);
    }


    /**
     * 根据用户编号获取详细信息
     *
     * @param userId 用户ID
     */
    @SaCheckPermission("system:user:query")
    @GetMapping(value = {"/", "/{userId}"})
    public BaseResponse getInfo(@PathVariable(value = "userId", required = false) Long userId) {
        Map<String, Object> ajax = new HashMap<>();
        List<SysRole> roles = roleService.selectRoleAll();
        ajax.put("roles", isAdmin(userId) ? roles : StreamUtils.filter(roles, r -> !r.isAdmin()));
        if (ObjectUtil.isNotNull(userId)) {
            AuthAdmin sysUser = userService.findById(userId);
            ajax.put("user", sysUser);
            ajax.put("roleIds", StreamUtils.toList(sysUser.getRoles(), SysRole::getRoleId));
        }
        return ResultVOUtils.success(ajax);
    }


    /**
     * 根据用户编号获取授权角色
     *
     * @param userId 用户ID
     */
    @SaCheckPermission("system:user:query")
    @GetMapping("/authRole/{userId}")
    public BaseResponse authRole(@PathVariable Long userId) {
        AuthAdmin user = userService.findById(userId);
        List<SysRole> roles = roleService.selectRolesByUserId(userId);
        Map<String, Object> ajax = new HashMap<>();
        ajax.put("user", user);
        ajax.put("roles", isAdmin(userId) ? roles : StreamUtils.filter(roles, r -> !r.isAdmin()));
        return ResultVOUtils.success(ajax);
    }

    /**
     * 用户授权角色
     *
     * @param userId  用户Id
     * @param roleIds 角色ID串
     */
    @Log(title = "用户管理", businessType = BusinessType.GRANT)
    @SaCheckPermission("system:user:edit")
    @PutMapping("/authRole")
    public BaseResponse inseinsertUserAuthrtAuthRole(Long userId, Long[] roleIds) {
        userService.insertUserAuth(userId, CollUtil.toList(roleIds));
        return ResultVOUtils.success("授权成功！");
    }

    @Log(title = "用户管理", businessType = BusinessType.INSERT)
    @PostMapping("/save")
    public BaseResponse save(@RequestBody @Valid AuthUserSaveRequest authUserSaveRequest,
                             BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }

        AuthAdmin curUser = getUser();
        //先获取账号最大用户量
        CustomerInfoEntity customerInfoEntity = customerInfoService.selectById(curUser.getCustomerId());
        //获取此账号下存在的用户量
        List<AuthAdmin> byCustomerld = authAdminService.findByCustomerld(curUser.getCustomerId());
        if (customerInfoEntity != null && customerInfoEntity.getUserMax() <= byCustomerld.size()) {
            return ResultVOUtils.error(500, "已到达最大用户量");
        }

        // 检查是否存在相同名称的管理员
        AuthAdmin byUserName = userService.findByUserName(authUserSaveRequest.getUserName());
        if (byUserName != null) {
            return ResultVOUtils.error(ResultEnum.DATA_REPEAT, "当前管理员已存在");
        }
        AuthAdmin authAdmin = new AuthAdmin();
        BeanUtils.copyProperties(authUserSaveRequest, authAdmin);
        if (authAdmin.getPassWord() != null) {
            authAdmin.setPassWord(PasswordUtils.authAdminPwd(authAdmin.getPassWord()));
        }
        authAdmin.setCustomerId(curUser.getCustomerId());
        authAdmin.setLastModifyTime(new Date());
        //先默认插入部门 仓库
        //通过仓库找到对应部门
        String pid = invWarehouseService.selectParentIdByCode(authUserSaveRequest.getLocInvCode());
        authAdmin.setLocDeptCode(pid);
        authAdmin.setLocInvCode(authUserSaveRequest.getLocInvCode());
        authAdmin.setId(IdUtil.getSnowflakeNextId());
        boolean b = userService.insertAuthAdmin(authAdmin);
        authAdmin = userService.findByUserName(authAdmin.getUserName());
        if (!b) {
            return ResultVOUtils.error(ResultEnum.NOT_NETWORK);
        }

        // 插入角色
        if (authUserSaveRequest.getRoles().size() != 0) {
            userService.insertUserAuth(authAdmin.getId(), authUserSaveRequest.getRoles());
        }

        //默认插入第一部门
        List<Long> deptCodeList = authUserSaveRequest.getDepts();
        if (deptCodeList == null) {
            deptCodeList = new ArrayList<>();
        }
        deptCodeList.add(1L);
        authUserSaveRequest.setDepts(deptCodeList);


        //插入部门
        if (CollUtil.isNotEmpty(authUserSaveRequest.getDepts())) {
            List<DeptUserEntity> list = new ArrayList<>();
            for (int i = 0; i < authUserSaveRequest.getDepts().size(); i++) {
                DeptUserEntity deptUserEntity = new DeptUserEntity();
                deptUserEntity.setUserId(authAdmin.getId());
                deptUserEntity.setDeptId(authUserSaveRequest.getDepts().get(i));
                deptUserEntity.setUpdateTime(new Date());
                list.add(deptUserEntity);
            }
            deptUserService.insertBatch(list);
        } else {

        }

        // 插入仓库
        if (StringUtils.isNotBlank(authUserSaveRequest.getLocInvCode())) {
            WarehouseUserEntity warehouseUserEntity = new WarehouseUserEntity();
            warehouseUserEntity.setCode(authUserSaveRequest.getLocInvCode());
            warehouseUserEntity.setUsername(authUserSaveRequest.getUserName());
            warehouseUserEntity.setUserid(authAdmin.getId());
            warehouseUserService.insert(warehouseUserEntity);
        }

        Map<String, Long> res = new HashMap<>();
        res.put("id", authAdmin.getId());
        return ResultVOUtils.success(res);
    }


    @Resource
    DeptUserService deptUserService;

    @Resource
    WarehouseUserService warehouseUserService;

    @Resource
    InvWarehouseService invWarehouseService;

    /**
     * 修改用户
     */
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
    @PostMapping("/edit")
    public BaseResponse edit(@RequestBody @Valid AuthUserSaveRequest authUserSaveRequest,
                             BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        if (authUserSaveRequest.getId() == null) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, "参数错误！");
        }
        // 检查是否存在除了当前管理员的其它名称的管理员
        AuthAdmin byUserName = userService.findByUserName(authUserSaveRequest.getUserName());
        if (byUserName != null && !authUserSaveRequest.getId().equals(byUserName.getId())) {
            return ResultVOUtils.error(ResultEnum.DATA_REPEAT, "当前管理员已存在");
        }

        AuthAdmin authAdmin = new AuthAdmin();
        BeanUtils.copyProperties(authUserSaveRequest, authAdmin);
        if (authAdmin.getPassWord() != null) {
            authAdmin.setPassWord(PasswordUtils.authAdminPwd(authAdmin.getPassWord()));
        }
        authAdmin.setLastModifyTime(new Date());
        boolean b = userService.updateAuthAdmin(authAdmin);

        if (!b) {
            return ResultVOUtils.error(ResultEnum.NOT_NETWORK);
        }

//        修改角色(供应商账号)
        AuthAdmin byId = userService.findById(authUserSaveRequest.getId());
        if ("110".equals(byId.getCustomerId())) {
            userService.insertUserAuth(authAdmin.getId(), authUserSaveRequest.getRoles());
        }

        userService.updateAuthAdmin(authAdmin);
        //默认插入第一部门
        ArrayList<Long> deptCodeList = new ArrayList<>();
        FilterDeptUserReqeust filterDeptUserReqeust = new FilterDeptUserReqeust();
        filterDeptUserReqeust.setUserId(authUserSaveRequest.getId());
        List<DeptUserEntity> deptUserEntities = deptUserService.selectDeptUser(filterDeptUserReqeust);
        if (CollUtil.isEmpty(deptUserEntities)) {
            deptCodeList.add(1L);
            authUserSaveRequest.setDepts(deptCodeList);
        } else {
            Boolean checkDeptId = false;
            for (DeptUserEntity deptUserEntity : deptUserEntities) {
                if (deptUserEntity.getDeptId() == 1) {
                    checkDeptId = true;
                } else {
                    deptCodeList.add(deptUserEntity.getDeptId());
                }
            }
            if (checkDeptId == false) {
                deptCodeList.add(1L);
                authUserSaveRequest.setDepts(deptCodeList);
            }
        }

        //修改所属部门
        deptUserService.deleteByUser(authUserSaveRequest.getId());
        if (CollUtil.isNotEmpty(authUserSaveRequest.getDepts())) {
            List<DeptUserEntity> list = new ArrayList<>();
            for (int i = 0; i < authUserSaveRequest.getDepts().size(); i++) {
                DeptUserEntity deptUserEntity = new DeptUserEntity();
                deptUserEntity.setUserId(authUserSaveRequest.getId());
                deptUserEntity.setDeptId(authUserSaveRequest.getDepts().get(i));
                deptUserEntity.setUpdateTime(new Date());
                list.add(deptUserEntity);
            }
            deptUserService.insertBatch(list);
        }
        return ResultVOUtils.success();
    }

}