package com.myproject.webapp.controller.webService;

import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.myproject.bean.update.*;
import com.myproject.bean.utils.BoxStatusBean;
import com.myproject.bean.utils.StatusBean;
import com.myproject.dao.mongo.IDataLogDao;
import com.myproject.exception.ValidateException;
import com.myproject.manager.IBarcodeManager;
import com.myproject.manager.IComponentManager;
import com.myproject.manager.IStoragePosManager;
import com.myproject.util.DateUtil;
import com.myproject.util.StorageConstants;
import com.myproject.webapp.controller.storage.BaseController;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.util.Integers;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.text.ParseException;
import java.util.*;
import java.util.stream.Collectors;


@Controller
@RequestMapping("/rest/api/v2/mes")
public class MesApiController extends BaseController {

    @Autowired
    protected ITaskService taskService;

    @Autowired
    protected IComponentManager componentManager;

    @Autowired
    private IBarcodeManager barcodeManager;

    @Autowired
    private IStoragePosManager storagePosManager;

    @Autowired
    private DataCache dataCache;

    @Autowired
    private IDataLogDao dataLogDao;

    protected final static Logger log = LogManager.getLogger(MesApiController.class);

    /**
     * 基础数据同步
     */
    @RequestMapping(value = "/dataUpdate")
    @ResponseBody
    public String dataUpdate(HttpServletRequest request) {
        try {
            String Partnumber = checkParameter(request,"PN");
            String w = checkParameter(request,"PACKAGE_WIDTH");
            String h = checkParameter(request,"PACKAGE_HEIGHT");

            log.info("收到 MES 的 数据同步信息"+Partnumber+"【"+w+"x"+h+"】");

            Component c = componentManager.findOneByPn(Partnumber);
            if(c == null){
                c = new Component();
            }
            c.setPartNumber(Partnumber);
            c.setPlateSize(Integer.valueOf(w));
            c.setHeight(Integer.valueOf(h));
            componentManager.save(c);
        } catch (ValidateException e) {
            return "Error:" + e.getMessage();
        }
        return "OK";
    }

    private String checkParameter(HttpServletRequest request, String paramName) throws ValidateException {
        String value = request.getParameter(paramName);
        if(Strings.isNullOrEmpty(value)){
            log.info(paramName + " is required.");
            throw new ValidateException(paramName + " is required.");
        }
        return value;
    }

    @RequestMapping(value = "/codeUpdate")
    @ResponseBody
    public String codeUpdate(HttpServletRequest request) {

        try {
            String REEL_ID = checkParameter(request,"RI");
            String PARTNUMBER = checkParameter(request,"PN");
            String QTY = checkParameter(request,"QTY");
            log.info("收到条码同步信息:RI="+REEL_ID + " PN=" + PARTNUMBER + " QTY="+QTY);
            Component c = componentManager.findOneByPn(PARTNUMBER);
            if(c == null){
                return "Error: 物料编号[" + PARTNUMBER + "]的档案不存在";
            }
            Barcode barcode = barcodeManager.findByBarcode(REEL_ID);
            if(barcode == null){
                barcode = new Barcode();
            }
            barcode.setBarcode(REEL_ID);
            barcode.setPartNumber(PARTNUMBER);
            barcode.setInitialAmount(Integer.valueOf(QTY));
            barcode.setAmount(Integer.valueOf(QTY));
            barcode.setPlateSize(c.getPlateSize());
            barcode.setHeight(c.getHeight());
            barcodeManager.save(barcode);
        }catch (ValidateException ve) {
            return "Error:" + ve.getMessage();
        }catch (Exception e){
            return "Error:" + e.getMessage();
        }
        return "OK";
    }

    @RequestMapping(value = "/stackOut")
    @ResponseBody
    public String stackOut(HttpServletRequest request) {

        try {
            String[] REEL_IDS = request.getParameterValues("RIS");

            if(REEL_IDS == null || REEL_IDS.length == 0){
                return "Error: RI 为必须项";
            }

            ArrayList<StoragePos> poses = Lists.newArrayList();
            for (String REEL_ID : REEL_IDS) {
                StoragePos pos = storagePosManager.getByBarcode(REEL_ID);
                if(pos == null){
                    return "Error: RI["+REEL_ID+"]在BOX中不存在";
                }
                poses.add(pos);
            }
            for (StoragePos pos : poses) {
                log.info("出库位置仓位【"+pos.getPosName()+"】");
                taskService.checkout(pos,null,false);
            }

        }catch (Exception e){
            return "Error:" + e.getMessage();
        }
        return "OK";
    }

    @RequestMapping(value = "/inventory")
    @ResponseBody
    public List<Map<String,Object>> getInventory(HttpServletRequest request){
        String storageId = request.getParameter("LOC");
//        try {
//            String body = request.getReader().lines().collect(Collectors.joining(System.lineSeparator()));
//            log.info("body:" + body);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
        List<Map<String,Object>> ReelBarCodes = Lists.newArrayList();
        List<StoragePos> poses;
        if(!Strings.isNullOrEmpty(storageId)){
            poses = storagePosManager.findNotEmptyByStorageId(storageId);
        }else{
            poses = storagePosManager.findNotEmpty();
        }

        for (StoragePos pos : poses){
            Barcode barcode = pos.getBarcode();
            Map<String,Object> item = Maps.newHashMap();
            item.put("RI",barcode.getBarcode());
            item.put("PN",barcode.getPartNumber());
            item.put("QTY",barcode.getAmount());
            item.put("LOC", pos.getStorageId());
            ReelBarCodes.add(item);
        }
        return ReelBarCodes /*+ dataCache.getSettings().getNotifyApiUrl()*/;
    }

    @RequestMapping(value = "/unlock")
    @ResponseBody
    public String unlock(HttpServletRequest request) {
        String orderName = request.getParameter("orderName");//锁定标签
        log.info("收到unlock 请求:orderName=" + orderName);
        Storage defaultStorage = dataCache.defaultStorage();
        List<StoragePos> lockPoses = storagePosManager.findLockPos(orderName);
        for (StoragePos lockPos : lockPoses) {
            try {
                Barcode code = lockPos.getBarcode();
                code.setLockId(null);
                code.setLockName(null);
                lockPos.setBarcode(code);
                storagePosManager.save(lockPos);
                dataCache.unLockOneReel(defaultStorage.getCid(),code.getPartNumber());
            } catch (ValidateException e) {
                e.printStackTrace();
            }
        }
        return "OK";
    }

    @RequestMapping(value = "/lock")
    @ResponseBody
    public String lock(HttpServletRequest request){
        String orderName = request.getParameter("orderName");//锁定标签
        String pn = request.getParameter("pn");//Partnumber
        int num =Integers.parseInt(request.getParameter("num"),-1);//锁定数量
        log.info("lock 请求:orderName="+orderName + ";pn=" + pn + ";num=" + num);
        if(Strings.isNullOrEmpty(orderName) || Strings.isNullOrEmpty(pn) || num == -1){
            return "Error:参数错误";
        }
        //验证库存
        Collection<String> excludePosIds = Sets.newHashSet();
        Collection<StoragePos> posToLock = Sets.newHashSet();
        int lockNum = 0;
        while (lockNum < num){
            StoragePos pos = storagePosManager.findPartNumberPos(null, pn, excludePosIds, StorageConstants.CHECKOUT_TYPE.EXPIRE_FIRST);
            if(pos == null){
                return "Error:库存不足";
            }
            Barcode barcode = pos.getBarcode();
            if(barcode != null){
                lockNum = lockNum + barcode.getAmount();
                log.info("lockOrderName="+orderName+"查找到物料【 "+barcode.getBarcode()+" 】,PN=["+ barcode.getPartNumber()+"],数量="+barcode.getAmount()+"已找到数量:"+lockNum);
                posToLock.add(pos);
            }
            excludePosIds.add(pos.getId());
        }

        for (StoragePos storagePos : posToLock) {
            try {
                Barcode code = storagePos.getBarcode();
                code.setLockId(orderName);
                code.setLockName("API");
                storagePos.setBarcode(code);
                storagePosManager.save(storagePos);
                Storage storage = dataCache.getStorageById(storagePos.getStorageId());
                dataCache.lockOneReel(storage.getCid(),pn);
            } catch (ValidateException e) {
                e.printStackTrace();
            }
        }
        return "OK";
    }


    @RequestMapping(value = "/pnInventory")
    @ResponseBody
    public Map<String,Map<String,Integer>> getParnumberInventory(HttpServletRequest request){
        log.info("收到 getParnumberInventory 请求");
        Map<String,Map<String,Integer>> partnumberInventory = Maps.newHashMap();
        List<StoragePos> poses = storagePosManager.findNotEmpty();
        for (StoragePos pos : poses){
            Barcode barcode = pos.getBarcode();
            String parnumber = barcode.getPartNumber();
            Map<String,Integer> itemInventory = partnumberInventory.get(parnumber);
            int totalNum = 0;
            int lockNum = 0;
            if(itemInventory == null){
                itemInventory = Maps.newHashMap();
            }else{
                totalNum = itemInventory.get("totalNum");
                lockNum = itemInventory.get("lockNum");
            }

            totalNum = totalNum + barcode.getAmount();
            if(!Strings.isNullOrEmpty(barcode.getLockId())){
                lockNum = lockNum + barcode.getAmount();
            }
            itemInventory.put("totalNum", totalNum);
            itemInventory.put("lockNum", lockNum);
            partnumberInventory.put(parnumber,itemInventory);
        }
        return partnumberInventory;
    }






    @RequestMapping(value = "/history")
    @ResponseBody
    public List<Map<String,Object>> history(HttpServletRequest request) {
        String bid = request.getParameter("bid");
//        String start = request.getParameter("start");
//        String end = request.getParameter("end");
//        Date startDate = toDate(start);
//        Date endDate = toDate(end);
        String numStr = request.getParameter("num");

        int num = 20;
        if(!Strings.isNullOrEmpty(numStr)){
            try{
                num = Integer.valueOf(numStr);
            }catch (Exception e){

            }
        }

        List<Map<String,Object>> results = Lists.newArrayList();
        List<DataLog> datas = dataLogDao.findHistory(bid,num);

        datas.sort(new Comparator<DataLog>() {
            @Override
            public int compare(DataLog o1, DataLog o2) {
                return o1.getCreateDate().compareTo(o2.getCreateDate());
            }
        });
        for (DataLog dataItem : datas){
            Map<String,Object> item = Maps.newHashMap();
            item.put("barcode",dataItem.getBarcode());
            item.put("partnumber",dataItem.getPartNumber());
            item.put("qty",dataItem.getNum());
            item.put("type", dataItem.getType());
            item.put("opor", dataItem.getOperator());
            item.put("boxName",dataItem.getStorageName());
            item.put("posName",dataItem.getPosName());
            item.put("source",dataItem.getSourceId());
            item.put("status", dataItem.getStatus());
            item.put("date", DateUtil.toDateTimeString(dataItem.getCreateDate()));
            results.add(item);
        }
        return results;
    }

    @RequestMapping(value = "/status")
    @ResponseBody
    public Map<String,Object> status(HttpServletRequest request) {
        Map<String,Object> results = Maps.newHashMap();
        for (Storage storage : dataCache.getAllStorage().values()){
            StatusBean statusBean = taskService.getStatus(storage.getCid());
            Map<Integer, BoxStatusBean> boxStatusMap = statusBean.getBoxStatus();
            int status = -1;
            if(boxStatusMap != null){
                BoxStatusBean boxStatusBean = boxStatusMap.get(1);
                if(boxStatusBean != null){
                    status = boxStatusBean.getStatus();
                }

            }
            int storageStatus = status;
            if(status == StorageConstants.STATUS.OFFLINE || statusBean.timeOut()){
                //离线
                storageStatus = -1;
            }
            results.put(storage.getName(), storageStatus);
        }
        return results;
    }

    private Date toDate(String dateStr){
        try {
            return DateUtil.toDate(dateStr,"yyyyMMddHHmmss");
        } catch (Exception e) {
        }
        return null;
    }


}