package com.ruoyi.basicData.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.ruoyi.basicData.domain.TCorps;
import com.ruoyi.basicData.domain.TCustomerContact;
import com.ruoyi.basicData.domain.TWarehouseArea;
import com.ruoyi.basicData.mapper.TCorpsMapper;
import com.ruoyi.basicData.mapper.TCustomerContactMapper;
import com.ruoyi.basicData.mapper.TWarehouseAreaMapper;
import com.ruoyi.basicData.mapper.TWarehouseMapper;
import com.ruoyi.basicData.service.ITWarehouseService;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.TreeSelect;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.entity.TWarehouse;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.exception.CustomException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysDictDataService;
import com.ruoyi.warehouseBusiness.domain.TAnnex;
import com.ruoyi.warehouseBusiness.domain.TWarehouseBills;
import com.ruoyi.warehouseBusiness.domain.dto.WarehouseSubmitDTO;
import com.ruoyi.warehouseBusiness.domain.enums.AnnexActEnum;
import com.ruoyi.warehouseBusiness.domain.vo.WarehouseInfoVO;
import com.ruoyi.warehouseBusiness.mapper.TAnnexMapper;
import com.ruoyi.warehouseBusiness.mapper.TWarehouseBillsMapper;
import com.ruoyi.warehouseBusiness.request.InventoryQueryRequest;
import com.ruoyi.warehouseBusiness.response.InventoryQueryResponse;
import com.ruoyi.warehouseBusiness.service.impl.BillnoSerialServiceImpl;
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.transaction.interceptor.TransactionAspectSupport;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 仓库Service业务层处理
 *
 * @author ruoyi
 * @date 2020-12-11
 */
@Service
public class TWarehouseServiceImpl implements ITWarehouseService {
    @Autowired
    private TAnnexMapper annexMapper;

    @Autowired
    private TWarehouseMapper tWarehouseMapper;

    @Autowired
    private TWarehouseAreaMapper tWarehouseAreaMapper;

    @Autowired
    private TWarehouseBillsMapper tWarehouseBillsMapper;

    @Autowired
    private TCustomerContactMapper customerContactMapper;

    @Autowired
    private TCorpsMapper tCorpsMapper;

    @Autowired
    private BillnoSerialServiceImpl billnoSerialServiceImpl;

    @Autowired
    private ISysDictDataService sysDictDataService;


    /**
     * 查询仓库
     *
     * @param fId 仓库ID
     * @return 仓库
     */
    @Override
    public WarehouseInfoVO selectTWarehouseById(Long fId) {
        WarehouseInfoVO warehouseInfoVO = new WarehouseInfoVO();
        TWarehouse tWarehouse = tWarehouseMapper.selectTWarehouseById(fId);
        if (Objects.nonNull(tWarehouse)) {
            BeanUtils.copyProperties(tWarehouse, warehouseInfoVO);
            TAnnex annex = new TAnnex();
            annex.setfPid(fId);
            annex.setfActid(AnnexActEnum.WAREHOUSE.getType());
            List<TAnnex> annexList = annexMapper.selectTAnnexList(annex);
            warehouseInfoVO.setAnnexList(annexList);
        }
        return warehouseInfoVO;
    }

    @Override
    public Map<String, Object> selectTWarehouseById1(Long fId) {
        Map<String, Object> map = new HashMap<>();
        TWarehouse tWarehouse = tWarehouseMapper.selectTWarehouseById(fId);
        if (StringUtils.isNotNull(tWarehouse)) {
            map.put("tWarehouse", tWarehouse);
        }
        TWarehouseArea tWarehouseArea = new TWarehouseArea();
        tWarehouseArea.setfWarehouseid(fId);
        List<TWarehouseArea> tWarehouseAreaList = tWarehouseAreaMapper.selectTWarehouseAreaList(tWarehouseArea);
        if (StringUtils.isNotEmpty(tWarehouseAreaList)) {
            map.put("tWarehouseArea", tWarehouseAreaList);
        }
        return map;
    }

    /**
     * 查询仓库列表
     *
     * @param tWarehouse 仓库
     * @return 仓库
     */
    @Override
    public List<TWarehouse> selectTWarehouseList(TWarehouse tWarehouse) {
        List<TWarehouse> list = tWarehouseMapper.selectTWarehouseList(tWarehouse);
        return list;
    }

    /**
     * 查询仓库列表
     *
     * @param tWarehouse 仓库
     * @return 仓库
     */
    @Override
    public List<WarehouseInfoVO> selectTWarehouseListAll(TWarehouse tWarehouse) {
        List<TWarehouse> list = tWarehouseMapper.selectTWarehouseList(tWarehouse);
        List<Long> ids = list.stream().map(TWarehouse::getfId).collect(Collectors.toList());
        TAnnex annex = new TAnnex();
        StringBuilder pids = new StringBuilder();
        for (Long id : ids) {
            pids.append(id).append(",");
        }
        if (ObjectUtils.isNotNull(pids) && pids.length() > 0) {
            annex.setIds(pids.substring(0, pids.length() - 1));
        }
        annex.setfActid(AnnexActEnum.WAREHOUSE.getType());
        List<TAnnex> annexList = annexMapper.selectListByPId(annex);
        List<WarehouseInfoVO> tWarehouseList = new ArrayList<>();
        for (TWarehouse tWarehouse1 : list) {
            WarehouseInfoVO warehouseInfoVO = new WarehouseInfoVO();
            BeanUtils.copyProperties(tWarehouse1, warehouseInfoVO);
            warehouseInfoVO.setfProperties(sysDictDataService.selectDictLabel("warehouse_properties", tWarehouse1.getfProperties()));
            warehouseInfoVO.setfType(sysDictDataService.selectDictLabel("warehouse_type", tWarehouse1.getfType()));
            warehouseInfoVO.setfGoodsType(sysDictDataService.selectDictLabel("data_goods_category", tWarehouse1.getfGoodsType()));
            if (ObjectUtils.isNotNull(annexList) && annexList.size() > 0) {
                warehouseInfoVO.setAnnexList(annexList.stream().filter(e -> ObjectUtils.isNotNull(e.getfPid()) && e.getfPid().equals(tWarehouse1.getfId())).collect(Collectors.toList()));
            }
            tWarehouseList.add(warehouseInfoVO);
        }
        return tWarehouseList;
    }

    @Override
    public List<TWarehouse> selectTWarehouseLists(TWarehouse tWarehouse) {
        return tWarehouseMapper.selectTWarehouseLists(tWarehouse);
    }

    @Override
    public List<Map<String, Object>> appGetWarehouseList() {
        TCustomerContact customerContact = new TCustomerContact();
        SysUser user = SecurityUtils.getLoginUser().getUser();
        Long corpId = null;
        if ("外部用户".equals(user.getDept().getDeptName())) {
            customerContact.setfTel(user.getUserName());
            List<TCustomerContact> tCustomerContacts = customerContactMapper.selectTCustomerContactList(customerContact);
            if (CollectionUtils.isNotEmpty(tCustomerContacts)) {
                corpId = tCustomerContacts.get(0).getfPid();
            }
        }
        return tWarehouseMapper.appGetWarehouseList(corpId);
    }

    /**
     * 新增仓库
     *
     * @param tWarehouse 仓库
     * @return 结果
     */
    @Override
    @Transactional
    public int insertTWarehouse(TWarehouse tWarehouse) {
        tWarehouse.setCreateTime(DateUtils.getNowDate());
        TWarehouse info = tWarehouseMapper.selectTWarehouseById(tWarehouse.getParentId());
        // 如果父节点不为正常状态,则不允许新增子节点
        if (!UserConstants.DEPT_NORMAL.equals(info.getfStatus())) {
            throw new CustomException("部门停用，不允许新增");
        }
        tWarehouse.setAncestors(info.getAncestors() + "," + tWarehouse.getParentId());
        // 所有节点转换成中文拼接
        String fWarehouseInformation = warehouseName(info.getAncestors() + "," + tWarehouse.getParentId(), tWarehouse.getfName());
        tWarehouse.setfWarehouseInformation(fWarehouseInformation);
        tWarehouseMapper.insertTWarehouse(tWarehouse);
        // 更新库容
        if (tWarehouse.getfLocation() == 1) {
            int i = updateWarehousefTotalgross(tWarehouse.getAncestors());
            if (i <= 0) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return 0;
            }
        }
        return 1;

    }

    @Override
    @Transactional
    public AjaxResult insertTWarehouse1(String tWarehouse, String tWarehouseArea, LoginUser loginUser) {
        if (StringUtils.isEmpty(tWarehouse)) {
            return AjaxResult.error("提交失败：仓库信息为空");
        }
        if (StringUtils.isEmpty(tWarehouseArea) && !"[{}]".equals(tWarehouseArea)) {
            return AjaxResult.error("提交失败：库区为空");
        }
        Long fPid = null;
        TWarehouse tWarehouses = JSONArray.parseObject(tWarehouse, TWarehouse.class);
        JSONArray jsonArray = JSONArray.parseArray(tWarehouseArea);
        List<TWarehouseArea> tWarehouseAreaList = JSONObject.parseArray(jsonArray.toJSONString(), TWarehouseArea.class);
        if (StringUtils.isNull(tWarehouses.getfId())) {
            tWarehouses.setCreateBy(loginUser.getUser().getUserName());
            tWarehouses.setCreateTime(new Date());
            tWarehouses.setfStatus("0");
            tWarehouseMapper.insertTWarehouse(tWarehouses);
            fPid = tWarehouses.getfId();
        } else {
            fPid = tWarehouses.getfId();
            tWarehouses.setUpdateBy(loginUser.getUser().getUserName());
            tWarehouses.setUpdateTime(new Date());
            if (tWarehouses.getfStatus() != null && tWarehouses.getfStatus().equals("1")) {
                TWarehouseBills tWarehouseBill = new TWarehouseBills();
                tWarehouseBill.setfWarehouseid(tWarehouses.getfId());
                List<TWarehouseBills> tWarehouseBillList = tWarehouseBillsMapper.selectTWarehousebillsList(tWarehouseBill);
                if (tWarehouseBillList != null && !tWarehouseBillList.isEmpty()) {
                    return AjaxResult.error("仓库在库存总账有记录不可变更状态");
                }
            }
            tWarehouseMapper.updateTWarehouse(tWarehouses);
            // tWarehouseAreaMapper.deleteTWarehouseAreaByTWarehoused(fPid);
        }
        for (TWarehouseArea cc : tWarehouseAreaList) {
            if (StringUtils.isNull(cc.getfNo()) ||
                    StringUtils.isNull(cc.getfName()) ||
                    StringUtils.isNull(cc.getfAddr())) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return AjaxResult.error("请完善库区明细信息");
            }
            if (cc.getfId() != null) {
                cc.setUpdateBy(loginUser.getUser().getUserName());
                cc.setUpdateTime(new Date());
                tWarehouseAreaMapper.updateTWarehouseArea(cc);
            } else {
                cc.setfWarehouseid(fPid);
                cc.setfStatus("0");
                cc.setCreateBy(loginUser.getUser().getUserName());
                cc.setCreateTime(new Date());
                tWarehouseAreaMapper.insertTWarehouseArea(cc);
            }

        }
        return AjaxResult.success();
    }

    /**
     * 修改仓库
     *
     * @param tWarehouse 仓库
     * @return 结果
     */
    @Override
    @Transactional
    public AjaxResult updateTWarehouse(TWarehouse tWarehouse) {
        if (tWarehouse.getfStatus() != null && tWarehouse.getfStatus().equals("1")) {
            TWarehouseBills tWarehouseBill = new TWarehouseBills();
            tWarehouseBill.setfWarehouseid(tWarehouse.getfId());
            List<TWarehouseBills> tWarehouseBillList = tWarehouseBillsMapper.selectTWarehousebillsList(tWarehouseBill);
            if (tWarehouseBillList != null && !tWarehouseBillList.isEmpty()) {
                return AjaxResult.error("仓库在库存总账有记录不可变更状态");
            }
        }
        tWarehouse.setUpdateTime(DateUtils.getNowDate());
        tWarehouseMapper.updateTWarehouse(tWarehouse);
        return AjaxResult.success();
    }

    @Override
    public int updateTWarehouses(TWarehouse tWarehouse) {
        TWarehouse newParentTWarehouse = tWarehouseMapper.selectTWarehouseById(tWarehouse.getParentId());
        TWarehouse oldTWarehouse = tWarehouseMapper.selectTWarehouseById(tWarehouse.getfId());
        if (StringUtils.isNotNull(newParentTWarehouse) && StringUtils.isNotNull(oldTWarehouse)) {
            String newAncestors = newParentTWarehouse.getAncestors() + "," + newParentTWarehouse.getfId();
            String oldAncestors = oldTWarehouse.getAncestors();
            tWarehouse.setAncestors(newAncestors);
            updateDeptChildren(tWarehouse.getfId(), newAncestors, oldAncestors);
            // 修改仓库信息
            String fWarehouseInformation = warehouseName(newAncestors, tWarehouse.getfName());
            tWarehouse.setfWarehouseInformation(fWarehouseInformation);
        }
        int result = tWarehouseMapper.updateTWarehouse(tWarehouse);
        if (UserConstants.DEPT_NORMAL.equals(tWarehouse.getfStatus())) {
            // 如果该部门是启用状态，则启用该部门的所有上级部门
            updateParentDeptStatus(tWarehouse);
        }
        // 更新库容
        if (tWarehouse.getfLocation() == 1) {
            int i = updateWarehousefTotalgross(tWarehouse.getAncestors());
            if (i <= 0) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return 0;
            }
        }
        return result;
    }

    /**
     * 修改子元素关系
     *
     * @param deptId       被修改的部门ID
     * @param newAncestors 新的父ID集合
     * @param oldAncestors 旧的父ID集合
     */
    public void updateDeptChildren(Long deptId, String newAncestors, String oldAncestors) {
        List<TWarehouse> children = tWarehouseMapper.selectChildrenDeptById(deptId);
        for (TWarehouse child : children) {
            child.setAncestors(child.getAncestors().replace(oldAncestors, newAncestors));
        }
        if (children.size() > 0) {
            tWarehouseMapper.updateDeptChildren(children);
        }
    }

    /**
     * 修改该部门的父级部门状态
     *
     * @param tWarehouse 当前部门
     */
    private void updateParentDeptStatus(TWarehouse tWarehouse) {
        String updateBy = tWarehouse.getUpdateBy();
        tWarehouse = tWarehouseMapper.selectTWarehouseById(tWarehouse.getfId());
        tWarehouse.setUpdateBy(updateBy);
        tWarehouseMapper.updateDeptStatus(tWarehouse);
    }

    /**
     * 批量删除仓库
     *
     * @param fIds 需要删除的仓库ID
     * @return 结果
     */
    @Override
    @Transactional
    public AjaxResult deleteTWarehouseByIds(Long[] fIds) {
        // 查询仓库主表 是否有仓库在使用
        int i = 1;
        for (Long id : fIds) {
            TWarehouseBills tWarehouseBill = new TWarehouseBills();
            tWarehouseBill.setfWarehouseid(id);
            List<TWarehouseBills> tWarehouseBillList = tWarehouseBillsMapper.selectTWarehousebillsList(tWarehouseBill);
            if (tWarehouseBillList != null && !tWarehouseBillList.isEmpty()) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return AjaxResult.error("仓库第" + i + "行仓库有货物不可删除");
            }
            tWarehouseMapper.deleteTWarehouseById(id);
            i++;
        }
        // tWarehouseMapper.deleteTWarehouseByIds(fIds);
        return AjaxResult.success();
    }

    /**
     * 删除仓库信息
     *
     * @param fId 仓库ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteTWarehouseById(Long fId) {
        TWarehouse warehouse = tWarehouseMapper.selectTWarehouseById(fId);
        tWarehouseMapper.deleteTWarehouseById(fId);
        updateParentGross(warehouse.getAncestors());

        annexMapper.deleteByPid(fId, AnnexActEnum.WAREHOUSE.getType());
        return 1;
    }

    @Override
    public String checkNameUnique(TWarehouse tWarehouse) {
        Long fId = StringUtils.isNull(tWarehouse.getfId()) ? -1L : tWarehouse.getfId();
        TWarehouse info = tWarehouseMapper.checkDeptNameUnique(tWarehouse.getfName(), tWarehouse.getParentId());
        if (StringUtils.isNotNull(info) && info.getfId().longValue() != fId.longValue()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    @Override
    public boolean hasChildByfId(Long fId) {
        int result = tWarehouseMapper.hasChildByfId(fId);
        return result > 0 ? true : false;
    }

    @Override
    public boolean checkDeptExistWarehouse(Long deptId) {
        int result = tWarehouseMapper.checkDeptExistarehouse(deptId);
        return result > 0 ? true : false;
    }

    @Override
    public boolean checkDeptExistWarehouseItems(Long deptId) {
        int result = tWarehouseMapper.checkDeptExistWarehouseItems(deptId);
        return result > 0 ? true : false;
    }

    /**
     * 新增仓库
     *
     * @param tWarehouse
     * @return
     */
    @Override
    public AjaxResult warehouseSubmit(WarehouseSubmitDTO tWarehouse) {
        // 登录用户
        String username = SecurityUtils.getUsername();
        tWarehouse.setCreateTime(new Date());
        tWarehouse.setCreateBy(username);
        TWarehouse info = tWarehouseMapper.selectTWarehouseById(tWarehouse.getParentId());
        // 如果父节点不为正常状态,则不允许新增子节点
        if (!UserConstants.DEPT_NORMAL.equals(info.getfStatus())) {
            throw new CustomException("部门停用，不允许新增");
        }
        tWarehouse.setAncestors(info.getAncestors() + "," + tWarehouse.getParentId());
        // 所有节点转换成中文拼接
        String fWarehouseInformation = warehouseName(info.getAncestors() + "," + tWarehouse.getParentId(), tWarehouse.getfName());
        tWarehouse.setfWarehouseInformation(fWarehouseInformation);
        tWarehouse.setfStatus("0");
        tWarehouseMapper.insertTWarehouse(tWarehouse);

        updateParentGross(tWarehouse.getAncestors());

        if (CollectionUtils.isNotEmpty(tWarehouse.getAnnexList())) {
            tWarehouse.getAnnexList().forEach(li -> {
                li.setfPid(tWarehouse.getfId());
                li.setfActid(AnnexActEnum.WAREHOUSE.getType());
                if (Objects.nonNull(li.getfId())) {
                    li.setCreateTime(new Date());
                    li.setCreateBy(username);
                } else {
                    li.setUpdateTime(new Date());
                    li.setUpdateBy(username);
                }
                annexMapper.insertTAnnex(li);
            });
        }
        return AjaxResult.success();
    }

    /**
     * 修改仓库
     *
     * @param tWarehouse
     * @return
     */
    @Override
    @Transactional
    public AjaxResult edit(WarehouseSubmitDTO tWarehouse) {
        // 登录用户
        String username = SecurityUtils.getUsername();

        tWarehouse.setUpdateBy(username);
        tWarehouseMapper.updateTWarehouse(tWarehouse);

        updateParentGross(tWarehouse.getAncestors());

        annexMapper.deleteByPid(tWarehouse.getfId(), AnnexActEnum.WAREHOUSE.getType());
        if (CollectionUtils.isNotEmpty(tWarehouse.getAnnexList())) {
            tWarehouse.getAnnexList().forEach(li -> {
                li.setfPid(tWarehouse.getfId());
                li.setfActid(AnnexActEnum.WAREHOUSE.getType());
                if (Objects.nonNull(li.getfId())) {
                    li.setCreateTime(new Date());
                    li.setCreateBy(username);
                } else {
                    li.setUpdateTime(new Date());
                    li.setUpdateBy(username);
                }
                annexMapper.insertTAnnex(li);
            });
        }
        return AjaxResult.success();
    }

    /**
     * 仓库懒加载列表
     *
     * @param tWarehouse
     * @return
     */
    @Override
    public List<TWarehouse> lazyList(TWarehouse tWarehouse) {
        if (StringUtils.isNull(tWarehouse.getParentId()) && StringUtils.isEmpty(tWarehouse.getfName()) &&
                StringUtils.isNull(tWarehouse.getfStatus()) && StringUtils.isNull(tWarehouse.getfProperties()) &&
                StringUtils.isNull(tWarehouse.getfAddr()) && StringUtils.isNull(tWarehouse.getfType()) && StringUtils.isNull(tWarehouse.getfGoodsType())) {
            tWarehouse.setParentId(0L);
        }
        return tWarehouseMapper.lazyList(tWarehouse);
    }

    @Override
    public TWarehouse selectByCode(String position) {
        return tWarehouseMapper.getWarehouseByNo(position);
    }

    @Override
    public List<Map<String, Object>> queryGoodsAccountByPageV1(String warehouseCode,
                                                               String ownerSocialIdentifier,
                                                               String ownerCode,
                                                               String ownerName,
                                                               String goodsName,
                                                               String specifications,
                                                               String producing,
                                                               String materialQuality,
                                                               String level,
                                                               Integer pageNo,
                                                               Integer pageSize) {
        if ("null".equals(warehouseCode)) {
            warehouseCode = null;
        }
        return tWarehouseMapper.queryGoodsAccountByPageV1(warehouseCode, ownerSocialIdentifier, ownerCode, ownerName, goodsName, specifications,
                producing, materialQuality, level, pageNo, pageSize);
    }

    @Override
    public List<Map<String, Object>> queryGoodsAccountDetailByPageV1(String warehouseCode, String ownerName, String ownerCode, String ownerSocialIdentifier, String goodsName, String specifications,
                                                                     String producing, String materialQuality, String level, String receiptDoc, String billOfLading,
                                                                     String areaName, String areaCode, String slotName, String slotCode, Integer pageNo, Integer pageSize) {
        if ("null".equals(warehouseCode)) {
            warehouseCode = null;
        }
        return tWarehouseMapper.queryGoodsAccountDetailByPageV1(warehouseCode, ownerName, ownerCode, ownerSocialIdentifier, goodsName, specifications,
                producing, materialQuality, level, receiptDoc, billOfLading, areaName, areaCode, slotName, slotCode, pageNo, pageSize);
    }

    /**
     * 获取仓库详细信息
     */
    @Override
    public TWarehouse getWareHouseInfo(String wareHouseId) {
        return tWarehouseMapper.getWareHouseInfo(wareHouseId);
    }

    /**
     * 获取最新的库存数据
     */
    @Override
    public Map<String, Object> getStorageInfo(String wareHouseId) {
        return tWarehouseMapper.getStorageInfo(wareHouseId);
    }

    /**
     * 库存吞吐趋势信息
     */
    @Override
    public List<Map<String, Object>> getTimeStorageInfo(String wareHouseId, String startTime, String endTime) {
        return tWarehouseMapper.getTimeStorageInfo(wareHouseId, startTime, endTime);
    }

    /**
     * 库存吞吐趋势信息
     */
    @Override
    public List<Map<String, Object>> getTimeThroughputInfo(String wareHouseId, String startTime, String endTime) {
        return tWarehouseMapper.getTimeThroughputInfo(wareHouseId, startTime, endTime);
    }

    /**
     * 货物保管信息
     */
    @Override
    public Map<String, Object> getCargoInfo(String wareHouseId, String startTime, String endTime, String isPledge) {
        return tWarehouseMapper.getCargoInfo(wareHouseId, startTime, endTime, isPledge);
    }

    /**
     * 货物保管信息
     */
    @Override
    public List<Map<String, Object>> getGoodsList(String wareHouseId, String startTime, String endTime) {
        return tWarehouseMapper.getGoodsList(wareHouseId, startTime, endTime);
    }

    /**
     * 仓库保管趋势
     */
    @Override
    public List<Map<String, Object>> getCargoInfoTrend(String wareHouseId, String startTime, String endTime, String FTradeModeId) {
        return tWarehouseMapper.getCargoInfoTrend(wareHouseId, startTime, endTime, FTradeModeId);
    }

    /**
     * 获取货物品类top值
     */
    @Override
    public List<Map<String, Object>> getStorageTop(String wareHouseId, Integer countType, Integer topCnt) {
        return tWarehouseMapper.getStorageTop(wareHouseId, countType, topCnt);
    }

    /**
     * 获取货物品类top值
     */
    @Override
    public List<Map<String, Object>> getStorageTopS(String wareHouseId, Integer countType, Integer topCnt) {
        return tWarehouseMapper.getStorageTopS(wareHouseId, countType, topCnt);
    }

    /**
     * 获取货主仓库top值
     */
    @Override
    public List<Map<String, Object>> getGoodsTop(String wareHouseId, Integer countType, Integer topCnt) {
        return tWarehouseMapper.getGoodsTop(wareHouseId, countType, topCnt);
    }

    /**
     * 过户交易信息获取
     */
    @Override
    public List<Map<String, Object>> getTransferTransaction(String wareHouseId, String startTime, String endTime) {
        return tWarehouseMapper.getTransferTransaction(wareHouseId, startTime, endTime);
    }

    /**
     * 最新的作业统计
     */
    @Override
    public Map<String, Object> getWorkInfo(String wareHouseId, String countType) {
        return tWarehouseMapper.getWorkInfo(wareHouseId, countType);
    }

    /**
     * 作业统计趋势数据
     */
    @Override
    public List<Map<String, Object>> getWorkTrend(String wareHouseId, String startTime, String endTime, String countType) {
        return tWarehouseMapper.getWorkTrend(wareHouseId, startTime, endTime, countType);
    }

    /**
     * 获取仓库详细信息
     */
    @Override
    public List<InventoryQueryResponse> inventoryQueries(InventoryQueryRequest inventoryQueryRequest) {
        return tWarehouseMapper.inventoryQueries(inventoryQueryRequest.getCurrentOwnerName(),
                inventoryQueryRequest.getCurrentOwnerSocialIdentifier(),
                inventoryQueryRequest.getWarehouseSerialNumbers());
    }
/**
     * 获取仓库详细信息
     */
    @Override
    public List<InventoryQueryResponse> inventoryQueriesV2(InventoryQueryRequest inventoryQueryRequest) {
        return tWarehouseMapper.inventoryQueriesV2(inventoryQueryRequest.getCurrentOwnerName(),
                inventoryQueryRequest.getCurrentOwnerSocialIdentifier(),
                inventoryQueryRequest.getWarehouseSerialNumbers());
    }

    /**
     * 仓单注册指令
     */
    @Override
    public int receiptRegister(String ownerName, String identifier, String numbers) {
        return tWarehouseMapper.receiptRegister(ownerName, identifier, numbers);
    }

    /**
     * 客户检验指令
     */
    @Override
    public TCorps verification(String name, String identifier) {
        return tCorpsMapper.verification(name, identifier);
    }

    /**
     * 仓单过户指令
     */
    @Override
    public int receiptTransfer(TWarehouseBills warehouseBills) {
        warehouseBills.setfBilltype("HQZY");
        warehouseBills.setfBillstatus(2L);
        warehouseBills.setfDeptid(100L);
        warehouseBills.setfBsdeptid(100L);
        warehouseBills.setCreateTime(new Date());
        warehouseBills.setCreateBy("admin");
        Date time = new Date();
        // 业务编码
        String billNo = billnoSerialServiceImpl.getBillNo("HQZY", time);
        warehouseBills.setfBillno(billNo);
        // 存货编码
        String bscorpno = billnoSerialServiceImpl.getCorpNo(warehouseBills.getfCorpid(), time);
        warehouseBills.setfBscorpno(bscorpno);
        warehouseBills.setfChargedate(time);
        warehouseBills.setfBsdate(time);
        warehouseBills.setfTrademodeid(1L);
        warehouseBills.setfItemsStatus(2L);
        return tWarehouseBillsMapper.insertTWarehousebills(warehouseBills);
    }

    /**
     * 仓单解锁指令
     */
    @Override
    public int receiptCancel(String ownerName, String identifier, String numbers) {
        return tWarehouseMapper.receiptCancel(ownerName, identifier, numbers);
    }

    @Override
    public String checkUFNoUnique(TWarehouse tWarehouse) {
        TWarehouse tWarehouse1 = tWarehouseMapper.checkFNoUnique(tWarehouse.getfNo());
        if (StringUtils.isNotNull(tWarehouse1) && tWarehouse1.getfId() != tWarehouse.getfId()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    @Override
    public String checkUFNnameUnique(TWarehouse tWarehouse) {
        TWarehouse tWarehouse1 = tWarehouseMapper.checkUFNnameUnique(tWarehouse.getfName());
        if (StringUtils.isNotNull(tWarehouse1) && tWarehouse1.getfId() != tWarehouse.getfId()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    @Override
    public String checkUFAaddrUnique(TWarehouse tWarehouse) {
        TWarehouse tWarehouse1 = tWarehouseMapper.checkUFAaddrUnique(tWarehouse.getfAddr());
        if (StringUtils.isNotNull(tWarehouse1) && tWarehouse1.getfId() != tWarehouse.getfId()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    @Override
    public String checkUFTWarehouseAreaNoUnique(TWarehouseArea tWarehouseAreas) {
        TWarehouseArea tWarehouseAreas1 = tWarehouseAreaMapper.checkFNoUnique(tWarehouseAreas.getfNo(), tWarehouseAreas.getfWarehouseid());
        if (StringUtils.isNotNull(tWarehouseAreas1) && tWarehouseAreas1.getfId() != tWarehouseAreas.getfId()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    @Override
    public String checkUTWarehouseAreaFNnameUnique(TWarehouseArea tWarehouseAreas) {
        TWarehouseArea tWarehouseAreas1 = tWarehouseAreaMapper.checkUFNnameUnique(tWarehouseAreas.getfName(), tWarehouseAreas.getfWarehouseid());
        if (StringUtils.isNotNull(tWarehouseAreas1) && tWarehouseAreas1.getfId() != tWarehouseAreas.getfId()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    @Override
    public int selectNormalChildrenDeptById(Long fId) {
        return tWarehouseMapper.selectNormalChildrenDeptById(fId);
    }

    @Override
    public List<TreeSelect> buildDeptTreeSelect(List<TWarehouse> tWarehouses) {
        List<TWarehouse> deptTrees = buildDeptTree(tWarehouses);
        return deptTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
    }

    /**
     * 构建前端所需要树结构
     *
     * @param depts 部门列表
     * @return 树结构列表
     */
    @Override
    public List<TWarehouse> buildDeptTree(List<TWarehouse> depts) {
        List<TWarehouse> returnList = new ArrayList<TWarehouse>();
        List<Long> tempList = new ArrayList<Long>();
        for (TWarehouse dept : depts) {
            tempList.add(dept.getfId());
        }
        for (Iterator<TWarehouse> iterator = depts.iterator(); iterator.hasNext(); ) {
            TWarehouse dept = (TWarehouse) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(dept.getParentId())) {
                recursionFn(depts, dept);
                returnList.add(dept);
            }
        }
        if (returnList.isEmpty()) {
            returnList = depts;
        }
        return returnList;
    }

    @Override
    public String checkUFAreUnique(TWarehouse tWarehouse) {
        TWarehouseArea tWarehouseArea = tWarehouseAreaMapper.selectTWarehouseAreaByWarehouseId(tWarehouse.getParentId());
        if (StringUtils.isNotNull(tWarehouseArea)) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 递归列表
     */
    private void recursionFn(List<TWarehouse> list, TWarehouse t) {
        // 得到子节点列表
        List<TWarehouse> childList = getChildList(list, t);
        t.setChildren(childList);
        for (TWarehouse tChild : childList) {
            if (hasChild(list, tChild)) {
                recursionFn(list, tChild);
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private List<TWarehouse> getChildList(List<TWarehouse> list, TWarehouse t) {
        List<TWarehouse> tlist = new ArrayList<TWarehouse>();
        Iterator<TWarehouse> it = list.iterator();
        while (it.hasNext()) {
            TWarehouse n = (TWarehouse) it.next();
            if (StringUtils.isNotNull(n.getParentId()) && n.getParentId().longValue() == t.getfId().longValue()) {
                tlist.add(n);
            }
        }
        return tlist;
    }

    /**
     * 判断是否有子节点
     */
    private boolean hasChild(List<TWarehouse> list, TWarehouse t) {
        return getChildList(list, t).size() > 0 ? true : false;
    }

    public String warehouseName(String ancestors, String oldName) {
        String str[] = ancestors.split(",");
        String fWarehouseInformation = "";
        for (String id : str) {
            if (!(id.equals("0")) && !(id.equals("100"))) {
                // 查询仓库名称
                TWarehouse tWarehouse = tWarehouseMapper.selectTWarehouseById(Long.valueOf(id));
                fWarehouseInformation += tWarehouse.getfName() + "/";
            }
        }
        if (StringUtils.isNull(fWarehouseInformation) && !fWarehouseInformation.equals("")) {
            fWarehouseInformation = oldName;
        } else {
            fWarehouseInformation += oldName;
        }
        return fWarehouseInformation;
    }

    /**
     * 修改仓库库容
     *
     * @param ancestors
     * @return
     */
    public int updateWarehousefTotalgross(String ancestors) {
        String str[] = ancestors.split(",");
        Long warehouseId = 0L;
        for (String id : str) {
            if (!(id.equals("0")) && !(id.equals("100"))) {
                warehouseId = Long.valueOf(id);
                break;
            }
        }
        if (warehouseId != 0) {
            // 所有库容
            BigDecimal fTotalgross = tWarehouseMapper.selectTWarehouseFTotalgross(warehouseId);
            TWarehouse tWarehouseNew = new TWarehouse();
            tWarehouseNew.setfId(warehouseId);
            tWarehouseNew.setfTotalgross(fTotalgross);
            return tWarehouseMapper.updatefTotalgross(tWarehouseNew);
        } else {
            return 0;
        }
    }

    private void updateParentGross(String ancestors) {
        String[] split = ancestors.split(",");
        Collections.reverse(Arrays.asList(split));

        for (String ancestor : split) {
            if ("0".equals(ancestor) || "100".equals(ancestor)) {
                break;
            }

            Long parentId = Long.valueOf(ancestor);
            List<TWarehouse> tWarehouses = tWarehouseMapper.selectChildrenDeptById(parentId);
            BigDecimal allGross = new BigDecimal("0");

            for (TWarehouse warehouse : tWarehouses) {
                if (StringUtils.isNotNull(warehouse.getfTotalgross())) {
                    allGross = allGross.add(warehouse.getfTotalgross());
                }
            }

            if (allGross.compareTo(BigDecimal.ZERO) > 0) {
                TWarehouse parent = new TWarehouse();
                parent.setfId(parentId);
                parent.setfTotalgross(allGross);
                tWarehouseMapper.updatefTotalgross(parent);
            }
        }
    }

}