package com.huaheng.api.general.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.general.domain.ContainerTypeDomain;
import com.huaheng.api.general.domain.Freeze;
import com.huaheng.api.general.domain.InventoryDomain;
import com.huaheng.api.general.domain.InventoryQueryDomain;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.company.service.CompanyService;
import com.huaheng.pc.config.containerCapacity.domain.ContainerCapacity;
import com.huaheng.pc.config.containerCapacity.service.ContainerCapacityService;
import com.huaheng.pc.config.containerType.domain.ContainerType;
import com.huaheng.pc.config.containerType.service.ContainerTypeService;
import com.huaheng.pc.config.customer.domain.Customer;
import com.huaheng.pc.config.customer.service.CustomerServiceImpl;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.supplier.domain.Supplier;
import com.huaheng.pc.config.supplier.service.SupplierService;
import com.huaheng.pc.config.warehouse.domain.Warehouse;
import com.huaheng.pc.config.warehouse.service.WarehouseService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService;
import com.huaheng.pc.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.ShipmentContainerDetailService;
import com.huaheng.pc.system.dept.domain.Dept;
import com.huaheng.pc.system.dept.service.IDeptService;
import com.huaheng.pc.system.dict.domain.DictData;
import com.huaheng.pc.system.dict.domain.DictType;
import com.huaheng.pc.system.dict.mapper.DictDataMapper;
import com.huaheng.pc.system.dict.mapper.DictTypeMapper;
import com.huaheng.pc.system.dict.service.IDictDataService;
import com.huaheng.pc.system.dict.service.IDictTypeService;
import com.huaheng.pc.system.user.domain.User;
import com.huaheng.pc.system.user.service.IUserService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component
@Transactional
public class BasicDataApiService {
    @Autowired
    ReceiptContainerDetailService receiptContainerDetailService;
    @Autowired
    TaskDetailService taskDetailService;
    @Autowired
    ShipmentContainerDetailService shipmentContainerDetailService;
    @Autowired
    IDictTypeService dictTypeService;
    @Autowired
    IDictDataService dictDataService;
    @Autowired
    MaterialService materialService;
    @Autowired
    ContainerTypeService containerTypeService;
    @Autowired
    InventoryDetailService inventoryDetailService;
    @Autowired
    InventoryHeaderService inventoryHeaderService;
    @Resource
    private DictTypeMapper dictTypeMapper;
    @Resource
    private DictDataMapper dictDataMapper;

    @Autowired
    IUserService iUserService;

    @Autowired
    IDeptService iDeptService;

    @Autowired
    CustomerServiceImpl iCustomerService;

    @Autowired
    WarehouseService iWarehouseService;

    @Autowired
    SupplierService iSupplierService;

    @Autowired
    CompanyService companyService;

    @Autowired
    private ContainerCapacityService containerCapacityService;

    private static final Logger logger = LoggerFactory.getLogger("base-api");


    //检查仓库
    public Warehouse checkWarehouse(String code) {
        LambdaQueryWrapper<Warehouse> warehouseLam = Wrappers.lambdaQuery();
        warehouseLam.eq(Warehouse::getCode, code);
        Warehouse warehouse = iWarehouseService.getOne(warehouseLam);
        if (warehouse == null) {
            throw new ServiceException("数据出现问题，系统没有该仓库");
        }
        return warehouse;
    }

    /**
     * 字典通用接口
     * 1、判断必填字段是否为空
     * 2、仓库是否正确
     * 3、检查字典头表，如果没有就添加
     * 4、增新一条字典明细表的记录
     *
     * @param dictData
     * @return
     */
    public AjaxResult dict(DictData dictData) {
        //1、判断必填字段是否为空
        if (StringUtils.isEmpty(dictData.getWarehouseCode())) {
            return AjaxResult.error("没有仓库编码");
        }
        if (StringUtils.isEmpty(dictData.getDictLabel())) {
            return AjaxResult.error("没有字典标签");
        }
        if (StringUtils.isEmpty(dictData.getDictType())) {
            return AjaxResult.error("没有字典类型");
        }
        if (StringUtils.isEmpty(dictData.getDictValue())) {
            return AjaxResult.error("没有字典键值");
        }

        //2、仓库是否正确
        int result = 0;
        this.checkWarehouse(dictData.getWarehouseCode());

        //3、检查字典头表，如果没有就添加
        DictData condition = new DictData();
        try {
            condition.setDictType(dictData.getDictType());
            condition.setWarehouseCode(dictData.getWarehouseCode());
            condition.setDictValue(dictData.getDictValue());
            condition.setEnable(true);
            List<DictData> dictDatas = dictDataService.selectDictDataList(dictData);
            if (dictDatas.size() < 1) {
                //找出字典头表的id
                DictType dictType = new DictType();
                dictType.setWarehouseCode(dictData.getWarehouseCode());
                dictType.setDictType(dictData.getDictType());
                List<DictType> dictList = dictTypeService.selectDictTypeList(dictType);
                if (dictList.size() < 1) {
                    dictType.setWarehouseId(dictData.getWarehouseId());
                    dictType.setCreateBy(dictData.getCreateBy());
                    dictType.setCreateTime(dictData.getCreateTime());
                    if (StringUtils.isEmpty(dictType.getCreateBy())) {
                        result = dictTypeService.insertDictType(dictType);
                    } else {
                        result = dictTypeMapper.insertDictType(dictType);
                    }
                    dictList.add(dictType);
                    if (result < 1) {
                        throw new ServiceException("新增字典类型失败！");
                    }
                }
                //4、增新一条字典明细表的记录
                dictData.setHeaderId(dictList.get(0).getId());
                if (StringUtils.isEmpty(dictData.getCreateBy())) {
                    result = dictDataService.insertDictData(dictData);
                } else {
                    result = dictDataMapper.insertDictData(dictData);
                }
                if (result < 1) {
                    throw new ServiceException("新增字典数据失败！");
                }
            }
        } catch (Exception e) {
            throw new ServiceException("字典数据有误!!");
        }
        return AjaxResult.success("新增字典成功");
    }

    /**
     * 检查是否存在物料，如果存在就修改，不存在就新增
     * 1、判断必填字段是否为空
     * 2、检查仓库和货主
     * 3、查看此物料在系统是否存在
     *
     * @param material
     * @return
     */
    @Transactional
    public AjaxResult material(Material newMaterial) {
        if (StringUtils.isEmpty(newMaterial.getCode())) {
            return AjaxResult.error("物料编码不能为空!!");
        }
        if (StringUtils.isEmpty(newMaterial.getMaterialId())) {
            return AjaxResult.error("物料id为空");
        }
        //if(StringUtils.isEmpty(material.getType())){
        //    return AjaxResult.error("物料类型不能为空!!");
        //}
        if (StringUtils.isEmpty(newMaterial.getName())) {
            return AjaxResult.error("物料名称不能为空!!");
        }
        //if (StringUtils.isEmpty(material.getSpec())) {
        //    return AjaxResult.error("物料规格不能为空!!");
        //}
        //if (StringUtils.isEmpty(material.getUnit())) {
        //    return AjaxResult.error("物料单位不能为空!!");
        //}

        newMaterial.setERPID(Integer.valueOf(newMaterial.getMaterialId()));
        newMaterial.setCompanyCode("BHF");
        newMaterial.setWarehouseCode("CS0001");
        try {
            Material code2 = materialService.getOne(new LambdaQueryWrapper<Material>().eq(Material::getCode, newMaterial.getCode()).eq(Material::getERPID, newMaterial.getERPID()));
            if (code2 == null) {
                Material code = materialService.getOne(new LambdaQueryWrapper<Material>().eq(Material::getCode, newMaterial.getCode()));
                if (code != null) {
                    throw new ServiceException("wms系统有物料编码重复了，不能添加新的物料:" + newMaterial.getCode());
                }
            }


            //查看此物料在系统是否存在,通过ID
            Material entity = materialService.getOne(new LambdaQueryWrapper<Material>().eq(Material::getERPID, newMaterial.getERPID()));
            //不存在就新增
            if (entity == null) {
                if (!materialService.save(newMaterial)) {
                    throw new ServiceException("新增物料失败！");
                }
            } else {//修改
                newMaterial.setId(entity.getId());
                if (materialService.updateById(newMaterial)) {
                    //同步修改库存的物料信息，如果库存锁定了就修改物料失败
                    AjaxResult ajaxResult = updateInventory(entity, newMaterial);
                    if (ajaxResult.getCode() != 200) {
                        throw new ServiceException("更新库存失败！" + ajaxResult.getMsg());
                    }
                    return AjaxResult.success("更新物料和库存成功");
                } else {
                    throw new ServiceException("更新物料失败！");
                }
            }
        } catch (Exception e) {
            throw new ServiceException("物料数据问题:" + e);
        }
        return AjaxResult.success("新增物料成功");
    }

    private AjaxResult updateInventory(Material material, Material newMaterial) {
        String materialCode = material.getCode();

        List<InventoryDetail> list = inventoryDetailService.list(new LambdaQueryWrapper<InventoryDetail>().eq(InventoryDetail::getMaterialCode, materialCode));
        if (list.isEmpty()) {
            return AjaxResult.success("该物料没有库存，无需修改物料信息");
        }
        for (InventoryDetail inventoryDetail : list) {
            if (inventoryDetail.getTaskQty().compareTo(BigDecimal.ZERO) > 0) {
                throw new ServiceException("该库存的物料有任务了，无法修改物料信息：" + materialCode);
            }
        }
        List<TaskDetail> taskDetailList = taskDetailService.list(new LambdaQueryWrapper<TaskDetail>().eq(TaskDetail::getMaterialCode, materialCode).ne(TaskDetail::getStatus, 100));
        if (!taskDetailList.isEmpty()) {
            throw new ServiceException("该物料，无法修改物料信息,有未完成的任务:" + materialCode);
        }

        List<ReceiptContainerDetail> receiptContainerDetails = receiptContainerDetailService.list(new LambdaQueryWrapper<ReceiptContainerDetail>().eq(ReceiptContainerDetail::getMaterialCode, materialCode).ne(ReceiptContainerDetail::getStatus, 20));
        if (!receiptContainerDetails.isEmpty()) {
            throw new ServiceException("该物料，无法修改物料信息,有未完成入库组盘:" + materialCode);
        }

        List<ShipmentContainerDetail> shipmentContainerDetails = shipmentContainerDetailService.list(new LambdaQueryWrapper<ShipmentContainerDetail>().eq(ShipmentContainerDetail::getMaterialCode, materialCode).ne(ShipmentContainerDetail::getStatus, 20));
        if (!shipmentContainerDetails.isEmpty()) {
            throw new ServiceException("该物料，无法修改物料信息,有未完成出库组盘:" + materialCode);
        }


        //修改库存
        for (InventoryDetail inventoryDetail : list) {
            inventoryDetail.setMaterialCode(newMaterial.getCode());
            inventoryDetail.setMaterialName(newMaterial.getName());
            inventoryDetail.setMaterialSpec(newMaterial.getSpec());
            inventoryDetail.setMaterialUnit(newMaterial.getUnit());
        }
        if (!inventoryDetailService.updateBatchById(list)) {
            throw new ServiceException("修改库存失败！");

        }

        return AjaxResult.success("");
    }


    /**
     * 1,物料同步
     * 2,条件查询
     *
     * @param material
     * @return
     */
    @Transactional
    public AjaxResult queryMaterial(Material material) {
        if (StringUtils.isEmpty(material.getWarehouseCode())) {
            return AjaxResult.error("仓库编码不能为空!!");
        }
        if (StringUtils.isEmpty(material.getCompanyCode())) {
            return AjaxResult.error("货主编码不能为空!!");
        }
        LambdaQueryWrapper<Material> lambdaQueryWrapper = Wrappers.lambdaQuery(material);
        materialService.list(lambdaQueryWrapper);
        return AjaxResult.success(materialService.list(lambdaQueryWrapper));
    }


    /**
     * 人员档案通用接口
     * 1、判断必填字段是否为空
     * 2、判断系统中是否有该用户，如果有则更新，如果没有则新增
     * 新增： （1）、默认密码为123456
     * （2）默认为普通用户
     * （3）默认为长沙仓库
     *
     * @param user
     * @return
     */
    public AjaxResult user(User user) {
        //1、判断必填字段是否为空
        int result = 0;
        User user1 = new User();
        if (user.getLoginName() == null || user.getLoginName() == "") {
            return AjaxResult.error("没有人员编码!!");
        }
        if (user.getUserName() == null || user.getUserName() == "") {
            return AjaxResult.error("没有人员名称!!");
        }
        if (user.getDeptId() == null) {
            return AjaxResult.error("没有部门ID!!");
        }
        if (iDeptService.selectDeptById(user.getDeptId()) == null) {
            return AjaxResult.error("系统没有此部门!!");
        }
        try {
            user1.setLoginName(user.getLoginName());
            //2、判断系统中是否有该用户，如果有则更新，如果没有则新增
            if (iUserService.selectmen(user.getLoginName()) == null) {
                //（1）默认密码为123456
                if (user.getPassword() == null) {
                    user.setPassword("123456");
                }
                //（2）默认为普通用户
                if (StringUtils.isEmpty(user.getRoleIds())) {
                    List<Integer> roleIds = new ArrayList<>();
                    roleIds.add(2);
                    user.setRoleIds(roleIds);
                }
                //（3）默认为长沙仓库
                if (StringUtils.isEmpty(user.getCompanyIdList())) {
                    List<Integer> companyIdList = new ArrayList<>();
                    companyIdList.add(2);
                    user.setCompanyIdList(companyIdList);
                }
                result = iUserService.insertUser(user);
                if (result < 1) {
                    throw new ServiceException("新增人员档案失败！");
                } else {
                    return AjaxResult.success("新增人员档案成功！");
                }
            } else {
                return AjaxResult.error("已有该人员档案，无法进行修改!");
//                result = iUserService.updateUser(user);
//                if (result < 1) {
//                    throw new ServiceException("更新人员档案失败！");
//                } else {
//                    return AjaxResult.success("更新人员档案成功！");
//                }
            }
        } catch (Exception e) {
            throw new ServiceException("数据问题。。。");
        }
    }


    /**
     * 1,用户同步
     * 2,条件查询
     *
     * @param user
     * @return
     */
    @Transactional
    public AjaxResult queryUser(User user) {
        iUserService.selectUserList(user);
        return AjaxResult.success(iUserService.selectUserList(user));
    }


    /**
     * 部门档案通用接口
     * 1、判断必填字段是否为空
     * 2、部门编码长度应是双数
     *
     * @param dept
     * @return
     */
    @Transactional
    public AjaxResult dept(Dept dept) {

        //1、判断必填字段是否为空
        int result = 0;
        String code = dept.getCode();
        if (code == null || code == "") {
            return AjaxResult.error("部门编码不能为空!!");
        }
        try {
            Dept rs = iDeptService.selectDepts(code);

            //2、部门编码长度应是双数
            if (rs == null) {
                int x = code.length() % 2;
                if (x != 0) {
                    return AjaxResult.error("部门编码长度应是双数");
                } else {
                    int y = code.length() / 2;
                    if (y >= 1) {
                        String scode = code.substring(0, 2);
                        if (iDeptService.selectDepts(scode) == null) {
                            dept.setCode(scode);
                            dept.setParentId(100);
                            dept.setAncestors("0,100");
                            dept.setOrderNum("1");
                            result = iDeptService.insertDept(dept);
                            if (result < 1) {
                                throw new ServiceException("新增部门档案失败！");
                            }
                        }
                    }
                    for (int z = 1; z <= y; z++) {

                        //找到上级部门
                        String sqcode = code.substring(0, 2 * (z - 1));
                        Dept sdept = iDeptService.selectDepts(sqcode);
                        String sscode = code.substring(0, 2 * z);
                        if (iDeptService.selectDepts(sscode) == null) {
                            dept.setCode(sscode);
                            dept.setParentId(sdept.getId());
                            dept.setAncestors(sdept.getAncestors() + "," + sdept.getId());
                            dept.setOrderNum(String.valueOf(z));
                            result = iDeptService.insertDept(dept);
                            if (result < 1) {
                                throw new ServiceException("新增部门档案失败！");
                            }
                        }
                    }
                }
                return AjaxResult.success("新增部门成功");
            } else {
                dept.setId(rs.getId());
                int num = iDeptService.updatesDept(dept);
                if (num < 1) {
                    throw new ServiceException("部门修改失败");
                } else {
                    return AjaxResult.success("部门修改成功");
                }
            }
        } catch (Exception e) {
            throw new ServiceException("数据问题。。。");
        }
    }

    /**
     * 客户档案通用接口
     * 1、判断必填字段是否为空
     * 2、检查仓库
     * 3、查看此客户在系统是否存在
     *
     * @param customer
     * @return
     */
    public AjaxResult customer(Customer customer) {
        Boolean flag = true;
        //1、判断必填字段是否为空
        if (customer.getCode() == null || customer.getCode() == "") {
            return AjaxResult.error("客户代码不能为空!!");
        }
        if (StringUtils.isEmpty(customer.getWarehouseCode())) {
            return AjaxResult.error("没有仓库编码");
        }
        if (StringUtils.isEmpty(customer.getName())) {
            return AjaxResult.error("没有客户名称");
        }
        if (StringUtils.isEmpty(customer.getCompanyCode())) {
            return AjaxResult.error("没有货主编码");
        }
        try {
            //2、检查仓库
            this.checkWarehouse(customer.getWarehouseCode());

            //3、查看此客户在系统是否存在
            LambdaQueryWrapper<Customer> customerLam = Wrappers.lambdaQuery();
            customerLam.eq(Customer::getCode, customer.getCode())
                    .eq(Customer::getWarehouseCode, customer.getWarehouseCode());
            Customer ctr = iCustomerService.getOne(customerLam);

            //不存在添加
            if (ctr == null) {
                flag = iCustomerService.save(customer);
                if (flag == false) {
                    throw new ServiceException("新增客户档案失败！");
                } else {
                    return AjaxResult.success("新增客户档案成功！");
                }
            } else {
                return AjaxResult.error("已有该客户，无法进行修改!!");
//                customer.setId(rs.getId());
//                result = iCustomerService.updateByModel(customer);
//                if (result < 1) {
//                    throw new ServiceException("更新客户档案失败！");
//                } else {
//                    return AjaxResult.success("更新客户档案成功！");
//                }
            }
        } catch (Exception e) {
            throw new ServiceException("数据问题。。。");
        }
    }

    /**
     * 仓库档案通用接口
     * 1、判断必填字段是否为空
     * 2、判断系统中是否有该仓库，若有则更新，若无则新增
     *
     * @param warehouse
     * @return
     */
    public AjaxResult warehouse(Warehouse warehouse) {
        if (warehouse.getCode() == null || warehouse.getCode() == "") {
            return AjaxResult.error("仓库编码不能为空!!");
        }
        if (warehouse.getName() == null || warehouse.getName() == "") {
            return AjaxResult.error("仓库名称不能为空!!");
        }
        try {
            LambdaQueryWrapper<Warehouse> warehouseLam = Wrappers.lambdaQuery();
            warehouseLam.eq(Warehouse::getCode, warehouse.getCode());
            Warehouse whs = iWarehouseService.getOne(warehouseLam);

            //2、判断系统中是否有该仓库，若有则更新，若无则新增
            if (whs == null) {
                Boolean flag = iWarehouseService.save(warehouse);
                if (flag == false) {
                    throw new ServiceException("新增仓库档案失败！");
                } else {
                    return AjaxResult.success("新增仓库档案成功！");
                }
            } else {
                return AjaxResult.error("已有该仓库，无法进行修改!");
//                warehouse.setId(rs.getId());
//                result = iWarehouseService.updateByModel(warehouse);
//                if (result < 1) {
//                    throw new ServiceException("更新仓库档案失败！");
//                } else {
//                    return AjaxResult.success("更新仓库档案成功！");
//                }
            }
        } catch (Exception e) {
            throw new ServiceException("仓库数据问题。。。");
        }
    }

    /**
     * 供应商档案通用接口
     * 1、判断必填字段是否为空
     * 2、检查仓库
     * 3、查看此供应商在系统是否存在
     *
     * @param supplier
     * @return
     */
    public AjaxResult supplier(Supplier supplier) {

        //1、判断必填字段是否为空
        if (StringUtils.isEmpty(supplier.getCode())) {
            return AjaxResult.error("没有供应商代码");
        }
        if (StringUtils.isEmpty(supplier.getName())) {
            return AjaxResult.error("没有供应商名称");
        }
        if (StringUtils.isEmpty(supplier.getWarehouseCode())) {
            return AjaxResult.error("没有仓库编码");
        }

        //2、检查仓库
        this.checkWarehouse(supplier.getCode());

        //3、查看此供应商在系统是否存在
        try {
            LambdaQueryWrapper<Supplier> supplierLam = Wrappers.lambdaQuery();
            supplierLam.eq(Supplier::getCode, supplier.getCode())
                    .eq(Supplier::getWarehouseCode, supplier.getWarehouseCode());
            Supplier spl = iSupplierService.getOne(supplierLam);

            if (spl == null) {
                Boolean flag = iSupplierService.save(supplier);
                if (flag == false) {
                    throw new ServiceException("新增供应商失败!");
                } else {
                    return AjaxResult.success("新增供应商成功!");
                }
            } else {
                return AjaxResult.error("已有该供应商，无法修改!!");
            }
        } catch (Exception e) {
            throw new ServiceException("供应商数据问题。。。");
        }
    }


    /**
     * 容器容量通用接口
     * 1、判断必填字段是否为空
     * 2、检查仓库、物料和容器类型
     * 3、检查此容器容量是否存在，不存在则添加
     *
     * @param containerCapacity
     * @return
     */
    public AjaxResult containerCapacity(ContainerCapacity containerCapacity) {
        Boolean flag = false;
        //1、判断必填字段是否为空
        if (StringUtils.isEmpty(containerCapacity.getContainerType())) {
            return AjaxResult.error("没有容器类型");
        }
        if (StringUtils.isEmpty(containerCapacity.getWarehouseCode())) {
            return AjaxResult.error("没有仓库编号");
        }
        if (StringUtils.isEmpty(containerCapacity.getMaterialCode())) {
            return AjaxResult.error("没有物料编号");
        }
        if (StringUtils.isNull(containerCapacity.getQty())) {
            return AjaxResult.error("没有容量上限");
        }

        // 2、检查仓库、物料和容器类型
        this.checkWarehouse(containerCapacity.getWarehouseCode());

        //物料检查
        LambdaQueryWrapper<Material> materialLam = Wrappers.lambdaQuery();
        materialLam.eq(Material::getCode, containerCapacity.getMaterialCode())
                .eq(Material::getWarehouseCode, containerCapacity.getWarehouseCode());
        Material material = materialService.getOne(materialLam);
        if (material == null) {
            return AjaxResult.error("系统没有此物料编号");
        }

        //容器类型检查
        LambdaQueryWrapper<ContainerType> containerTypeLamb = Wrappers.lambdaQuery();
        containerTypeLamb.eq(ContainerType::getCode, containerCapacity.getContainerType())
                .eq(ContainerType::getWarehouseCode, containerCapacity.getWarehouseCode());
        ContainerType containerType = containerTypeService.getOne(containerTypeLamb);
        if (containerType == null) {
            return AjaxResult.error("系统没有此容器类型");
        }

        //3、检查此容器容量是否存在，不存在则添加
        LambdaQueryWrapper<ContainerCapacity> containerCapacityLambd = Wrappers.lambdaQuery();
        containerCapacityLambd.eq(ContainerCapacity::getContainerType, containerCapacity.getContainerType())
                .eq(ContainerCapacity::getWarehouseCode, containerCapacity.getWarehouseCode())
                .eq(ContainerCapacity::getMaterialCode, containerCapacity.getMaterialCode());
        ContainerCapacity capacity = containerCapacityService.getOne(containerCapacityLambd);
        if (capacity == null) {
            flag = containerCapacityService.save(containerCapacity);
            if (flag == false) {
                return AjaxResult.error("新增容器容量失败");
            }
        } else {
            if (capacity.getQty().compareTo(containerCapacity.getQty()) != 0) {
                capacity.setQty(containerCapacity.getQty());
                flag = containerCapacityService.updateById(capacity);
                if (flag == false) {
                    return AjaxResult.error("修改容器容量失败");
                }
            }
        }
        return AjaxResult.success("新增容器容量成功");
    }

    public AjaxResult containerType(ContainerTypeDomain containerTypeDomain) {
        if ("0".equals(containerTypeDomain.getCode())) {
            if (!containerTypeService.saveBatch(containerTypeDomain.getContainerTypeList())) {
                logger.error("erp初始化容器类型失败，失败原因：无法插入数据");
                return AjaxResult.error("初始化容器类型失败");
            }
            return AjaxResult.success("容器类型初始化成功");
        } else {
            LambdaQueryWrapper<ContainerType> lambdaQuery;
            for (ContainerType containerType : containerTypeDomain.getContainerTypeList()) {
                lambdaQuery = Wrappers.lambdaQuery();
                lambdaQuery.eq(ContainerType::getCode, containerType.getCode());
                ContainerType srcContainerType = containerTypeService.getOne(lambdaQuery);
                if (srcContainerType == null) {
                    if (!containerTypeService.save(containerType)) {
                        logger.error("erp更新容器类型失败，失败原因：无法插入数据");
                        return AjaxResult.error("插入容器类型失败");
                    }
                } else {
                    containerType.setId(srcContainerType.getId());
                    if (!containerTypeService.updateById(containerType)) {
                        logger.error("erp更新容器类型失败，失败原因：无法更新数据");
                        return AjaxResult.error("更新容器类型失败");
                    }
                }
            }
            return AjaxResult.success("容器类型更新成功");
        }
    }


    /**
     * 1,库存同步
     * 2,条件查询
     *
     * @param inventoryDetail
     * @return
     */
    @Transactional
    public AjaxResult queryInventoryApi(InventoryDetail inventoryDetail) {
        if (StringUtils.isEmpty(inventoryDetail.getWarehouseCode())) {
            return AjaxResult.error("仓库编码不能为空!!");
        }
        if (StringUtils.isEmpty(inventoryDetail.getCompanyCode())) {
            return AjaxResult.error("货主编码不能为空!!");
        }
        //查询库存明细
        LambdaQueryWrapper<InventoryDetail> lambdaQueryWrapper = Wrappers.lambdaQuery(inventoryDetail);
        List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(lambdaQueryWrapper);

        //查询库存Header表
        Map<Integer, InventoryHeader> inventoryHeaderList = new HashMap<>();//map防止出现数据重复
        for (InventoryDetail inventoryDetail1 : inventoryDetailList) {
            LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getId, inventoryDetail1.getInventoryHeaderId());
            inventoryHeaderList.put(inventoryDetail1.getInventoryHeaderId(), inventoryHeaderService.getOne(inventoryHeaderLambdaQueryWrapper));
        }

        InventoryDomain inventoryDomain = new InventoryDomain();
        inventoryDomain.setInventoryHeader(inventoryHeaderList);
        inventoryDomain.setInventoryDetails(inventoryDetailList);
        return AjaxResult.success(inventoryDomain);
    }


    public AjaxResult queryInventory(InventoryQueryDomain queryDomain) {
        if (StringUtils.isEmpty(queryDomain.getWarehouseCode())) {
            return AjaxResult.error("仓库编码不能为空");
        }
        if (StringUtils.isEmpty(queryDomain.getCompanyCode())) {
            return AjaxResult.error("货主编码不能为空");
        }
        if (StringUtils.isEmpty(queryDomain.getContainerCode()) && StringUtils.isEmpty(queryDomain.getLocationCode()) && StringUtils.isEmpty(queryDomain.getMaterialCode())) {
            return AjaxResult.error("容器、库位与物料至少一样不为空");
        }
        LambdaQueryWrapper<InventoryDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(InventoryDetail::getWarehouseCode, queryDomain.getWarehouseCode())
                .eq(InventoryDetail::getCompanyCode, queryDomain.getCompanyCode());
        ArrayList<InventoryDetail> inventoryDetails = new ArrayList<>();
        if (StringUtils.isNotEmpty(queryDomain.getContainerCode())) {
            queryWrapper.eq(InventoryDetail::getContainerCode, queryDomain.getContainerCode());
        }
        if (StringUtils.isNotEmpty(queryDomain.getLocationCode())) {
            queryWrapper.eq(InventoryDetail::getLocationCode, queryDomain.getLocationCode());
        }
        if (StringUtils.isNotEmpty(queryDomain.getMaterialCode())) {
            queryWrapper.eq(InventoryDetail::getMaterialCode, queryDomain.getMaterialCode());
        }
        List<InventoryDetail> list = inventoryDetailService.list(queryWrapper);
        if (list == null) {
            return AjaxResult.error("没有符合条件的库存");
        }
        return AjaxResult.success("获取成功", list);
    }


    public AjaxResult freeze(Freeze freeze) {
        List<InventoryDetail> list = inventoryDetailService.list(new LambdaQueryWrapper<InventoryDetail>().eq(InventoryDetail::getLabelCode, freeze.getLabelCode()));
        if (list.size() != 1) {
            return AjaxResult.error("这个标签号查询出的库存大于1," + freeze.getLabelCode());
        }
        InventoryDetail inventoryDetail = list.get(0);
        inventoryDetail.setFreezeStatus(freeze.getStatus());
        inventoryDetailService.updateById(inventoryDetail);
        if (freeze.getStatus() == 1) {
            return AjaxResult.success("冻结成功");
        }
        return AjaxResult.success("解冻成功");
    }
}