package com.glxp.api.controller.auth;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.github.pagehelper.PageInfo;
import com.glxp.api.annotation.AuthRuleAnnotation;
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.dto.DictDto;
import com.glxp.api.entity.auth.*;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.system.CompanyEntity;
import com.glxp.api.req.auth.*;
import com.glxp.api.req.basic.FilterBussinessTypeRequest;
import com.glxp.api.req.system.DeleteRequest;
import com.glxp.api.req.thrsys.FilterBasicThirdSysRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.auth.InvSubWarehouseResponse;
import com.glxp.api.res.auth.InvWarehouseThirdSysResponse;
import com.glxp.api.res.basic.BasicBussinessTypeResponse;
import com.glxp.api.service.auth.*;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.system.CompanyService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.IntUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
public class InvWarehouseController extends BaseController {

    @Resource
    InvWarehouseService invWarehouseService;
    @Resource
    DeptService deptService;
    @Resource
    CustomerService customerService;
    @Resource
    CompanyService companyService;
    @Resource
    private WarehouseUserService warehouseUserService;
    @Resource
    private SystemParamConfigService systemParamConfigService;
    @Resource
    private WarehouseBussinessTypeService warehouseBussinessTypeService;
    @Resource
    private IBasicBussinessTypeService basicBussinessTypeService;
    @Resource
    private InvSpaceService invSpaceService;
    @Resource
    InvBusUserService invBusUserService;
    @Resource
    AuthWarehouseUnifyService authWarehouseUnifyService;

    /**
     * 获取仓库列表
     *
     * @param filterInvSubWarehouseRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("spms/sub/inv/warehouse/filter")
    public BaseResponse filterInvWarehouse(FilterInvSubWarehouseRequest filterInvSubWarehouseRequest) {
        List<InvSubWarehouseResponse> responses = invWarehouseService.filterInvSubWarehouseResponse(filterInvSubWarehouseRequest);
        return ResultVOUtils.success(responses);
    }

    /**
     * 获取仓库列表
     *
     * @param filterInvSubWarehouseRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("spms/sub/inv/warehouse/filterOptimize")
    public BaseResponse filterOptimize(FilterInvSubWarehouseRequest filterInvSubWarehouseRequest) {
        List<InvSubWarehouseResponse> responses = invWarehouseService.filterInvSubWarehouseResponse(filterInvSubWarehouseRequest);
        List<DictDto> reList = responses.stream().map(s-> {
            DictDto dictDto = new DictDto(s.getCode(),s.getName());
            return dictDto;
        }).collect(Collectors.toList());
        return ResultVOUtils.success(reList);
    }

    /**
     * 获取部门底下仓库列表-关联用户
     *
     * @param filterInvWarehouseRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("spms/inv/warehouse/findByDeptUser")
    public BaseResponse findByDept(FilterInvWarehouseRequest filterInvWarehouseRequest) {
        AuthAdmin authAdmin = getUser();
        if (authAdmin.getCustomerId().equals("110")) {
            filterInvWarehouseRequest.setUserId(authAdmin.getId());
        } else {
            if (IntUtil.value(filterInvWarehouseRequest.getType()) == 1) {
                filterInvWarehouseRequest.setSpUse(true);
            }
            filterInvWarehouseRequest.setUserId(null);
        }
        if (StrUtil.isEmpty(filterInvWarehouseRequest.getDeptCode())) {
            return ResultVOUtils.error(500, "部门不能为空");
        }
        List<InvWarehouseEntity> invSubWarehouseEntities = invWarehouseService.filterGroupInvSub(filterInvWarehouseRequest);
        return ResultVOUtils.success(invSubWarehouseEntities);
    }

    /**
     * 获取用户所有关联仓库
     *
     * @param filterInvWarehouseRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("spms/inv/warehouse/findByUser")
    public BaseResponse findByUser(FilterInvWarehouseRequest filterInvWarehouseRequest) {

        if (isHosUser()) {
            filterInvWarehouseRequest.setUserId(getUserId());
        } else {
            filterInvWarehouseRequest.setUserId(null);
        }
        filterInvWarehouseRequest.setSpUse(true);
        List<InvWarehouseEntity> invSubWarehouseEntities = invWarehouseService.filterGroupInvSub(filterInvWarehouseRequest);
        return ResultVOUtils.success(invSubWarehouseEntities);
    }

    /**
     * 前端页面查询参数拉取用户关联所有仓库接口，只返回编码，父ID和名称
     *
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("spms/inv/warehouse/findInvListByUser")
    public BaseResponse findInvListByUser(FilterInvWarehouseRequest filterInvWarehouseRequest) {
        Long userId = getUserId();
        if (null == userId) {
            return ResultVOUtils.error(ResultEnum.LOGIN_VERIFY_FALL);
        }

        if (isHosUser()) {
            filterInvWarehouseRequest.setUserId(userId);
        } else {
            filterInvWarehouseRequest.setUserId(null);
            filterInvWarehouseRequest.setSpUse(true);
        }

        List<InvWarehouseEntity> list = invWarehouseService.findInvListByUser(filterInvWarehouseRequest);
        return ResultVOUtils.success(list);
    }

    @AuthRuleAnnotation("")
    @GetMapping("spms/inv/warehouse/findInvListByUserOptimize")
    public BaseResponse findInvListByUserOptimize(FilterInvWarehouseRequest filterInvWarehouseRequest) {
        Long userId = getUserId();
        if (null == userId) {
            return ResultVOUtils.error(ResultEnum.LOGIN_VERIFY_FALL);
        }

        if (isHosUser()) {
            filterInvWarehouseRequest.setUserId(userId);
        } else {
            filterInvWarehouseRequest.setUserId(null);
            filterInvWarehouseRequest.setSpUse(true);
        }

        List<InvWarehouseEntity> list = invWarehouseService.findInvListByUser(filterInvWarehouseRequest);
        List<DictDto> reList = list.stream().map(s-> {
            DictDto dictDto = new DictDto(s.getCode(),s.getName());
            return dictDto;
        }).collect(Collectors.toList());
        return ResultVOUtils.success(reList);
    }

    /**
     * 获取往来仓库(除了自己)
     *
     * @param filterInvWarehouseRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("spms/inv/warehouse/findByFrom")
    public BaseResponse findByFrom(FilterInvWarehouseRequest filterInvWarehouseRequest) {
        if (StrUtil.isEmpty(filterInvWarehouseRequest.getLocInvCode())) {
            return ResultVOUtils.error(500, "当前仓库不能为空！");
        }
        FilterInvSubWarehouseRequest filterInvSubWarehouseRequest = new FilterInvSubWarehouseRequest();
        List<InvWarehouseEntity> invWarehouseEntities = invWarehouseService.filterInvSubWarehouse(filterInvSubWarehouseRequest);
        List<InvWarehouseEntity> results = new ArrayList<>();
        if (CollUtil.isNotEmpty(invWarehouseEntities)) {
            invWarehouseEntities.forEach(invWarehouseEntity -> {
                if (!invWarehouseEntity.getCode().equals(filterInvWarehouseRequest.getLocInvCode())) {
                    results.add(invWarehouseEntity);
                }
            });
        }
        return ResultVOUtils.success(results);
    }


    @AuthRuleAnnotation("")
    @GetMapping("spms/sub/inv/warehouse/filterSub")
    public BaseResponse filterSub(FilterInvWarehouseRequest filterInvWarehouseRequest) {

//        if (StrUtil.isEmpty(filterInvWarehouseRequest.getPcode()) || filterInvWarehouseRequest.getUserId() == null) {
//            return ResultVOUtils.error(500, "用户或仓库不能未空！");
//        }
        AuthAdmin authAdmin = customerService.getUserBean();
        InvWarehouseEntity invWarehouseEntity = invWarehouseService.filterGroupInvSubAndcode(filterInvWarehouseRequest.getCode());
        filterInvWarehouseRequest.setSubordinateCode(invWarehouseEntity.getParentId());
        filterInvWarehouseRequest.setCode(null);
        List<InvWarehouseEntity> invSubWarehouseEntities = invWarehouseService.filterGroupInvSubDown(filterInvWarehouseRequest);
        return ResultVOUtils.success(invSubWarehouseEntities);
    }


    @AuthRuleAnnotation("")
    @PostMapping("/spms/sub/inv/warehouse/save")
    @Log(title = "用户管理", businessType = BusinessType.INSERT)
    public BaseResponse save(@RequestBody InvWarehouseEntity invWarehouseEntity,
                             BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }

        boolean checkResult = invWarehouseService.checkDuplicateName(invWarehouseEntity.getParentId(), invWarehouseEntity.getName());
        if (checkResult) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, "仓库名称重复！");
        }

        FilterInvSubWarehouseRequest filterInvWarehouseRequest = new FilterInvSubWarehouseRequest();
        InvWarehouseEntity codeEntity = invWarehouseService.selectMaxCode(filterInvWarehouseRequest);
        DeptEntity pEntity = deptService.selectByCode(invWarehouseEntity.getParentId());
        if (codeEntity == null) {
            int code = Integer.parseInt(pEntity.getCode()) * 1000;
            invWarehouseEntity.setCode(code + "");
        } else {
            invWarehouseEntity.setCode(Integer.parseInt(codeEntity.getCode()) + 1 + "");
        }


        DeptEntity updateEntity = new DeptEntity();
        updateEntity.setId(pEntity.getId());
        updateEntity.setUpdateTime(new Date());
        deptService.updateInvWarehouse(updateEntity);
        invWarehouseEntity.setId(IdUtil.getSnowflake(6, 1).nextId());
        invWarehouseEntity.setUpdateTime(new Date());
        boolean b = invWarehouseService.insertInvSubWarehouse(invWarehouseEntity);
        if (!b) {
            return ResultVOUtils.error(ResultEnum.NOT_NETWORK);
        }
        return ResultVOUtils.success("添加成功！");
    }

    @AuthRuleAnnotation("")
    @PostMapping("/spms/sub/inv/warehouse/edit")
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
    public BaseResponse edit(@RequestBody @Valid InvWarehouseEntity invWarehouseEntity,
                             BindingResult bindingResult, FilterInvSubWarehouseRequest filterInvSubWarehouseRequest) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        if (invWarehouseEntity.getId() == null) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        InvWarehouseEntity originEntity = invWarehouseService.findByInvSubByCode(invWarehouseEntity.getCode());

        if (!originEntity.getParentId().equals(invWarehouseEntity.getParentId()) || (originEntity.getParentCode() != null && !originEntity.getParentCode().equals(invWarehouseEntity.getParentCode()))) {
            Integer userCount = warehouseUserService.countUserBySubInvCode(invWarehouseEntity.getCode());
            if (userCount > 0) {
                return ResultVOUtils.error(500, "修改部门或上级仓库时,请先移除该仓库关联用户！");
            }
        }


        // 先判断是否有相同名字的仓库
        boolean checkResult = invWarehouseService.updateCheckExit(invWarehouseEntity);
        if (checkResult) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, "仓库名称重复！");
        }

        //更新仓库信息
        invWarehouseEntity.setUpdateTime(new Date());
        boolean b = invWarehouseService.updateInvSubWarehouse(invWarehouseEntity);

//        //如果要是一级仓库就吧全部子集都刷成一样的寄售仓库
//        if (StrUtil.isBlank(invWarehouseEntity.getParentCode())) {
//            List<InvWarehouseEntity> invWarehouseEntityList = invWarehouseService.selectLowWarehouseAll(invWarehouseEntity.getCode());
//            for (InvWarehouseEntity obj : invWarehouseEntityList) {
//                obj.setAdvanceType(invWarehouseEntity.getAdvanceType());
//                obj.setUpdateTime(new Date());
//                invWarehouseService.updateInvSubWarehouse(obj);
//            }
//        }


        //更新部门信息
        DeptEntity pEntity = deptService.selectByCode(invWarehouseEntity.getParentId());
        pEntity.setUpdateTime(new Date());
        deptService.updateInvWarehouse(pEntity);

        //更新货位信息
        //查询此仓库绑定的所有货位
        List<InvSpace> spaceList = invSpaceService.findBySubWarehouseCode(invWarehouseEntity.getCode());
        if (CollUtil.isNotEmpty(spaceList)) {
            for (InvSpace invSpace : spaceList) {
                invSpace.setInvStorageCode(invWarehouseEntity.getParentId());
                invSpace.setUpdateTime(new Date());
            }
            invSpaceService.batchUpdate(spaceList);
        }

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

        return ResultVOUtils.success("修改成功！");


    }

    @AuthRuleAnnotation("")
    @PostMapping("/spms/sub/inv/warehouse/delete")
    @Log(title = "用户管理", businessType = BusinessType.DELETE)
    public BaseResponse delete(@RequestBody DeleteRequest deleteRequest) {

        if (deleteRequest.getId() == null) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }

        InvWarehouseEntity invWarehouseEntity = invWarehouseService.findById(deleteRequest.getId());

        //todo 代码未迁移完，记得回来修改

        Integer userCount = warehouseUserService.countUserBySubInvCode(invWarehouseEntity.getCode());
        if (userCount > 0) {
            return ResultVOUtils.error(500, "请先移除该仓库关联用户！");
        }

        List<WarehouseBussinessTypeEntity> warehouseBussinessTypeEntities = warehouseBussinessTypeService.getListByCode(invWarehouseEntity.getCode());
        if (!warehouseBussinessTypeEntities.isEmpty()) {
            return ResultVOUtils.error(500, "请先移除该仓库关联用户和单据类型！");
        }


//
//        //判断此分库中是否还有库存
//        InvWarehouseEntity invSubWarehouse = invWarehouseService.findById(deleteRequest.getId());
//        Integer count = invProductService.countByWarehouseCode(null, invSubWarehouse.getCode());
//        if (count > 0) {
//            return ResultVOUtils.error(500, "此分库存在库存，不能删除！");
//        }
//
        // 判断此分库中是否还有库存
        InvWarehouseEntity byWareId = invWarehouseService.getByWareId(deleteRequest.getId());
        List<InvWarehouseEntity> byWarePcode = invWarehouseService.getByWarePcode(byWareId.getCode());
        if (byWarePcode.size() > 0) {
            return ResultVOUtils.error(500, "此仓库下存在仓库无法删除！");
        }


        //判断此分库下是否有货位
        List<InvSpace> spaceList = invSpaceService.findBySubWarehouseCode(invWarehouseEntity.getCode());
        if (CollUtil.isNotEmpty(spaceList)) {
            return ResultVOUtils.error(500, "请先移除此分库下的货位！");
        }

        boolean b = invWarehouseService.deleteById(deleteRequest.getId());

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


    @AuthRuleAnnotation("")
    @GetMapping("/spms/sub/inv/warehouse/thridSys/detail")
    public BaseResponse getThirdSysDetail(FilterInvSubWarehouseRequest request) {
        if (null == request || null == request.getId()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        FilterBasicThirdSysRequest sysRequest = new FilterBasicThirdSysRequest();
        sysRequest.setEnabled(true);
        List<InvWarehouseThirdSysResponse> list = invWarehouseService.getThirdSysDetail(request.getId());
        PageInfo<InvWarehouseThirdSysResponse> pageInfo;
        pageInfo = new PageInfo<>(list);
        PageSimpleResponse<InvWarehouseThirdSysResponse> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(list);
        return ResultVOUtils.success(pageSimpleResponse);
    }


    @AuthRuleAnnotation("")
    @PostMapping("/spms/sub/inv/warehouse/bindThrWarehouse")
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
    public BaseResponse bindThrWarehouse(String id, String thridWarehouseId, String sysId) {
        if (null == id || null == thridWarehouseId || StrUtil.isBlank(sysId)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        invWarehouseService.bindThrWarehouse(id, thridWarehouseId, sysId);
        return ResultVOUtils.success();
    }

    /**
     * 解绑第三方仓库ID
     *
     * @param id
     * @return
     */
    @AuthRuleAnnotation("")
    @PostMapping("/spms/sub/inv/warehouse/unbindThrWarehouse")
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
    public BaseResponse unbindThrWarehouse(String id, String sysId) {
        if (null == id || StrUtil.isBlank(sysId)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        invWarehouseService.unbindThrWarehouse(id, sysId);
        return ResultVOUtils.success();
    }

    /**
     * 查询分仓列表
     *
     * @param filterInvWarehouseRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("/spms/sub/inv/warehouse/filterSubInvList")
    public BaseResponse filterSubInvList(FilterInvWarehouseRequest filterInvWarehouseRequest) {
        List<InvSubWarehouseResponse> responses = invWarehouseService.filterSubInvList(filterInvWarehouseRequest);
        return ResultVOUtils.success(responses);
    }


    /**
     * 根据仓位码获取关联用户数据
     */
    @AuthRuleAnnotation("")
    @PostMapping("/warehouse/inout/warehouseUserList")
    public BaseResponse getWarehouseUserList(@RequestBody @Valid FilterInvLinkDataRequest filterInvLinkDataRequest, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        List<WarehouseUserEntity> warehouseUserList = warehouseUserService.getWarehouseUserList(filterInvLinkDataRequest);
        PageInfo<WarehouseUserEntity> pageInfo = new PageInfo<>(warehouseUserList);
        PageSimpleResponse<WarehouseUserEntity> response = new PageSimpleResponse<>();
        response.setList(pageInfo.getList());
        response.setTotal(pageInfo.getTotal());
        return ResultVOUtils.success(response);
    }


    @AuthRuleAnnotation("")
    @PostMapping("/warehouse/inout/warehouseBussniessTypeList")
    public BaseResponse getWarehouseBussniessTypeList(@RequestBody @Valid FilterInvLinkDataRequest filterInvLinkDataRequest, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        List<WarehouseBussinessTypeEntity> warehouseBussniessTypeList = warehouseBussinessTypeService.getWarehouseBussniessTypeList(filterInvLinkDataRequest);
        PageInfo<WarehouseBussinessTypeEntity> pageInfo = new PageInfo<>(warehouseBussniessTypeList);
        PageSimpleResponse<WarehouseBussinessTypeEntity> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setList(pageInfo.getList());
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        return ResultVOUtils.success(pageSimpleResponse);
    }


    //仓库关联单据类型管理页面数据
    @AuthRuleAnnotation("")
    @PostMapping("/warehouse/invRelBusType/manageList")
    public BaseResponse getManageList(@RequestBody @Valid FilterInvLinkDataRequest filterInvLinkDataRequest, BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByInvSubByCode(filterInvLinkDataRequest.getCode());

        //1.获取所有单据类型
        FilterBussinessTypeRequest filterBussinessTypeRequest = new FilterBussinessTypeRequest();
        filterBussinessTypeRequest.setEnable(true);
        filterBussinessTypeRequest.setActionType(invWarehouseEntity.getAdvanceType());
        List<BasicBussinessTypeEntity> basicBussinessTypeEntities = basicBussinessTypeService.findList(filterBussinessTypeRequest);

        //获取仓库关联单据类型
        if (StrUtil.isEmpty(filterInvLinkDataRequest.getCode()))
            return ResultVOUtils.error(500, "仓库编码不能为空！");
        List<WarehouseBussinessTypeEntity> warehouseBussniessTypeList = warehouseBussinessTypeService.getWarehouseBussniessTypeList(filterInvLinkDataRequest);
        basicBussinessTypeEntities.forEach(basicBussinessTypeEntity ->
        {
            for (WarehouseBussinessTypeEntity warehouseBussinessTypeEntity : warehouseBussniessTypeList) {
                if (warehouseBussinessTypeEntity.getAction().equals(basicBussinessTypeEntity.getAction())) {
                    basicBussinessTypeEntity.setSelect(true);
                    break;
                }
            }
        });
        return ResultVOUtils.success(basicBussinessTypeEntities);
    }


    @AuthRuleAnnotation("")
    @PostMapping("/spms/invRelBusType/warehouse/post")
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
    public BaseResponse postRes(@RequestBody UpdateInvRelBusRequest relBusRequset) {
        if (StrUtil.isEmpty(relBusRequset.getInvCode()))
            return ResultVOUtils.error(500, "仓库编码不能为空！");

        //1.先查出已存在关联单据类型
        List<WarehouseBussinessTypeEntity> exitEntitys = warehouseBussinessTypeService.getListByCode(relBusRequset.getInvCode());
        List<WarehouseBussinessTypeEntity> removeLists = new ArrayList<>();
        for (WarehouseBussinessTypeEntity warehouseBussinessTypeEntity : exitEntitys) {
            //2.过滤出被移除单据类型
            if (!isExitBusType(relBusRequset.getSelectActions(), warehouseBussinessTypeEntity)) {
                removeLists.add(warehouseBussinessTypeEntity);
            }
        }

        List<String> removeList = new ArrayList<>();
        for (WarehouseBussinessTypeEntity warehouseBussinessTypeEntity : removeLists) {
            removeList.add(warehouseBussinessTypeEntity.getAction());
        }
//        if (CollUtil.isNotEmpty(removeList)) {
//            FilterInvBusUserRequest filterInvBusUserRequest = new FilterInvBusUserRequest();
//            filterInvBusUserRequest.setSubInvCode(relBusRequset.getInvCode());
//            filterInvBusUserRequest.setSelectedCodes(relBusRequset.getSelectActions());
//            List<InvBusUserEntity> invBusUserEntities = invBusUserService.filterInvBusUser(filterInvBusUserRequest);
//            if (CollUtil.isNotEmpty(invBusUserEntities))
//                return ResultVOUtils.error(999, "请先移除用户关联单据类型！");
//        }


        boolean b = warehouseBussinessTypeService.deleteByCode(relBusRequset.getInvCode());
        if (CollUtil.isNotEmpty(relBusRequset.getSelectActions())) {
            List<BasicBussinessTypeResponse> basicBussinessTypeResponses = new ArrayList<>();
            relBusRequset.getSelectActions().forEach(action ->
            {
                BasicBussinessTypeResponse basicBussinessTypeResponse = new BasicBussinessTypeResponse();
                basicBussinessTypeResponse.setAction(action);
                basicBussinessTypeResponses.add(basicBussinessTypeResponse);

            });

            warehouseBussinessTypeService.saveWarehouseBussinessType(relBusRequset.getInvCode(), basicBussinessTypeResponses);
        }
        //更新仓库修改时间
        InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByInvSubByCode(relBusRequset.getInvCode());
        DeptEntity pEntity = deptService.selectByCode(invWarehouseEntity.getParentId());
        pEntity.setUpdateTime(new Date());
        deptService.updateInvWarehouse(pEntity);
        return ResultVOUtils.success("修改成功！");
    }

    public boolean isExitBusType(List<String> selects, WarehouseBussinessTypeEntity warehouseBussinessTypeEntity) {
        for (String busAction : selects) {
            if (warehouseBussinessTypeEntity.getAction().equals(busAction)) {
                return true;
            }
        }
        return false;
    }


    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/bussinessType/joinFilter")
    public BaseResponse filterJoinBussinessType(BussinessTypeFilterRequest bussinessTypeFilterRequest,
                                                BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        if (StrUtil.isNotEmpty(bussinessTypeFilterRequest.getIds())) {
            List<String> idList = new ArrayList<>(Arrays.asList(bussinessTypeFilterRequest.getIds().split(",")));
            bussinessTypeFilterRequest.setActionList(idList);
        }

//        if (!StrUtil.isEmpty(bussinessTypeFilterRequest.getFilterAction())) {
//            BussinessLocalTypeEntity bussinessLocalTypeEntity = bussinessLocalTypeService.findBTByAction(bussinessTypeFilterRequest.getFilterAction());
//            if (bussinessLocalTypeEntity.getMainAction().equals(ConstantType.TYPE_PUT)) {
//                bussinessTypeFilterRequest.setMainAction(ConstantType.TYPE_OUT);
//            } else {
//                bussinessTypeFilterRequest.setMainAction(ConstantType.TYPE_PUT);
//            }
//
//            bussinessTypeFilterRequest.setAdvanceType(bussinessLocalTypeEntity.isAdvanceType());
//        }
//
//        //查询该仓库绑定的单据
//        List<WarehouseBussinessTypeEntity> warehouseBussinessTypeEntityList = warehouseBussinessTypeService.getListByCode(bussinessTypeFilterRequest.getCode());
//        List<BussinessTypResponse> bussinessTypeEntities;
//        bussinessTypeEntities = bussinessTypeService.filterJoinList(bussinessTypeFilterRequest);
//        for (BussinessTypResponse w1 : bussinessTypeEntities) {
//            for (WarehouseBussinessTypeEntity w2 : warehouseBussinessTypeEntityList) {
//                if (w1.getAction().equals(w2.getAction())) {
//                    w1.setCheckSelect(true);
//                    break;
//                }
//            }
//        }
//
//        PageInfo<BussinessTypResponse> pageInfo;
//        pageInfo = new PageInfo<>(bussinessTypeEntities);
//        PageSimpleResponse<BussinessTypResponse> pageSimpleResponse = new PageSimpleResponse<>();
//        pageSimpleResponse.setTotal(pageInfo.getTotal());
//        pageSimpleResponse.setList(bussinessTypeEntities);
//        return ResultVOUtils.success(pageSimpleResponse);

        return null;
    }

    @AuthRuleAnnotation("")
    @PostMapping("/warehouse/inout/delWarehouseUser")
    @Log(title = "用户管理", businessType = BusinessType.DELETE)
    public BaseResponse deleteWarehouseUser(Long id) {
        if (null == id)
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        WarehouseUserEntity warehouseUserEntity = warehouseUserService.selectById(id);

        List<InvBusUserEntity> invBusUserEntities = invBusUserService.selectByUnion(warehouseUserEntity.getUserid() + "", warehouseUserEntity.getCode());
        if (CollUtil.isNotEmpty(invBusUserEntities)) {
            return ResultVOUtils.error(500, "已存在该用户关联单据类型，无法删除！");
        }

        InvWarehouseEntity invSubWarehouseEntity =
                invWarehouseService.findByInvSubByCode(warehouseUserEntity.getCode());
        deptService.updateTime(invSubWarehouseEntity.getParentId(), new Date());
        warehouseUserService.deleteWarehouseUser(id);
        return ResultVOUtils.success();
    }


    @AuthRuleAnnotation("")
    @PostMapping("/warehouse/inout/addWarehouseUser")
    @Log(title = "用户管理", businessType = BusinessType.INSERT)
    public BaseResponse addWarehouseUser(@RequestBody Map<String, Object> params) {
        String code = String.valueOf(params.get("code"));
        String userListJson = String.valueOf(params.get("userList"));
        if (StrUtil.isBlank(code) || StrUtil.isBlank(userListJson))
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        List<AuthAdmin> userList = JSONUtil.toList(userListJson, AuthAdmin.class);
        warehouseUserService.saveWarehouseUser(code, userList);
        InvWarehouseEntity invSubWarehouseEntity =
                invWarehouseService.findByInvSubByCode(code);
        deptService.updateTime(invSubWarehouseEntity.getParentId(), new Date());
        return ResultVOUtils.success();
    }

    @PostMapping("/warehouse/inout/getDeptById")
    public BaseResponse getDeptById(@RequestBody List<Integer> deptIds) {
        List<DeptEntity> list = deptService.getDeptById(deptIds);
        return ResultVOUtils.success(list);
    }



    @GetMapping("spms/sub/inv/unifyWarehouseList")
    public BaseResponse unifyWarehouseList() {
        FilterInvSubWarehouseRequest filterInvSubWarehouseRequest = new FilterInvSubWarehouseRequest();
        filterInvSubWarehouseRequest.setUnifyUse(true);
        filterInvSubWarehouseRequest.setSpUse(true);
        List<InvWarehouseEntity> responses = invWarehouseService.unifyWarehouseList(filterInvSubWarehouseRequest);
        return ResultVOUtils.success(responses);
    }

    /**
     * 根据仓位码获取关联用户数据
     */
    @AuthRuleAnnotation("")
    @PostMapping("/warehouse/inout/warehouseListByCode")
    public BaseResponse warehouseListByCode(@RequestBody @Valid FilterInvLinkDataRequest filterInvLinkDataRequest, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        List<CompanyEntity> warehouseUserList = warehouseUserService.warehouseListByCode(filterInvLinkDataRequest);
        PageInfo<CompanyEntity> pageInfo = new PageInfo<>(warehouseUserList);
        PageSimpleResponse<CompanyEntity> response = new PageSimpleResponse<>();
        response.setList(pageInfo.getList());
        response.setTotal(pageInfo.getTotal());
        return ResultVOUtils.success(response);
    }



    /**
     * 获取医院用户列表
     *
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("/warehouse/inout/selectNotSelectCustomer")
    public BaseResponse selectNotSelectCustomer(FilterInvLinkDataRequest filterInvLinkDataRequest) {
        //获取当前仓库已关联用户
        FilterInvLinkDataRequest temRequest = new FilterInvLinkDataRequest();
        temRequest.setCode(filterInvLinkDataRequest.getCode());
        List<CompanyEntity> companyEntities = warehouseUserService.warehouseListByCode(temRequest);
        List<String> customerIds = new ArrayList<>();
        for (CompanyEntity item : companyEntities) {
            customerIds.add(item.getCustomerId());
        }
        FilterCompanyRequest companyRequest = new FilterCompanyRequest();
        companyRequest.setNotSelectCustomers(customerIds);
        List<CompanyEntity> companyEntities1 = companyService.filterCompany(companyRequest);

        PageInfo<CompanyEntity> pageInfo = new PageInfo<>(companyEntities1);
        PageSimpleResponse<CompanyEntity> response = new PageSimpleResponse<>();
        response.setTotal(pageInfo.getTotal());
        response.setList(companyEntities1);
        return ResultVOUtils.success(response);

    }


    @AuthRuleAnnotation("")
    @PostMapping("/warehouse/inout/addWarehouseCustomer")
    public BaseResponse addWarehouseCustomer(@RequestBody FilterInvLinkDataRequest filterInvLinkDataRequest) {
        warehouseUserService.addWarehouseCustomer(filterInvLinkDataRequest);
        return ResultVOUtils.success();
    }

    @AuthRuleAnnotation("")
    @PostMapping("/warehouse/inout/deleteWarehouseCustomer")
    public BaseResponse deleteWarehouseCustomer(@RequestBody AuthWarehouseUnify authWarehouseUnify) {
        authWarehouseUnifyService.deleteWarehouseCustomer(authWarehouseUnify);
        return ResultVOUtils.success();
    }
}