package com.ruoyi.base.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.base.constant.Constant;
import com.ruoyi.base.domain.BaseLocationInfo;
import com.ruoyi.base.domain.BaseLocationZone;
import com.ruoyi.base.domain.dto.BaseLocationInfoSameColDTO;
import com.ruoyi.base.domain.vo.*;
import com.ruoyi.base.mapper.BaseLocationInfoMapper;
import com.ruoyi.base.mapper.BaseLocationZoneMapper;
import com.ruoyi.base.service.IBaseLocationInfoService;
import com.ruoyi.base.utils.CommonUtils;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 库位信息Service业务层处理
 *
 * @author andy
 * @date 2022-02-18
 */
@Slf4j
@Service
public class BaseLocationInfoServiceImpl implements IBaseLocationInfoService {

    @Autowired
    private BaseLocationInfoMapper baseLocationInfoMapper;
    @Autowired
    private BaseLocationZoneMapper baseLocationZoneMapper;

    /**
     * 入库校验同列任务任务状态和阻挡
     *
     * @param basLocationList
     * @return
     */
    public BaseLocationLotattDTO checkTheSameColumnLocation(List<BaseLocationLotattDTO> basLocationList) {
        boolean isBlock = false; // 是否阻挡
        BaseLocationLotattDTO basLocation = null;
        //筛选2次 第2次去除同列占用和阻挡条件 todo 先筛选一次吧
        for (int i = 0; i < 1 && basLocation == null; i++) {
            for (BaseLocationLotattDTO location : basLocationList) {
                //如果库位类型不为地堆则不用判断同列占用和阻挡
                if (location.getLocationType().equals("2")) {
                    isBlock = true;
                }

                //只有第一次判断同列任务占用和阻挡
                if (i == 0 && isBlock) {
                    //同列是否有任务
                    List<BaseLocationInfo> occupyByLocs = baseLocationInfoMapper.queryByListOccupyByLoc(location);
                    if (occupyByLocs.size() > 0) {
                        continue;
                    }
                    //同列前方是否有阻挡
                    List<BaseLocationInfo> inStockByLocs = baseLocationInfoMapper.queryByListInStockByLoc(location);
                    if (inStockByLocs.size() > 0) {
                        continue;
                    }
                }
                basLocation = location;
                break;
            }
        }
        return basLocation;
    }

    /**
     * @param baseLocationLotattVO 要判断的库位
     * @return
     */
    public BaseLocationLotattDTO checkTheSameColumnLocation1(BaseLocationLotattDTO baseLocationLotattVO, List<BaseLocationLotattDTO> baseLocationList) {

        if (CollectionUtil.isEmpty(baseLocationList)) return null;

        //查同列所有库位
        List<BaseLocationLotattDTO> baseLocationInfos = baseLocationInfoMapper.queryByListInUserdeFine1(baseLocationLotattVO);

        if (baseLocationInfos.size() == 1) {
            return baseLocationLotattVO;
        }

        //同列是否有任务
        List<BaseLocationInfo> occupyByLocs = baseLocationInfoMapper.queryByListOccupyByLoc(baseLocationLotattVO);
        if (occupyByLocs.size() > 0) {
            return null;
        }

        //同列前方是否有阻挡
        List<BaseLocationInfo> inStockByLocs = baseLocationInfoMapper.queryByListInStockByLoc(baseLocationLotattVO);
        if (CollectionUtil.isEmpty(inStockByLocs)) return baseLocationLotattVO;

        if (inStockByLocs.size() > 0) {

            boolean isSuccess = true;
            for (int i = 0; i < inStockByLocs.size(); i++) {
                if (baseLocationList.size() == 0) {
                    return null;
                }

                boolean isSuit = false;
                for (BaseLocationInfo baseLocationInfo : baseLocationList) {

                    if (inStockByLocs.get(i).getId().equals(baseLocationInfo.getId())) {

                        isSuit = true;
                    }
                }

                isSuccess = isSuit;
                if (!isSuccess) return null;
            }
        }
        return baseLocationLotattVO;
    }

    /**
     * 查询库位信息
     *
     * @param id 库位信息主键
     * @return 库位信息
     */
    @Override
    public BaseLocationInfo selectBaseLocationInfoById(Long id) {
        return baseLocationInfoMapper.selectBaseLocationInfoById(id);
    }

    @Override
    public BaseLocationInfo selectBaseLocationInfoByIdOrNo(String idOrNo, Long warehouseId) {
        BaseLocationInfo locationInfo = null;
        try {
            locationInfo = baseLocationInfoMapper.selectBaseLocationInfoById(Long.parseLong(idOrNo));
        } catch (Exception e) {

        }
        if (locationInfo == null) {
            return baseLocationInfoMapper.selectBaseLocationInfoByLocationNo(idOrNo, warehouseId);
        } else {
            return locationInfo;
        }
    }

    @Override
    public List<BaseLocationLotattDTO> selectAllocatingLocationAccordingConditionsOrderBy(List<String> zoneId, String bindSku, String orderBy) {
        return baseLocationInfoMapper.selectAllocatingLocationAccordingConditionsOrderBy(zoneId, Constant.WAREHOUSE_ID, bindSku
                , orderBy);
    }

    @Override
    public List<BaseLocationLotattDTO> selectAllocatingInventoryAccordingConditionsOrderBy(List<String> zoneId, Map<String, String> lotatt, String sku
            , String orderBy) {
        return baseLocationInfoMapper.selectAllocatingInventoryAccordingConditionsOrderBy(zoneId, Constant.WAREHOUSE_ID, lotatt, sku
                , orderBy);
    }

    /**
     * 查询库位信息列表
     *
     * @param baseLocationInfo 库位信息
     * @return 库位信息
     */
    @Override
    public List<BaseLocationInfo> selectBaseLocationInfoList(BaseLocationInfo baseLocationInfo) {
        return baseLocationInfoMapper.selectBaseLocationInfoList(baseLocationInfo);
    }

    @Override
    public List<BaseLocationInfo> selectBaseLocationInfoList(long locId) {
        BaseLocationInfo baseLocationInfo = new BaseLocationInfo();
        baseLocationInfo.setId(locId);
        return baseLocationInfoMapper.selectBaseLocationInfoList(baseLocationInfo);
    }

    /**
     * 新增库位信息
     *
     * @param baseLocationInfo 库位信息
     * @return 结果
     */
    @Override
    public int insertBaseLocationInfo(BaseLocationInfo baseLocationInfo) {
        baseLocationInfo.setCreateTime(DateUtils.getNowDate());
        return baseLocationInfoMapper.insertBaseLocationInfo(baseLocationInfo);
    }

    /**
     * 修改库位信息
     *
     * @param baseLocationInfo 库位信息
     * @return 结果
     */
    @Override
    public int updateBaseLocationInfo(BaseLocationInfo baseLocationInfo) {
        baseLocationInfo.setUpdateTime(DateUtils.getNowDate());
        return baseLocationInfoMapper.updateBaseLocationInfo(baseLocationInfo);
    }

    /**
     * 批量删除库位信息
     *
     * @param ids 需要删除的库位信息主键
     * @return 结果
     */
    @Override
    public int deleteBaseLocationInfoByIds(Long[] ids) {
        return baseLocationInfoMapper.deleteBaseLocationInfoByIds(ids);
    }

    /**
     * 删除库位信息信息
     *
     * @param id 库位信息主键
     * @return 结果
     */
    @Override
    public int deleteBaseLocationInfoById(Long id) {
        return baseLocationInfoMapper.deleteBaseLocationInfoById(id);
    }

    @Override
    public List<TreeSelectVO> buildLocationTreeSelect() {
        List<BasLocationTreeSelectVO> locationTrees = buildLocationTree(0L);
        return locationTrees.stream().map(TreeSelectVO::new).collect(Collectors.toList());
    }

    @Override
    public List<BasLocationTreeSelectVO> buildLocationTree(Long zoneId) {
        // 查询区域，库位树把区域也组装进去
        BaseLocationZone queryZone = new BaseLocationZone();
        queryZone.setStatus("0");
        List<BaseLocationZone> zoneList = baseLocationZoneMapper.selectBaseLocationZoneList(queryZone);
        List<BasLocationTreeSelectVO> locationTreeSelectVOList = new ArrayList<>();
        //循环遍历每个区域的库位
        for (BaseLocationZone zone : zoneList) {
            BasLocationTreeSelectVO parent = new BasLocationTreeSelectVO();
            List<BasLocationTreeSelectVO> children = new ArrayList<>();
            BaseLocationInfo query = new BaseLocationInfo();
            query.setZoneId(zone.getZoneId());
            List<BaseLocationInfo> locationInfoList = baseLocationInfoMapper.selectBaseLocationInfoList(query);
            for (BaseLocationInfo b : locationInfoList) {
                BasLocationTreeSelectVO child = new BasLocationTreeSelectVO();
                child.setId(b.getId());
                child.setTreeName(b.getLocationNo());
                children.add(child);
            }
            parent.setId(zone.getZoneId());
            parent.setTreeName(zone.getZoneName());
            parent.setChildren(children);
            locationTreeSelectVOList.add(parent);
        }
        return locationTreeSelectVOList;
    }

    @Override
    public boolean checkIsLocation(String idOrNo, Long warehouseId) {
        BaseLocationInfo baseLocationInfo = this.selectBaseLocationInfoByIdOrNo(idOrNo, warehouseId);
        if (baseLocationInfo == null) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public List<BaseLocationInfo> selectSortedLocatinListByZoneId(Long zoneId, Long warehouseId, String orderBy) {
        BaseLocationInfo query = new BaseLocationInfo();
        query.setWarehouseId(warehouseId);
        query.setZoneId(zoneId);
        query.setOrderByClause(orderBy);
        return baseLocationInfoMapper.selectSortedLocationListByZoneId(query);
    }

    @Override
    public List<BaseLocationLotattListVO> selectSortedLocatinListByZoneId(List<Long> locationId, Long warehouseId, Map<String, String> lotatt, String sku) {
        List<BaseLocationLotattListVO> result = new ArrayList<>();
        List<BaseLocationLotattDTO> locationLotattVOList = baseLocationInfoMapper.selectSortedLocationLotattListByLocationIdList(locationId, warehouseId, lotatt, sku);
        BaseLocationLotattListVO current = null;
        for (BaseLocationLotattDTO vo : locationLotattVOList) {
            if (current == null || current.getId().longValue() != vo.getId().longValue()) {
                current = new BaseLocationLotattListVO();
                BeanUtils.copyProperties(vo, current);
                List<LotattInfo> lotattInfoList = new ArrayList<>();
                current.setLotattInfoList(lotattInfoList);
                result.add(current);
            }
            LotattInfo lotattObj = new LotattInfo();
            lotattObj.setSku(vo.getSku());
            lotattObj.setQty(vo.getQty());
            lotattObj.setLotattVO(vo.getLotattVO());
            current.getLotattInfoList().add(lotattObj);
        }
        return result;
    }

    @Override
    public int updateLocationStockStatus(Long id, String status) {
        return baseLocationInfoMapper.updateLocationStockStatus(id, status);
    }

    @Override
    public List<BaseLocationInfo> selectNeighborLocation(String colNo, Long zoneId) {
        List<BaseLocationInfo> colNoList = baseLocationInfoMapper.selectAllColNo();
        List<BaseLocationInfo> resultList = new ArrayList<>();
        String preColNo = "";
        String nextColNo = "";
        BaseLocationInfo currentLocation = null;
        for (int i = 0; i < colNoList.size(); i++) {
            if (!colNoList.get(i).getColNo().equals(colNo) && preColNo.equals("")) {
                preColNo = colNoList.get(i).getColNo();
                continue;
            }
            if (colNoList.get(i).getColNo().equals(colNo)) {
                currentLocation = colNoList.get(i);
                preColNo = colNoList.get(i - 1).getColNo();
                if (i + 1 < colNoList.size()) {
                    nextColNo = colNoList.get(i + 1).getColNo();
                }
                continue;
            }
            if (nextColNo.equals(colNoList.get(i).getColNo())) {
                continue;
            } else {
                if (i + 1 < colNoList.size()) {
                    if (currentLocation != null) {
                        if (CommonUtils.getString(colNoList.get(i + 1).getBindSku()).equals("") || CommonUtils.getString(colNoList.get(i + 1).getBindSku()).equals(currentLocation.getBindSku())) {
                            nextColNo = colNoList.get(i + 1).getColNo();
                        }
                    }
                }
            }
        }
        resultList.addAll(baseLocationInfoMapper.selectLocationByColNo(colNo));
        resultList.addAll(baseLocationInfoMapper.selectLocationByColNo(preColNo));
        resultList.addAll(baseLocationInfoMapper.selectLocationByColNo(nextColNo));
        return resultList;
    }

    @Override
    public Boolean verifyLocationIsIdle(String locationId, Long warehouseId) {
        BaseLocationInfo baseLocationInfo = selectBaseLocationInfoByIdOrNo(locationId, warehouseId);
        if (!baseLocationInfo.getStockStatus().equals(Constant.STOCK_STATUS.STOCK00.getValue())) {
            return false;
        }
        return true;
    }

    @Override
    public Boolean verifyLocationIsInStock(String locationId, Long warehouseId) {
        BaseLocationInfo baseLocationInfo = selectBaseLocationInfoByIdOrNo(locationId, warehouseId);
        if (baseLocationInfo.getIsEmpty().equals(Constant.IS_YES.Y.toString())) {
            return false;
        }
        return true;
    }

    @Override
    public boolean lockLocationStockStatus(Long id, Long warehouseId, String updateBy) {
        return updateLocationStockStatusAndIsEmpty(id, warehouseId, updateBy
                , Constant.STOCK_STATUS.STOCK10, null);
    }

    @Override
    public boolean unLockLocationStockStatus(Long id, Long warehouseId, String updateBy) {
        return updateLocationStockStatusAndIsEmpty(id, warehouseId, updateBy
                , Constant.STOCK_STATUS.STOCK00, null);
    }

    @Override
    public boolean lockLocationStockStatus(Long locationFromId, Long locationToId, Long warehouseId, String updateBy) {
        if (!lockLocationStockStatus(locationFromId, warehouseId, updateBy)) {
            return false;
        }
        return lockLocationStockStatus(locationToId, warehouseId, updateBy);
    }

    @Override
    public boolean unLockLocationStockStatus(Long locationFromId, Long locationToId, Long warehouseId, String updateBy) {
        if (!unLockLocationStockStatus(locationFromId, warehouseId, updateBy)) {
            return false;
        }
        return unLockLocationStockStatus(locationToId, warehouseId, updateBy);
    }

    @Override
    public boolean occupyLocation(Long id, Long warehouseId, String updateBy) {
        return updateLocationStockStatusAndIsEmpty(id, warehouseId, updateBy
                , null, Constant.IS_YES.N);
    }

    @Override
    public boolean unOccupyLocation(Long id, Long warehouseId, String updateBy) {
        return updateLocationStockStatusAndIsEmpty(id, warehouseId, updateBy
                , null, Constant.IS_YES.Y);
    }

    @Override
    public boolean updateLocationIdleAndEmpty(Long id, Long warehouseId, String updateBy) {
        return updateLocationStockStatusAndIsEmpty(id, warehouseId, updateBy
                , Constant.STOCK_STATUS.STOCK00, Constant.IS_YES.Y);
    }

    @Override
    public boolean updateLocationIdleAndNoEmpty(Long id, Long warehouseId, String updateBy) {
        return updateLocationStockStatusAndIsEmpty(id, warehouseId, updateBy
                , Constant.STOCK_STATUS.STOCK00, Constant.IS_YES.N);
    }

    @Override
    public List<BaseLocationInfo> selectBeforeLocationByColNo(String colNo, Long colIndex) {
        return baseLocationInfoMapper.selectBeforeLocationByColNo(colNo, colIndex);
    }

    @Override
    public List<BaseLocationInfoSameColDTO> selectSameColCanToLoc(String colNo, Long colIndex) {
        return baseLocationInfoMapper.selectSameColCanToLoc(colNo, colIndex);
    }

    private boolean updateLocationStockStatusAndIsEmpty(Long id, Long warehouseId, String updateBy
            , Constant.STOCK_STATUS stockStatus, Constant.IS_YES isYes) {
        BaseLocationInfo locationInfo = selectBaseLocationInfoById(id);
        if (locationInfo == null) {
            return false;
        }
        BaseLocationInfo locationInfoFromUpdate = new BaseLocationInfo();
        locationInfoFromUpdate.setId(locationInfo.getId());
        if (stockStatus != null) {
            locationInfoFromUpdate.setStockStatus(stockStatus.getValue());
        }
        if (isYes != null) {
            locationInfoFromUpdate.setIsEmpty(isYes.toString());
        }
        locationInfoFromUpdate.setUpdateBy(updateBy);
        locationInfoFromUpdate.setWarehouseId(warehouseId);
        return this.updateBaseLocationInfo(locationInfoFromUpdate) > 0;
    }

    @Override
    public AjaxResult importLocation(List<BaseLocationInfo> list, boolean updateSupport, String opname) {
        if (StringUtils.isNull(list) || list.size() == 0) {
            throw new ServiceException("导入库位基本信息数据不能为空！");
        }
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        for (BaseLocationInfo baseLocationInfo : list) {
            try {
                if (StringUtils.isEmpty(baseLocationInfo.getLocationNo())) {
                    if (baseLocationInfo.getLocationType().equals("1")) {
                        baseLocationInfo.setLocationNo(baseLocationInfo.getColNo() + "-" + StringUtils.addZero(baseLocationInfo.getRowNo(), 2) + "-" + StringUtils.addZero(baseLocationInfo.getRowIndex(), 2));
                    } else {
                        baseLocationInfo.setLocationNo(baseLocationInfo.getRowNo() + "-" + StringUtils.addZero(baseLocationInfo.getColNo(), 2) + "-" + StringUtils.addZero(baseLocationInfo.getColIndex().toString(), 2));
                    }
                }
                BaseLocationInfo b = baseLocationInfoMapper.selectBaseLocationInfoByLocationNo(baseLocationInfo.getLocationNo(), Constant.WAREHOUSE_ID);
                if (b == null) {
                    //BeanValidators.validateWithException(validator, stu);
                    baseLocationInfo.setCreateBy(opname);
                    baseLocationInfo.setCreateTime(new Date());
                    baseLocationInfo.setStockStatus("00");
                    baseLocationInfo.setIsEmpty("Y");
                    baseLocationInfo.setWarehouseId(Constant.WAREHOUSE_ID);
                    baseLocationInfo.setColNo(baseLocationInfo.getColNo());
                    this.insertBaseLocationInfo(baseLocationInfo);
                    successNum++;
                    successMsg.append("<br/>" + successNum + "、库位 " + baseLocationInfo.getLocationNo() + " 导入成功");
                } else if (updateSupport) {
                    //BeanValidators.validateWithException(validator, stu);
                    b.setUpdateBy(opname);
                    b.setUpdateTime(new Date());
                    this.updateBaseLocationInfo(b);
                    successNum++;
                    successMsg.append("<br/>" + successNum + "、库位 " + b.getLocationNo() + " 更新成功");
                } else {
                    failureNum++;
                    failureMsg.append("<br/>" + failureNum + "、库位 " + b.getLocationNo() + " 已存在");
                }
            } catch (Exception e) {
                failureNum++;
                String msg = "<br/>" + failureNum + "、库位 " + baseLocationInfo.getLocationNo() + " 导入失败：";
                failureMsg.append(msg + e.getMessage());
                log.error(msg, e);
            }
        }
        if (failureNum > 0) {
            failureMsg.insert(0, "导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
            throw new ServiceException(failureMsg.toString());
        } else {
            successMsg.insert(0, "数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        }
        return AjaxResult.success(successMsg);
    }

    @Override
    public Boolean reSetLocationInfo(BaseLocationInfo baseLocationInfo) {

        LambdaUpdateWrapper<BaseLocationInfo> updateWrapper = Wrappers.<BaseLocationInfo>lambdaUpdate()
                .set(StringUtils.isNotEmpty(baseLocationInfo.getIsEmpty()), BaseLocationInfo::getIsEmpty, baseLocationInfo.getIsEmpty())
                .set(StringUtils.isNotEmpty(baseLocationInfo.getStockStatus()), BaseLocationInfo::getStockStatus, baseLocationInfo.getStockStatus())
                .set(BaseLocationInfo::getBindSku, baseLocationInfo.getBindSku()).set(BaseLocationInfo::getUserdefine10, baseLocationInfo.getUserdefine10())
                .eq(BaseLocationInfo::getId, baseLocationInfo.getId());
        return baseLocationInfoMapper.update(null, updateWrapper) == 1;
    }


    @Override
    public List<BaseLocationInfo> getBaseLocationInfoList(Long zoneId, List<Long> configLocationIdList) {
        List<BaseLocationInfo> baseLocationInfoList = getBaseLocationInfoList(zoneId);
        return baseLocationInfoList.stream().filter(item -> CollectionUtil.contains(configLocationIdList, item.getId())).collect(Collectors.toList());
    }

    @Override
    public List<BaseLocationInfo> getBaseLocationInfoList(Long zoneId) {
        return baseLocationInfoMapper.selectList(Wrappers.<BaseLocationInfo>lambdaQuery().eq(BaseLocationInfo::getZoneId, zoneId)
                .eq(BaseLocationInfo::getWarehouseId, Constant.DEFAULT_WAREHOUSE_ID));
    }


    @Override
    public List<BaseLocationInfo> selectLocationInfoList(Long zoneId, String bindSku, Boolean isEmpty, String stockStatus) {
        return baseLocationInfoMapper.selectList(Wrappers.<BaseLocationInfo>lambdaQuery()
                .eq(BaseLocationInfo::getZoneId, zoneId)
                .eq(BaseLocationInfo::getBindSku, bindSku)
                .eq(BaseLocationInfo::getIsEmpty, isEmpty? Constants.YES : Constants.NO)
                .eq(BaseLocationInfo::getStockStatus, stockStatus));
    }
}