package com.iamberry.rst.controllers.pts;

import com.iamberry.rst.controllers.sys.SysController;
import com.iamberry.rst.core.pts.*;
import com.iamberry.rst.core.sys.SysConfig;
import com.iamberry.rst.core.tools.QRCJson;
import com.iamberry.rst.core.tools.WeixinUtil;
import com.iamberry.rst.faces.pts.*;
import com.iamberry.rst.faces.sys.SysConfigService;
import com.iamberry.wechat.tools.*;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

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

/**
 * Created by LJK on 2017/8/29.
 */
@Controller
@RequestMapping("/mcahine")
public class MachineController {
    private static Logger logger = LoggerFactory.getLogger(MachineController.class);

    @Autowired
    private ProduceService produceService;

    @Autowired
    private MachineService machineService;

    @Autowired
    private DeviceService deviceService;

    @Autowired
    private PtsEmployeeService ptsEmployeeService;

    @Autowired
    private MachineLogsService machineLogsService;

    @Autowired
    private PtsBatchService ptsBatchService;

    @Autowired
    private MachineBarQrcode machineBarQrcode;

    @ResponseBody
    @RequestMapping("/uploadProcessOptions")
    public ResponseJson uploadProcessOptions(HttpServletRequest request) {
        ResponseJson rj = new ResponseJson();
        String nodeList = request.getParameter("nodeList");
        if (nodeList == null || "".equals(nodeList)) {
            return ResponseJson.getFAILURE();
        }
        // 转换json数据
        JSONObject query = JSONObject.fromObject(nodeList);

        // 员工id
        Integer employeeId = query.getInt("employeeId");
        // 产品编号
        String produceNo = query.getString("produceId");
        // NFCID(卡片id)
        String nfcId = query.getString("nfcId");
        // 选项集合（包含一个或多个工序选项，详情见示例）
        JSONArray nodes = query.getJSONArray("nodes");

        /**
         * 判断当前卡片的内容是否已经上传到服务器(卡片ID+时间戳)
         */
        JSONObject machineJsonObject = nodes.getJSONObject(0);
        PtsMachine machine = new PtsMachine();
        machine.setMachineNfcId(nfcId);
        machine.setMachineCreateTime(timeConversions(machineJsonObject.getString("logsProcessTime")));
        Integer ishave = machineService.getMachineIsHave(machine);
        if (ishave > 0) {
            rj.setResultCode(500);
            rj.setResultMsg("500");
            rj.setResultMsg("此卡片内容已生成二维码");
            return rj;
        }

        //根据产品编号获取产品信息
        Produce produce = produceService.getProduce(produceNo);

        /*根据员工id，获取拉线，再将拉线存入机器表 */
        PtsEmployee employee = new PtsEmployee();
        employee.setEmployeeId(employeeId);
        employee = ptsEmployeeService.getPtsEmployeeWebApp(employee);
        String employeeLine = employee.getEmployeeLine();

        /* 获取当前产品使用的批次 */
        PtsBatch ptsBatch = ptsBatchService.getUseBatch(produce.getProduceId());
        if (ptsBatch == null) {
            rj.setResultCode(500);
            rj.setResultMsg("500");
            rj.setResultMsg("系统中没有该产品正在使用的批次,请到管理平台完善");
            return rj;
        }

        // 生成条形码
        String berQrcode = machineBarQrcode.ctrBarCode(produce);

        // 判断是否需要二维码
        String qrcode = null;
        if (produce.getIsPrintQrcode() == 1) {
            if (produce.getIsGeneralQrcode() == 1) {
                // 使用通用的二维码
                qrcode = produce.getGeneralQrcode();
            } else {
                // 单独生成二维码
                WechatMp wechatMp = produceService.getWechatMpById(produce.getWechatMpId());
                String json = String.format(NameUtils.QR_LIMIT_STR_SCENE, ResultInfo.barCodePrefix + berQrcode);
                QRCJson qrc = WeixinUtil.createQrcodeByWechatMp(json,wechatMp.getWechatMpAppid(),wechatMp.getWechatMpAppsecret(),wechatMp.getWechatMpPubno());
                qrcode = qrc.getUrl();
            }
        }

        /*获取公众号信息*/
        PtsMachine ptsMachine = new PtsMachine();
        {
            //二维码
            ptsMachine.setMachineQrcode(qrcode);
            //条形码
            ptsMachine.setMachineBarcode(berQrcode);
            //机器状态
            ptsMachine.setMachineStatus(1);
            //生产时间
            ptsMachine.setMachineProducedTime(new Date());
            //是否打印1:未打印2:已打印
            ptsMachine.setMachineIsPrint(1);
            ptsMachine.setMachineCompoundImg("合成的图片url");
            //生成流程状态1.正常2.异常
            ptsMachine.setMachineProcessState(1);
            //创建时间
            ptsMachine.setMachineCreateTime(new Date());
            //产品类型
            ptsMachine.setMachineProduceType(produce.getProduceType());
            ptsMachine.setMachineNfcId(nfcId);
            ptsMachine.setMachineSoftwareVersion(ptsBatch.getBatchSoftwareVersionId());
            ptsMachine.setMachineProduceId(produce.getProduceId());
            //默认为0
            ptsMachine.setMachineBomId(0);
            //默认为0
            ptsMachine.setMachineBatchId(0);
            ptsMachine.setMachineIsRetreading(2);
            //拉线信息
            ptsMachine.setMachineLine(employeeLine);
            //批次id
            ptsMachine.setMachineBatchId(ptsBatch.getBatchId());
            //bom单id
            ptsMachine.setMachineBomId(ptsBatch.getBomId());
            machineService.addMachine(ptsMachine);
        }

        //状态是否异常
        boolean isAbnormality = true;

        List<PtsMachineLogs>  ptsMachineLogsList = new ArrayList<PtsMachineLogs>();
        for (int i = 0; i < nodes.size(); i++) {
            PtsMachineLogs ptsMachineLogs = new PtsMachineLogs();

            JSONObject jsonObject = nodes.getJSONObject(i);
            //工序编号
            String processNo = jsonObject.getString("processId");
            //工序选项编号
            String nodeNo = jsonObject.getString("nodeId");
            //工序执行时间 （时间戳）
            String logsProcessTime = jsonObject.getString("logsProcessTime");
            Date logsProcessDate = timeConversions(logsProcessTime);

            ProduceProcess produceProcess = produceService.getProduceProcessAndNode(produce.getProduceId(), processNo);
            ProcessNode processNode = produceService.getprocessNode(produceProcess.getProcessId(), nodeNo);
            String deviceName = produceProcess.getDeviceName();
            String employeeName = produceProcess.getEmployeeName();

            if (deviceName == null) {
                String processName = produceProcess.getProcessName();
                rj.setResultCode(500);
                rj.setResultMsg("500");
                rj.setResultMsg("\"" + processName + "\"工序的打卡设备未完善，请到管理平台完善");
                return rj;
            }
            if (employeeName == null) {
                String processName = produceProcess.getProcessName();
                rj.setResultCode(500);
                rj.setResultMsg("500");
                rj.setResultMsg("\"" + processName + "\"工序的员工信息未完善，请到管理平台完善");
                return rj;
            }

            ptsMachineLogs.setDeviceId(produceProcess.getDriveId());
            ptsMachineLogs.setEmployeeId(produceProcess.getEmployeeId());
            ptsMachineLogs.setProduceId(produce.getProduceId());
            ptsMachineLogs.setProcessId(produceProcess.getProcessId());
            ptsMachineLogs.setMachineId(ptsMachine.getMachineId());
            ptsMachineLogs.setEmployeeName(employeeName);
            ptsMachineLogs.setProduceName(produce.getProduceName());
            ptsMachineLogs.setProcessName(produceProcess.getProcessName());
            ptsMachineLogs.setDeviceName(deviceName);
            ptsMachineLogs.setProcessNodeId(processNode.getNodeId());
            ptsMachineLogs.setProcessNodeName(processNode.getNodeDes());
            if (i == 0) {
                //如果当前循环的是第一条数据则排序必须是1，否则为异常
                if (produceProcess.getProcessSort() == 1) {
                    if (processNode.getNodeStatus() == 0) {
                        //工序选项状态为异常则机器表状态也是异常
                        isAbnormality = false;
                    }
                    ptsMachineLogs.setLogsProcessStatus(processNode.getNodeStatus());
                } else {
                    ptsMachineLogs.setLogsProcessStatus(0);
                    isAbnormality = false;
                }
            } else {
                //默认为正常
                ptsMachineLogs.setLogsProcessStatus(processNode.getNodeStatus());
            }
            ptsMachineLogs.setLogsProcessPrompt(processNode.getNodeStatus() == 0 ? "检查不通过" : null);
            ptsMachineLogs.setLogsProcessTime(logsProcessDate);
            ptsMachineLogs.setLogsCreateTime(new Date());

            //根据上一条工序选项信息判断当前工序是否正常，如果当前为修理工序则忽略，如果上一条为修理工序则查询上上一条
            if (i > 0) {
                int num = 0;
                // 当前工序的上一条非修理工序
                ProduceProcess produceProcess2 = null;
                //上一级工序信息
                JSONObject jsonObject2;
                //上一级工序编号
                String processNo2 = null;
                //先判断当前的上一次是否是修理工序，如果不是则不用执行下面的循环，否则需要循环判断
                jsonObject2 = nodes.getJSONObject(i - 1);
                if (jsonObject2 != null) {
                    processNo2 = jsonObject2.getString("processId");
                    produceProcess2 = produceService.getProduceProcess(produce.getProduceId(), processNo2);
                    //判断当前工序是否是修理工序，如果是，则修改上一条为次品
                    if (produceProcess.getProcessType() == 2) {
                        //异常类型 1:流程异常 2:次品异常
                        ptsMachineLogsList.get(ptsMachineLogsList.size()-1).setLogsErrorType(2);
                        ptsMachineLogsList.get(ptsMachineLogsList.size()-1).setLogsProcessPrompt("次品异常");
                        isAbnormality = false;
                        ptsMachineLogs.setLogsId(null);
                        ptsMachineLogs.setLogsErrorType(null);
                        ptsMachineLogs.setLogsProcessPrompt(null);
                    } else {
                        //判断是否是修理工序 1:生产工序 2:修理工序
                        if (produceProcess2.getProcessType() == 1) {
                            if (produceProcess.getProcessSort() - produceProcess2.getProcessSort() != 1) {
                                ptsMachineLogs.setLogsProcessStatus(0);
                                //异常类型 1:流程异常 2:次品异常
                                ptsMachineLogs.setLogsErrorType(1);
                                ptsMachineLogs.setLogsProcessPrompt("流程异常");
                                isAbnormality = false;
                            }
                        } else {
                            for (int j = i - 1; j <= i - 1; j--) {
                                if (num == i) {
                                    break;//只能循环 i 次，超出则跳出当前循环
                                }
                                jsonObject2 = nodes.getJSONObject(j);
                                if (jsonObject2 != null) {
                                    processNo2 = jsonObject2.getString("processId");
                                    produceProcess2 = produceService.getProduceProcess(produce.getProduceId(), processNo2);
                                    if (produceProcess2.getProcessType() == 1) {
                                        //判断是否是修理工序 1:生产工序 2:修理工序
                                        if (produceProcess.getProcessSort() > produceProcess2.getProcessSort()) {
                                            ptsMachineLogs.setLogsProcessStatus(0);
                                            //异常类型 1:流程异常 2:次品异常
                                            ptsMachineLogs.setLogsErrorType(1);
                                            ptsMachineLogs.setLogsProcessPrompt("流程异常");
                                            isAbnormality = false;
                                        }
                                        break;
                                    }
                                }
                                num++;
                            }
                        }
                    }
                }
            }
            //执行添加日志操作
            ptsMachineLogsList.add(ptsMachineLogs);
            //还原为默认值
            ptsMachineLogs.setLogsErrorType(null);
        }
        machineLogsService.addMachineLogs(ptsMachineLogsList);

        //修改机器信息
        PtsMachine ptsMachine2 = new PtsMachine();
        ptsMachine2.setMachineId(ptsMachine.getMachineId());
        if (!isAbnormality) {
            //2表示机器生产过程中出现异常
            ptsMachine2.setMachineProcessState(2);
        }
        ptsMachine2.setMachineUpdateTime(new Date());
        ptsMachine2.setMachineProduceId(produce.getProduceId());
        machineService.updateMachine(ptsMachine2);
        //截取条形码尾号（4位）
        rj.addResponseKeyValue("barcodeTail", berQrcode.substring(berQrcode.length() - 4, berQrcode.length()));
        return rj;
    }


    private static Date timeConversions(String time) {
        if (time == null || time.equals("")) {
            return new Date();
        }
        //08311112
        Calendar date = Calendar.getInstance();
        String year = String.valueOf(date.get(Calendar.YEAR));//年
        String months = null;//月
        String sky = null;//天
        String when = null;//时
        String subdivision = null;//分
        months = time.substring(0, 2);
        sky = time.substring(2, 4);
        when = time.substring(4, 6);
        subdivision = time.substring(6, 8);
        time = year + "-" + months + "-" + sky + " " + when + ":" + subdivision;
        Date dates = new Date();
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            dates = sdf.parse(time);
        } catch (ParseException e) {
            System.out.println(e.getMessage());
        }

        return dates;
    }

    /**
     * 根据barcode查询机器信息（电动牙刷项目也调用此功能）
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping("/getMachineInfo")
    public RespJsonBean getMachineInfo(HttpServletRequest request) {
        RespJsonBean rsj = new RespJsonBean();
        String barCode = request.getParameter("barCode");
        if (barCode == null || barCode.equals("")) {
            return null;
        }
        PtsMachine ptsMachine = machineService.getMachineByBarCode(barCode);
        if(ptsMachine != null){
            rsj.addResponseKeyValue("isBeing",1);
            rsj.addResponseKeyValue("productType",ptsMachine.getMachineProduceType() == 1?"净水机":"冲奶机");
            rsj.addResponseKeyValue("producedTime",ptsMachine.getMachineProducedTime() == null?null:ptsMachine.getMachineProducedTime().getTime());
            rsj.addResponseKeyValue("productId",ptsMachine.getMachineProduceId());//产品id
            /*rsj.addResponseKeyValue("producePattern",ptsMachine.getProducePattern());//产品型号前俩位
            rsj.addResponseKeyValue("produceModel",ptsMachine.getProduceModel());//产品型号后俩位
            rsj.addResponseKeyValue("produceName",ptsMachine.getProduceName());//产品名*/
        }else{
            rsj.addResponseKeyValue("isBeing",2);
        }
        return rsj;
    }

    /**
     * 查询所有牙刷信息（电动牙刷项目也调用此功能）
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping("/listToothInfo")
    public RespJsonBean listToothInfo(HttpServletRequest request) {
        RespJsonBean rsj = new RespJsonBean();
        List<Produce> produce = produceService.listToothInfo();
        if(produce != null){
            rsj.setResultCode(200);
            rsj.addResponseKeyValue("produce",produce);

        }else{
            rsj.setResultCode(500);
        }
        return rsj;
    }
}