package com.huaheng.pc.config.location.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.location.domain.LocationInfo;
import com.huaheng.pc.config.locationType.domain.LocationType;
import com.huaheng.pc.config.locationType.service.LocationTypeService;
import com.huaheng.pc.config.zone.domain.Zone;
import com.huaheng.pc.config.zone.service.ZoneService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.location.mapper.LocationMapper;

@Service("LocationService")
public class LocationServiceImpl extends ServiceImpl<LocationMapper, Location> implements LocationService{

    @Resource
    private LocationService locationService;
    @Resource
    private LocationTypeService locationTypeService;
    @Resource
    private ZoneService zoneService;
    @Resource
    private LocationMapper locationMapper;

    /**
     * //新增库位，需要建立code，并判断是否重复
     * 1. 库区和库位没有绝对关系。 先建立库区，然后在库区的位置进行建立库位类型。
     * TODO：胡海--在判断库位类型和库区是否匹配，应该用库位类型表进行判断。库位类型在库区存在即可
     * @param location
     * @return
     */
    @Override
    public AjaxResult addsave(Location location){

        //库区与库位类型的匹配判断
        if(!location.getZoneCode().equals(location.getLocationType())){
            throw new ServiceException(location.getLocationType()+"的库位类型与"+location.getZoneCode()+"库区不匹配");
        }
       //TODO:胡海-- 库位编码长度应该是弹性的，即我们的库位是由4个维度组成的，正常情况下  平库（行列） 立体仓库（行列层） AGV料架库（行列层格）
        // 这里可以判断下 然后决定库位编码长度。
        //创建库位编码code
        String prefix = location.getLocationType().substring(1);
        String code = MessageFormat.format("{0}{1}-{2}-{3}-{4}",
                prefix,
                String.format("%02d", location.getIRow()),
                String.format("%02d", location.getIColumn()),
                String.format("%02d", location.getILayer()),
                String.format("%02d", location.getIGrid()));

        //判断code是否重复
        LambdaQueryWrapper<Location> lam = Wrappers.lambdaQuery();
        lam.eq(Location::getWarehouseCode,ShiroUtils.getWarehouseCode())
                .eq(Location::getCode,code);
        if(this.getOne(lam)!=null){
            return AjaxResult.error("该位置已有库位生成，请重新输入位置");
        }

        //插入数据库
        location.setCode(code);
        location.setWarehouseCode(ShiroUtils.getWarehouseCode());
        location.setCreatedBy(ShiroUtils.getLoginName());
        Boolean flag=this.save(location);
        if(flag == false){
            return AjaxResult.error("新增库位失败，插入数据库时失败");
        }
        return AjaxResult.success("新增库位成功");
    }

    /**
     * 批量新增库位
     * @param location
     * @return boolean
     */
    @Override
    public boolean insertLocation(Location location) {
        /* 判断库位类型编码是否存在*/
        LambdaQueryWrapper<LocationType> typeLambda = Wrappers.lambdaQuery();
        typeLambda.eq(LocationType::getCode,location.getLocationType())
                        .select(LocationType::getCode);
        List<Map<String, Object>> list = locationTypeService.listMaps(typeLambda);
        if (list.size() < 1){
            throw new ServiceException("库位类型编码不存在");
        }

        /* 判断库区编码是否存在*/
        LambdaQueryWrapper<Zone> zoneLambda= Wrappers.lambdaQuery();
        zoneLambda.eq(Zone::getCode, location.getZoneCode())
                .select(Zone::getCode);

        list = zoneService.listMaps(zoneLambda);
        if (list.size() < 1){
            throw new ServiceException("库区编码不存在");
        }
        //TODO：胡海--在判断库位类型和库区是否匹配，应该用库位类型表进行判断。库位类型在库区存在即可
        if(!location.getZoneCode().equals(location.getLocationType())){
            throw new ServiceException(location.getLocationType()+"的库位类型与"+location.getZoneCode()+"库区不匹配");
        }

        List<Location> locations = new ArrayList<>();
        for (int i=1; i<=location.getIRow().intValue(); i++)  {
            for (int j=1; j<=location.getIColumn().intValue(); j++)  {
                for (int k=1; k<=location.getILayer().intValue(); k++)  {
                    for (int m=1; m<=location.getIGrid().intValue(); m++)  {
                        //Integer roadway = (j / 2) + 1;
                        Location param = new Location();
                        param.setIRow(i);
                        param.setIColumn(j);
                        param.setILayer(k);
                        param.setIGrid(m);
                        param.setRoadway(location.getRoadway());
                        param.setZoneCode(location.getZoneCode());
                        param.setLocationType(location.getLocationType());
                        param.setStatus(location.getStatus());
                        param.setWarehouseCode(ShiroUtils.getWarehouseCode());
                        param.setCreatedBy(ShiroUtils.getLoginName());
                        param.setLastUpdatedBy(ShiroUtils.getLoginName());
                        String code = MessageFormat.format("{0}{1}_{2}_{3}",
                                location.getLocationType(),
                                String.format("%02d", i),
                                String.format("%02d", j),
                                String.format("%02d", k));
                        //查询该库位编码是否存在
                        LambdaQueryWrapper<Location> queryWrapper = Wrappers.lambdaQuery();
                        queryWrapper.eq(Location::getCode,code)
                                .eq(Location::getWarehouseCode,ShiroUtils.getWarehouseCode());
                        List<Location> locationList = locationService.list(queryWrapper);
                        if (locationList.size() == 0) {
                            param.setCode(code);
                            locations.add(param);
                        }
                    }
                }
            }
        }
        int num =0;
        List<Location> locations1 = new ArrayList<>();
        if(locations.size() >1000 ){
            for(Location item : locations){
                num++;
                locations1.add(item);
                if(num % 1000 ==0 || num == locations.size()){
                    locationMapper.addList(locations1);
                    locations1=new ArrayList<>();
                }
            }
        }else {
            locationMapper.addList(locations);
        }
        return true;
    }

    /**
     * 根据库位编码对库位表格的状态进行更新
     * @param locationCode
     * @param status
     */
    @Override
    public void updateStatus(String locationCode, String status) {
        if (StringUtils.isNotEmpty(locationCode)) {
            locationMapper.updateStatus(ShiroUtils.getWarehouseCode(), locationCode, status);
        }
    }

    /**
     * 通过定位规则查找库位
     * @param locatingRule
     * @return
     */
    @Override
    public String position(String locatingRule){
        return locationMapper.position(locatingRule).getCode();
    }

    /**
     * 修改容器和库位状态
     * */
    @Override
    public void updateContainerCodeAndStatus(String locationCode, String containerCode, String status) {
        if (StringUtils.isNotEmpty(locationCode) || StringUtils.isNotEmpty(containerCode)) {
            locationMapper.updateContainerCodeAndStatus(ShiroUtils.getWarehouseCode(), locationCode, containerCode, status);
        }
    }

    @Override
    public LocationInfo getAllLocation(String type) {
        if (StringUtils.isNotEmpty(type)) {
            Location location = locationMapper.getAllLocation(ShiroUtils.getWarehouseCode(), type);
            LocationInfo locationInfo = new LocationInfo();
            locationInfo.setMaxRow(location.getIRow());
            locationInfo.setMaxLine(location.getIColumn());
            locationInfo.setMaxLayer(location.getILayer());
            locationInfo.setMaxGrid(location.getIGrid());
            return locationInfo;
        }
        return null;
    }

    /**
     * 验证库位合法性
     *
     * @param code
     * @return
     */
    @Override
    public boolean checkLocation(String code) {
        LambdaQueryWrapper<Location> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Location::getWarehouseCode, ShiroUtils.getWarehouseCode())
                .eq(Location::getDeleted,false)
                .eq(Location::getCode, code);
        List<Location> locations = list(queryWrapper);
        if (locations.size() >= 1){
            Location location = locations.get(0);
            String containerCode =location.getContainerCode();
            if (containerCode != null && containerCode.length() > 0) {
                throw new ServiceException("货架上已有容器");
            }
            String status = location.getStatus();
            if(!"empty".equals(status)) {
                throw new ServiceException("库位状态不为空");
            }
            return true;
        } else {
            return false;
        }
    }

    @Override
    public boolean getFreeLocation(String materialCode, String batch) {
        LambdaQueryWrapper<Location> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(Location::getWarehouseCode, ShiroUtils.getWarehouseCode())
                .eq(Location::getContainerCode, "")
                .eq(Location::getDeleted, false)
                .eq(Location::getStatus, "empty");
        List<Location> locations = locationService.list(lambdaQueryWrapper);
        if(locations != null && locations.size() > 0) {
            return true;
        }
        return false;
    }

    /**
     * 查询库位利用率
     * @return
     */
    @Override
    public List<LinkedHashMap<String, Object>> getLocationProp() {
        return locationMapper.getLocationProp();
    }

    /**
     * 根据库位编码查询库位信息
     * @param code
     * @return
     */
    @Override
    public Location findLocationByCode(String code) {
        LambdaQueryWrapper<Location> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Location::getCode, code);
        return getOne(queryWrapper);
    }

    @Override
    public List<Location> pickLocation() {
        return locationMapper.pickLocation();
    }

    @Override
    public List<Location> selectContainerEmpty(String warehouseCode) {
        return locationMapper.selectContainerEmpty(warehouseCode);
    }


}