package com.tld.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.tld.mapper.AskGoodsMapper;
import com.tld.mapper.DeliveryMapper;
import com.tld.mapper.DictionaryMapper;
import com.tld.mapper.WarehousingMapper;
import com.tld.model.*;
import com.tld.service.DeliveryService;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class DeliveryServiceImpl implements DeliveryService {

    @Autowired
    private DeliveryMapper deliveryMapper;

    @Autowired
    private AskGoodsMapper askGoodsMapper;
    //redis锁
    @Autowired
    private RedissonClient redissonClient;
    //删除日志表
    @Autowired
    private DictionaryMapper dictionaryMapper;
    //入库
    @Autowired
    private WarehousingMapper warehousingMapper;

    @Override
    public Map<String, Object> getDelivery(Delivery delivery) {
        Map<String, Object> map = new HashMap<>();
        try{
            List<Delivery> list = deliveryMapper.getDelivery(delivery);
            Map<String, Object> mapVal = new HashMap<>();
            for(Delivery delivery1 : list){
                int sumScan = deliveryMapper.getScanSum(delivery1);
                mapVal.put(delivery1.getDeliveryId() + delivery1.getMaterialId() + delivery1.getEntryNumber(), sumScan);
            }
            map.put("data", list);
            map.put("scan", mapVal);
            map.put("msg", "200");
        }catch (Exception e) {
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
            e.printStackTrace();
        }
        return map;
    }

    @Override
    public Map<String, Object> getRecommend(Delivery delivery) {
        Map<String, Object> map = new HashMap<>();
        try{
            MaterialClass materialClass = deliveryMapper.getMaterialClass(delivery.getMaterialId());
            if(materialClass == null){
                map.put("msg", "500");
                map.put("errMsg", "物料信息未录入，请联系管理员");
                return map;
            }
            if(materialClass.getPartType().equals("产成品")){
                //查询所有产成品库位
                String storageLocationCode = deliveryMapper.getStorageLocationCodeList();
                List<Inventory> list = new LinkedList<>();
                for(Inventory inventory : deliveryMapper.getInventory(storageLocationCode, delivery)){
                    int occupy = deliveryMapper.getVitrual(inventory);
                    if(occupy == 0){
                        //--------------暂时使用 后期改回逻辑
//                        if(Double.doubleToLongBits(Double.parseDouble(inventory.getAmount())) == Double.doubleToLongBits(Double.parseDouble(delivery.getOutNum()))){
                        if(Double.doubleToLongBits(Double.parseDouble(inventory.getAmount())) >= Double.doubleToLongBits(Double.parseDouble(delivery.getOutNum()))){
                            for(Inventory inventorys : deliveryMapper.getInventory(storageLocationCode, delivery)){
                                if (inventorys.getStorageLocationCode().equals(inventory.getStorageLocationCode())){
                                    list.add(inventorys);
                                    map.put("data", list);
                                    map.put("msg", "200");

                                }
                            }
                            return map;
                        }
                    }
                }
                map.put("data", list);
            } else if(materialClass.getPartType().equals("半成品")){
                List<Inventory> list = new LinkedList<>();
                for(Inventory inventory : deliveryMapper.getInventory(delivery.getStorageLocationCode(), delivery)){
                    int productNum = deliveryMapper.getProductNumVitrual(inventory);
                    if(Integer.parseInt(inventory.getAmount()) < 0){
                        map.put("msg", "500");
                        map.put("errMsg", "库存不足");
                        return map;
                    } else {
                        list.add(inventory);
                        map.put("data", list);
                        map.put("msg", "200");
                        return map;
                    }
                }
            } else {
                List<Inventory> list = new LinkedList<>();
                AskGoods askGoods = new AskGoods()
                        .setCompanyNumber(delivery.getCompanyNumber())
                        .setMaterialId(delivery.getMaterialId())
                        .setWbs(delivery.getWbs());
                for(Inventory inventory : deliveryMapper.getMaterialCk(askGoods)){
                    AskGoods askGoods1 = askGoodsMapper.getAsk(inventory);
                    if(askGoods1 != null){
                        if( Double.doubleToLongBits(Double.parseDouble(askGoods1.getNum()))  != Double.doubleToLongBits(Double.parseDouble(inventory.getAmount())) ){
                            list.add(inventory);
                            map.put("data", list);
                            map.put("msg", "200");
                            return map;
                        }
                    } else {
                        list.add(inventory);
                        map.put("data", list);
                        map.put("msg", "200");
                        return map;
                    }
                }
            }
            map.put("msg", "200");
        }catch (Exception e){
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
            e.printStackTrace();
        }
        return map;
    }

    @Override
    public Map<String, Object> OutOfLibrary(String uniqueCode, String type, String deliveryId) {
        Map<String, Object> map = new HashMap<>();
        //redis并发锁
        RLock lock = redissonClient.getLock(uniqueCode);
        lock.lock();
        try{
            String removalCode = codeGenerateCk();
            List<AskGoods> listData = askGoodsMapper.getAskGoodsVitrual(uniqueCode, type);
            for(AskGoods askGoods : listData){
                if(!askGoods.getAskGoodsId().equals(deliveryId)){
                    continue;
                }
                askGoods.setStorageCode(removalCode);
                askGoods.setCompanyNumber(askGoods.getAccountSleeve());
                //判断物料是否录入
                MaterialClass materialClass = warehousingMapper.getMateriaIsExist(askGoods.getWllbCode());

                //临时使用后期删除
                //-------------------------------
                Inventory inventory = null;
                if(materialClass.getPartType().equals("产成品")){
                    inventory = deliveryMapper.getTemporarily(askGoods);
                } else {
                    inventory = deliveryMapper.getInventoryHalf(askGoods);
                }
                //------------------------------
//                Inventory inventory = deliveryMapper.getInventoryHalf(askGoods);
                //如果出库库存等于虚拟表库存则删除此库存
                if(Double.doubleToLongBits(Double.parseDouble(askGoods.getNum())) == Double.doubleToLongBits(Double.parseDouble(inventory.getAmount()))){
                    askGoodsMapper.deleteInventory(inventory);
                } else {
                    inventory.setAmount(askGoods.getNum());
                    askGoodsMapper.updateInventory(inventory);
                }
                //查询销售单部分信息
                Delivery delivery = new Delivery().setDeliveryId(deliveryId).setMaterialId(materialClass.getTldId())
                        .setEntryNumber(askGoods.getEntryNumber())
                        .setUserId(askGoods.getUserId());
                List<Delivery> list = deliveryMapper.getDelivery(delivery);
                deliveryMapper.updateDelivery(materialClass.getTldId(), askGoods.getNum(), deliveryId, askGoods.getEntryNumber()); //修改销售单出库数量
                if(materialClass.getPartType().equals("产成品")){
                    //产成品销售流水
                    Delivery delivery1 = new Delivery()
                            .setMaterialCode(askGoods.getWllbCode()) //物料code
                            .setOutNum(askGoods.getNum()) //出库数量
                            .setUserId(askGoods.getUserId()) //用户id
                            .setDeliveryId(deliveryId) //销售单id
                            .setCompanyNumber(list.get(0).getCompanyNumber()) //公司编号
                            .setCustomerCode(list.get(0).getCustomerCode())//客户编号
                            .setStorageCode(removalCode) //出库流水
                            .setWbs(list.get(0).getWbs());// wbs
                    deliveryMapper.addRemovalHalf(delivery1); //流水录入
                } else if(materialClass.getPartType().equals("原材料")){
                    askGoods.setType("销售出库");
                    askGoodsMapper.addRemoval(askGoods);//插入出库流水
                } else if(materialClass.getPartType().equals("半成品")){
                    //半成品销售流水
                    Delivery delivery1 = new Delivery()
                            .setMaterialCode(askGoods.getWllbCode()) //物料code
                            .setOutNum(askGoods.getNum()) //出库数量
                            .setUserId(askGoods.getUserId()) //用户id
                            .setDeliveryId(deliveryId) //销售单id
                            .setCompanyNumber(list.get(0).getCompanyNumber()) //公司编号
                            .setCustomerCode(list.get(0).getCustomerCode())//客户编号
                            .setStorageCode(removalCode) //出库流水
                            .setWbs(list.get(0).getWbs());// wbs
                    deliveryMapper.addRemovalHalfProduct(delivery1); //流水录入
                }
                askGoodsMapper.deleteVirtual(askGoods.getId());//删除已出虚拟表库存

                if(materialClass.getPartType().equals("产成品")){
                    //查询设备绑定的
                    List<Map<String, Object>> list1 = deliveryMapper.getEquipmentSoftware(materialClass.getCode());
                    //如果设备绑定软件基础信息有数据则继续往下执行
                    if(list1.size() != 0){
                        Map<String, Object> map1 = list1.get(0);
                        Delivery delivery1 = new Delivery()
                                .setDeliveryId(deliveryId)
                                .setMaterialId(map1.get("materialId").toString())
                                .setWbs(list.get(0).getWbs())
                                .setUserId(askGoods.getUserId());
                        //查询软件类销售出库单据
                        List<Delivery> list2 = deliveryMapper.getDelivery(delivery1);
                        //如果单据存在  则继续往下执行
                        if(list2.size() != 0){
                            //修改软件类单据出库数量
                            deliveryMapper.updateDelivery(list2.get(0).getMaterialId(), askGoods.getNum(), deliveryId, list2.get(0).getEntryNumber());
                            //存入返回GS信息表内
                            ReturRemoval returRemoval = new ReturRemoval()
                                    .setMaterialId(map1.get("materialId").toString())
                                    .setDocumentId(deliveryId)
                                    .setWbs(list2.get(0).getWbs())
                                    .setNum(askGoods.getNum())
                                    .setEntryNumber(list2.get(0).getEntryNumber())
                                    .setDocumentPointsId(list2.get(0).getId())
                                    .setStorageLocationCode(askGoods.getStorageLocationCode());
                            askGoodsMapper.addReturnGsRemoval(returRemoval);//新增返回gs数据子表信息
                        }
                    }
                }
                //存入返回GS信息表内
                ReturRemoval returRemoval = new ReturRemoval()
                        .setMaterialId(materialClass.getTldId())
                        .setDocumentId(deliveryId)
                        .setWbs(list.get(0).getWbs())
                        .setNum(askGoods.getNum())
                        .setEntryNumber(list.get(0).getEntryNumber())
                        .setDocumentPointsId(list.get(0).getId())
                        .setStorageLocationCode(askGoods.getStorageLocationCode());
                askGoodsMapper.addReturnGsRemoval(returRemoval);//新增返回gs数据子表信息
            }
            if(listData.size() != 0){
                //新增销售单出库父表信息
                Delivery delivery = deliveryMapper.getDeliveryF(deliveryId);
                ReturRemoval returRemoval1 = new ReturRemoval()
                        .setDocumentId(delivery.getDeliveryId())
                        .setRemovalCode(removalCode)
                        .setSourceType(delivery.getSourceType())
                        .setMoveType(delivery.getMoveType())
                        .setDeliveryType(delivery.getDeliveryType());
                askGoodsMapper.addReturnGsRemovalF(returRemoval1);//新增返回gs数据父表信息
            }
            map.put("data", removalCode);
            map.put("msg", "200");
        }catch (Exception e){
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
            e.printStackTrace();
        } finally {
            //判断要解锁的key是否已被锁定;判断要解锁的key是否被当前线程持有
            if (lock.isLocked() && lock.isHeldByCurrentThread()) {
                //释放锁
                lock.unlock();
            }
        }
        return map;
    }

    @Override
    public Map<String, Object> getAttribute(Delivery delivery) {
        Map<String, Object> map = new HashMap<>();
        try{
            //查询所有产成品库位
            String storageLocationCode = deliveryMapper.getStorageLocationCodeList();
            List<Inventory> list = deliveryMapper.getAttribute(storageLocationCode, delivery);
            map.put("data", list);
            map.put("msg", "200");
        }catch (Exception e){
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
            e.printStackTrace();
        }
        return map;
    }

    @Override
    public Map<String, Object> addVitrual(AskGoods askGoods) {
        Map<String, Object> map = new HashMap<>();
        try{
            int mapValScan = deliveryMapper.getDeliveryScan(askGoods);
            if(mapValScan != 0){
                map.put("msg", "500");
                map.put("errMsg", "已扫描！");
                return map;
            }
            Map<String, Object> mapVal = deliveryMapper.getScanIsNot(askGoods);
            if(Double.parseDouble(mapVal.get("amount").toString()) - Double.parseDouble(mapVal.get("vitrualNum").toString()) == 0){
                map.put("msg", "500");
                map.put("errMsg", "已全部出库");
                return map;
            }
            //判断物料是否录入
            MaterialClass materialClass = warehousingMapper.getMateriaIsExist(askGoods.getWllbCode());
            if(!materialClass.getPartType().equals("产成品")){
                Delivery delivery = deliveryMapper.getDeliveryInfo(askGoods); //需求数量、已出数量
                String scanNum = deliveryMapper.getScanNumDelivery(askGoods); //单据扫描数量
                Inventory inventory = deliveryMapper.getInventoryVal(askGoods.getId());//库存数量
                String allScanNum = deliveryMapper.getAllScanNumDelivery(askGoods); //虚拟表此物料占用数量
                //剩余出库数量
                Double num = Double.parseDouble(delivery.getGsDeliveryNum()) - Double.parseDouble(delivery.getOutNum()) - Double.parseDouble(scanNum);
                if(Double.doubleToLongBits(Double.parseDouble(inventory.getAmount()) - Double.parseDouble(allScanNum) - num) >= 0){
                    askGoods.setNum(num.toString());
                } else {
                    askGoods.setNum((Double.parseDouble(inventory.getAmount()) - Double.parseDouble(allScanNum)) + "");
                }
            }
            askGoodsMapper.addAskGoodsVitrual(askGoods);
            map.put("msg", "200");
        }catch (Exception e){
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
            e.printStackTrace();
        }
        return map;
    }

    @Override
    public Map<String, Object> delDelivery(String id, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<>();
        try {
            String userId = request.getHeader("userId");
            Map<String, Object> mapVal = deliveryMapper.getDeliverys(id);
            if(Double.parseDouble(mapVal.get("out_num").toString()) > 0){
                map.put("msg", "500");
                map.put("errMsg", "此单据已出库！");
                return map;
            }
            LogData logData = new LogData()
                    .setUserId(userId)
                    .setData(mapVal.toString())
                    .setType("0")
                    .setDocumentType("交货单");
            dictionaryMapper.addLogdata(logData);
            deliveryMapper.delDelivery(id);
            map.put("msg", "200");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    @Override
    public Map<String, Object> getDeliveryCode(Delivery delivery) {
        Map<String, Object> map = new HashMap<>();
        try {
            List<Delivery> list = deliveryMapper.getDeliveryCode(delivery);
            map.put("data", list);
            map.put("msg", "200");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    @Override
    public Map<String, Object> getDeliveryName(Delivery delivery) {
        Map<String, Object> map = new HashMap<>();
        try {
            List<String> list = deliveryMapper.getDeliveryProjectName(delivery);
            map.put("data", list);
            map.put("msg", "200");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    @Override
    public Map<String, Object> getEquipmentBindingSoftware(EquipmentBindingSoftware equipmentBindingSoftware) {
        Map<String, Object> map = new HashMap<>();
        try {
            PageHelper.startPage(equipmentBindingSoftware.getPage(), equipmentBindingSoftware.getLimit());
            PageInfo<EquipmentBindingSoftware> pageInfo = new PageInfo<>(deliveryMapper.getEquipmentBindingSoftware(equipmentBindingSoftware));
            map.put("data", pageInfo);
            map.put("msg", "200");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    @Override
    public Map<String, Object> addEquipmentBindingSoftware(EquipmentBindingSoftware equipmentBindingSoftware, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<>();
        try {
            equipmentBindingSoftware.setModifyUser(request.getHeader("userId"));
            int count = deliveryMapper.getIsNotBinding(equipmentBindingSoftware);
            if(count > 0){
                map.put("msg", "500");
                map.put("errMsg", "此设备已经绑定过次软件，请勿重复绑定！");
                return map;
            }
            deliveryMapper.addEquipmentBindingSoftware(equipmentBindingSoftware);
            map.put("msg", "200");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    @Override
    public Map<String, Object> updateEquipmentBindingSoftware(EquipmentBindingSoftware equipmentBindingSoftware, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<>();
        try {
            equipmentBindingSoftware.setModifyUser(request.getHeader("userId"));
            deliveryMapper.updateEquipmentBindingSoftware(equipmentBindingSoftware);
            map.put("msg", "200");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    @Override
    public Map<String, Object> delEquipmentBindingSoftware(String id) {
        Map<String, Object> map = new HashMap<>();
        try {
            deliveryMapper.delEquipmentBindingSoftware(id);
            map.put("msg", "200");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 出库单生成
     * @return
     */
    public String codeGenerateCk(){
        StringBuilder stringBuilder = new StringBuilder("XSCK");
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyMMdd");
        stringBuilder.append(sdf.format(date));
        int count = askGoodsMapper.getReturnRemovalCount();
        for(int i = 0; i < 4 - (count + "").length(); i++){
            stringBuilder.append("0");
        }
        return (stringBuilder.append(count + 1)).toString();
    }
}