package com.uas.eis.serviceImpl;

import com.alibaba.fastjson.JSON;
import com.uas.eis.annotation.ApiLog;
import com.uas.eis.core.support.TokenHandler;
import com.uas.eis.dao.BaseDao;
import com.uas.eis.dao.SqlMap;
import com.uas.eis.dao.SqlRowList;
import com.uas.eis.entity.ErrorMessage;
import com.uas.eis.entity.ErrorMsg;
import com.uas.eis.entity.StepWork.StationReq;
import com.uas.eis.entity.StepWork.TestReq;
import com.uas.eis.exception.ApiStepWorkException;
import com.uas.eis.exception.SystemException;
import com.uas.eis.sdk.entity.ApiResult;
import com.uas.eis.sdk.entity.StepWorkApiResult;
import com.uas.eis.sdk.resp.StepWorkApiResponse;
import com.uas.eis.service.StepWorkService;
import com.uas.eis.utils.*;
import org.aspectj.weaver.ast.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
public class StepWorkServiceImpl implements StepWorkService {
    @Autowired
    private BaseDao baseDao;

    @Override
    public Map<String,Object> login(String username, String password) {
        Map<String,Object> map = new HashMap<>();
        SqlRowList rs = baseDao.queryForRowSet("select AE_SECRET from APIEMPLOYEE where AE_KEY=?",username);
        if(rs.next()){
            System.out.println("secret:"+MD5Util.encrypt32Up(rs.getString("ae_secret")));
          if(!password.toUpperCase().equals(MD5Util.encrypt32Up(rs.getString("ae_secret")))){
              map.put("success","0");
              map.put("error","password");
              map.put("error_description","密码错误");
              return map;
          }else{
              map.put("token",TokenHandler.createToken(username,rs.getString("ae_secret")));
              map.put("success","1");
              return map;
          }
        }else{
            map.put("success","0");
            map.put("error","username");
            map.put("error_description","用户名不存在");
            return map;
        }
    }

    /**
     * 保存测试信息并且过站
     * @param data
     * @return
     *  {
     *  "workOrderNo":"WO20220826000002SHD", //工单号 必填
     *  "stationCode":"GW--001",  //工位编码 必填
     * "routeCode":"22b443b4fa379a546330f4e984cc6ed1", //工序编号 必填
     * "sequenceNumber":"[P]2022083426046[B]",//产品SN 必填
     * "eventResult":"PASS", 测试结果：PASS(合格)，FAIL（不合格） 必填
     *  failureCode MES不良配置里维护的信息 * 注：PASS可以不用传， 如果是FAIL不良代码就必传 非必填
     *	extendSequenceNumber 测试合格后会把三方条码和组合体SN组合，后续扫描其中任意条码都可以识别。多个条码中间用逗分隔 非必填
     * 	machineTestData	设备测试数据 非必填 Json可以传产品多次测试记录。results的键值需要和titles的键值对应Titles中的键值不能重复
     * 	isInputSn	 是否属于投入产品 非必填 Boolean (true:根据投入SN过站并生成产品数据，false[默认]:从工单中查找是否有过站SN)
     * }
     *
     */
    @Override
    public StepWorkApiResult<Map<String,Object>> test(HttpServletRequest request ,String data) {
        insertLogger(data,"test");
        return testmain(request,data);
    }

    /**
     *  * {
     *      *  "workOrderNo":"WO20220826000002SHD",  //工单号
     *      * "stationCode":"GW--001",  //工位编码
     *      * "routeCode":"22b443b4fa379a546330f4e984cc6ed1", //工序编号
     *      * "sequenceNumber":"[P]2022083426046[B]" //产品SN
     *      * }
     * @param data
     * @return
     */
    @Override
    public StepWorkApiResult<Map<String,Object>> station(HttpServletRequest request , String data) {
        insertLogger(data,"station");
        return stationmain(request,data);
    }

    @Override
    public StepWorkApiResult<Map<String,Object>> UploadThruputLog(HttpServletRequest request, String data) {
        Map<Object,Object> map =  BaseUtil.parseFormStoreToMap(data);
        String SN = map.get("sequenceNumber").toString();
        String WO = map.get("workOrderNo").toString();
        String stationCode = map.get("stationCode").toString();
        String routeCode = map.get("routeCode").toString();
        String eventResult = map.get("eventResult").toString();
        try{
            String testName = Objects.toString(baseDao.getFieldDataByCondition("make,prodtestparam","pp_stepname","ma_code = '"+WO+"' AND pp_prodcode = ma_prodcode AND pp_stepcode = '"+routeCode+"'"),"");
            if(testName.isEmpty()){
                return new StepWorkApiResult(false,500,"工单:"+WO+"未维护测试参数列表");
            }

            int sdId = baseDao.getSeqId("steptestdata_seq");
            Object testDataObj = map.get("TestData");
            if (testDataObj instanceof List) {
                List<Object> testDataList = (List<Object>) testDataObj;
                for (Object item : testDataList) {
                    if (item instanceof Map) {
                        Map<Object, Object> testDataMap = (Map<Object, Object>) item;
                        String testItem = Objects.toString(testDataMap.get("testItem"),"");
                        String threshold = Objects.toString(testDataMap.get("threshold"),"");
                        String actualValue = Objects.toString(testDataMap.get("actualValue"),"");
                        String result = Objects.toString(testDataMap.get("result"),"");
                        String paramName = Objects.toString(testDataMap.get("paramName"),"");
                        String duration = Objects.toString(testDataMap.get("duration"),"");
                        String description = Objects.toString(testDataMap.get("description"),"");

                        if(!baseDao.checkIf("prodtestparam,make","pp_prodcode=ma_prodcode AND ma_code='"+WO+"' AND pp_stepcode='"+routeCode+"' AND pp_paramname='"+paramName+"'")){
                            return new StepWorkApiResult(false,500,"工单:"+WO+"测试参数列表,测试项目中参数名称无"+ paramName);
                        }

                        String sql = "INSERT INTO steptestdatadet( sdd_id, sdd_detno, sdd_sdid, sdd_sncode, sdd_makecode, " +
                                "sdd_resultdesc, sdd_testitem, sdd_pmenxdesc, sdd_result, sdd_paramname, " +
                                "sdd_testtime, sdd_value, sdd_okmin, sdd_okmax) " +
                                "SELECT steptestdatadet_seq.NEXTVAL, pp_detno, '"+sdId+"', '"+SN+"', ma_code, " +
                                "'"+description+"', pp_testitem, pp_menxdesc, '"+result+"', pp_paramname, " +
                                "pp_testtimes, '"+actualValue+"', pp_okmin, pp_okmax " +
                                "FROM prodtestparam, make WHERE pp_prodcode = ma_prodcode " +
                                "AND ma_code = '"+WO+"' AND pp_stepcode = '"+routeCode+"' AND pp_paramname = '"+paramName+"'";
                        baseDao.execute(sql);
                    }
                }

                baseDao.execute("INSERT INTO steptestdata(sd_id, sd_sn, sd_makecode, sd_sccode, " +
                        "sd_stepcode, sd_result, sd_indate, sd_recorddate) " +
                        "SELECT "+sdId+", '"+SN+"', '"+WO+"', sc_stepcode, " +
                        "'"+routeCode+"', '"+eventResult+"', sysdate, sysdate FROM source WHERE sc_code = '"+stationCode+"'");
            }

            List<String> list = baseDao.callProcedureWithOut("CS_CHECKSTEPSNANDMACODE", new Object[]{
                    WO, stationCode,SN,""
            }, new Integer[]{1, 2, 3, 4}, new Integer[]{5, 6, 7});
            String msg = Objects.toString(list.get(2),"");
            if(!msg.isEmpty()){
                return new StepWorkApiResult(false,500,"过站前核对失败:"+msg);
            }

            stepPassed(WO, stationCode, SN, "", "OK");

        }catch (Exception ex){
            return new StepWorkApiResult(false,500,"记录失败:" + ex.getMessage());
        }

        insertLogger(data,"UploadThruputLog");
        return new StepWorkApiResult(true,200,"上传MES测试信息成功");
    }

    /**
     *
     * @param request
     * @param data
     *  数据格式
     * {
     * "DeviceType":"",  //必填
     * "MacStart":"",
     * "MacEnd":"",
     * "WholeDeviceCode":"", //必填 表示SN号
     * "CameraID":"",
     * "ExtCode":"",
     * "EncryKey":"",
     * "RSANORM":""
     *  }
     * @return
     */
    @ApiLog(actionType = "产品SN个参校对")
    @Transactional
    @Override
    public StepWorkApiResult<Map<String, Object>> checkProdParam(HttpServletRequest request, String data) {
        if (!FlexJsonUtil.isValid(data)) {
            return StepWorkApiResponse.failRsp("传参JSON格式非法，请检查是否包含未转义的特殊字符（如反斜杠）");
        }
        //解析data 获取数据
         Map<Object,Object> map =  BaseUtil.parseFormStoreToMap(data);

         Object sn = map.get("WholeDeviceCode");
         if(!StringUtil.hasText(sn)){
            return StepWorkApiResponse.failRsp("传参:WholeDeviceCode,异常不能为空!");
         }
        Object prodcode = map.get("DeviceType");
        if(!StringUtil.hasText(prodcode)){
            return StepWorkApiResponse.failRsp("传参:DeviceType,异常不能为空!");
        }
        // 判断产品是否有设置个参字段
        String paramCodes = null;
        SqlRowList rsParam = baseDao.queryForRowSet(
                "select wm_concat(pp_paramcode) as paramcodes " +
                        " from (select distinct pp_paramcode from product left join prodparam on pr_id=pp_prid " +
                        " where pr_code=? and pp_id>0 and pp_paramcode is not null)", prodcode);
        if (rsParam.next()) {
            paramCodes = rsParam.getGeneralString("paramcodes");
        }
        if (!StringUtil.hasText(paramCodes)) {
            return StepWorkApiResponse.failRsp("产品[" + prodcode + "]未配置个参字段，无法校对！");
        }

        //根据产品编号+sn号，寻找工作中心是组装的工单
        String macode = "";
        SqlRowList rs = baseDao.queryForRowSet("select ma_code from makeserial left join make on ma_code=ms_makecode where ms_sncode=? and ma_prodcode=? and ma_wccode='103'",sn,prodcode);
        if(rs.next()){
            macode = rs.getGeneralString("ma_code");
        }else{
            return StepWorkApiResponse.failRsp("(WholeDeviceCode："+sn+"和DeviceType："+prodcode+"),未找到工作中心是组装的工单!");
        }

        // 解析配置字段列表
        Set<String> configFields = new HashSet<>();
        for (String field : paramCodes.split(",")) {
            configFields.add(field.trim().toUpperCase());
        }

        // 提取传入参数 key 转大写
        Map<String, Object> inputMap = new HashMap<>();
        for (Map.Entry<Object, Object> entry : map.entrySet()) {
            String key = entry.getKey().toString();
            if (!"DEVICETYPE".equalsIgnoreCase(key)) {
                inputMap.put(key.toUpperCase(), entry.getValue());
            }
        }

        // 1. 校验字段一致性：传入字段必须在配置列表中，配置字段必须全部传入且非空
        Set<String> inputFields = inputMap.keySet();
        for (String field : inputFields) {
            if (!configFields.contains(field)) {
                return StepWorkApiResponse.failRsp("传入个参字段[" + field + "]不在产品个参配置中！");
            }
        }
        for (String field : configFields) {
            Object value = inputMap.get(field);
            if (value == null || !StringUtil.hasText(value.toString())) {
                return StepWorkApiResponse.failRsp("产品个参设置字段[" + field + "]传入值为空，必须提供！");
            }
        }
        // 2. 动态构建查询条件，检查 PRODPARAMDATA 中是否存在一条记录与传入数据完全匹配
        StringBuilder sqlWhere = new StringBuilder(" where DeviceType=? and pd_makecode=? ");
        List<Object> params = new ArrayList<>();
        params.add(prodcode);
        params.add(macode);

        StringBuilder sqlWhere2 = new StringBuilder(" where DeviceType=? and pd_makecode=? ");
        List<Object> params2 = new ArrayList<>();
        params2.add(prodcode);
        params2.add(macode);
        String err ="";
         // 将配置的所有字段作为等值条件加入查询
        for (String field : configFields) {
            Object val = inputMap.get(field);
            // 传入值必非空（已校验），直接做等值匹配
            sqlWhere.append(" and ").append(field).append("=? ");
            params.add(val.toString());
            params2.add(val.toString());
            Integer pd_id = baseDao.getJdbcTemplate().queryForObject("select max(pd_id) from PRODPARAMDATA "+sqlWhere2 +" and "+field+"=? ",
                    Integer.class, params2.toArray()); // 根据实际 DAO 调整方法名
            if (null == pd_id || pd_id <= 0) {
                err += "个参-"+field+":"+val.toString()+"，错误不存在！";
            }
            params2.remove(2);
        }
        if(!"".equals(err)){
            return StepWorkApiResponse.failRsp(err);
        }

        String sql = "select max(pd_id) from PRODPARAMDATA " + sqlWhere.toString();
        Integer pd_id = baseDao.getJdbcTemplate().queryForObject(sql,Integer.class, params.toArray()); // 根据实际 DAO 调整方法名
        if (null != pd_id && pd_id > 0) {
            baseDao.execute("update PRODPARAMDATA set pd_checkcount=nvl(pd_checkcount,0)+1 where pd_id=?",pd_id);
        }else{
            return StepWorkApiResponse.failRsp("工单[" + macode + "]+产品["+prodcode+"]中传入数据组合与个参数据不匹配！");
        }
       // ========== 所有校验通过，写入日志 ==========
        long id = baseDao.getSeqId("PRODPARAMCHECKLOGGER_SEQ"); // 请确认序列名
        String inman = request.getSession().getAttribute("usercode").toString(); // 从 request 或 session 获取操作人，示例留空
        String sqlLog = "insert into prodparamchecklogger(pl_id, pl_indate, pl_inman, pl_sncode, pl_makecode, pl_prodcode) " +
                "values(?, sysdate, ?, ?, ?, ?)";
        baseDao.execute(sqlLog,id, inman,sn,macode,prodcode);
        baseDao.saveClob("prodparamchecklogger", "PL_INDATA",data, "pl_id=" + id);
        return new StepWorkApiResult(true,200,"SN:"+sn+",个参校对成功！");
    }

    /**
     * 工单绑定，工序检测
     *
     */
    private Map<String,Object> checkStep(String macode,String sourcecode,String sncode,String usercode,String stepcode ){
        Map<String,Object> map = new HashMap<>();
       /* String code = baseDao.getJdbcTemplate().queryForObject("select max(sc_code) from source where sc_code=? and sc_stepcode=?",
                String.class,sourcecode,stepcode);
        if(!StringUtil.hasText(code)){
            map.put("success",false);
            map.put("msg","工位："+sourcecode+"+工序："+stepcode+",在系统岗位资源中不存在！");
            return map;
        }*/
        List<String> list = new ArrayList<String>();
        /**
         *     v_i_macode  in varchar2 ,
         *     v_i_sourcecode in varchar2,
         *     v_i_sncode in varchar2,
         *     v_i_usercode in varchar2,
         *     v_o_macode out varchar2,
         *     v_o_msid out int,
         *     v_o_errmsg out varchar2
         */
        list = baseDao.callProcedureWithOut("CS_CHECKSTEPSNANDMACODE", new Object[]{
                macode, stepcode,sncode,usercode
        }, new Integer[]{1, 2, 3, 4}, new Integer[]{5, 6, 7});
        String msg = list.get(2);
        if(StringUtil.hasText(msg)){
            map.put("success",false);
            map.put("msg",msg);
        }else{
            map.put("success",true);
            map.put("macode",list.get(0));
            map.put("msid",list.get(1));
        }
        return map;

    }

    private boolean stepPassed(String iMakeCode, String iSourceCode, String iSN, String iUserCode, String iResult) {
        String msg = baseDao.callProcedure("CS_SETSTEPRESULT",
                iMakeCode,
                iSourceCode,
                iSN,
                iUserCode,
                iResult);
        if(StringUtil.hasText(msg)){
            throw new ApiStepWorkException(new StepWorkApiResult(false,400,msg));
        }else{
            return true;
        }
    }

    /**
     * 保存测试数据并且过站
     * @param macode
     * @param sccode //工位编号
     * @param sncode
     * @param isok
     * @param failureCode
     * @param machineTestData
     * "machineTestData":{
     * "machineCode":"JT001",
     * "titles":{
     * "芯片型号":"100",
     * "开机电流":"200",
     *"线损补偿":"300",
     * "输出功率":"400",
     * "测试时长":"500",
     * "测试结果":"600"},
     * "results":[{
     * "芯片型号":"XXC5121",
     * "开机电流":"9.438",
     * "线损补偿":"11.00",
     * "输出功率":"11.683",
     * "测试时长":"31.37",
     * "测试结果":"成功"
     * }]}
     */
    private void saveTestDataAndPassed(String macode, String sccode,String gwcode, String sncode, String isok, String failureCode,
                                       Object isinput,Object machineTestData,Object extendSequenceNumber,String usercode) {
        String result = isok;
        //保存测试数据
        Object machinecode = "";
        List<Map<Object,Object>> sqldata = new ArrayList<>();
        int mainid = baseDao.getSeqId("STEPTESTMAIN_SEQ");
        if(StringUtil.hasText(machineTestData)){
            Map<Object, Object> map = null;
            if (machineTestData instanceof Map) {
                map = (Map<Object, Object>) machineTestData;
            }else{
                map = BaseUtil.parseFormStoreToMap(machineTestData.toString());
            }
            if(!map.isEmpty()) {
                int detno=1;
                machinecode = map.containsKey("machineCode")?map.get("machineCode"):"";
                Object titles = map.get("titles");
                Object results = map.get("results");
                if(StringUtil.hasText(titles) && StringUtil.hasText(results)){
                   // SD_SN,SD_MAKECODE,SD_MACHINECODE,SD_INDATE,
                    Map<Object,Object> baseData = new HashMap<>() ;
                    baseData.put("SD_SN",sncode);
                    baseData.put("SD_MAKECODE",macode);
                    baseData.put("SD_MACHINECODE",machinecode);
                    baseData.put("SD_INDATE",DateUtil.parseDateToString(new Date(), Constant.YMD_HMS));
                    Map<String,Object> titledata = null;
                    if (machineTestData instanceof Map) {
                        titledata = (Map<String, Object>) titles;
                    }else{
                        titledata = FlexJsonUtil.fromJson(titles.toString());
                    }
                    List<Map<String,Object>> resultdata = null;
                    if (results instanceof List) {
                        resultdata = (List<Map<String,Object>>) results;
                    }else{
                        resultdata = FlexJsonUtil.fromJsonArray(results.toString(),HashMap.class);
                    }
                    for(Map<String,Object> m : resultdata){
                        Iterator<Map.Entry<String, Object>> iterator = titledata.entrySet().iterator();
                        baseData.put("SD_DETNO", detno);
                        detno++;
                        while (iterator.hasNext()) {
                            Map.Entry<String, Object> entry = iterator.next();
                            String key = entry.getKey();
                            Object value = entry.getValue();
                            Map<Object,Object> sqlm = new HashMap<>();
                            sqlm.putAll(baseData);
                            sqlm.put("SD_CLASS", key);
                            sqlm.put("SD_LENGTH", value);
                            sqlm.put("SD_SMID",mainid);
                            Object v = m.get(key);
                            sqlm.put("SD_ACTVALUE",v);
                            sqlm.put("SD_ID",null);
                            sqldata.add(sqlm);
                            //测试参数里面有值是失败，则整个结果需要更新成失败
                            if("结果".equals(key) && !"0".equals(v)){
                                result = "FAIL";
                            }
                        }
                    }
                }
            }
        }
        //测试项和测试结果不一致
        /**
         * insert into STEPTESTMAIN(SM_ID,SM_SN,SM_MAKECODE,SM_STEPCODE,SM_SCCODE,SM_RESULT,SM_BADCODE,SM_ISINPUT,SM_INDATE)
         * insert into STEPTESTDETAIL(SD_ID,SD_SMID,SD_SN,SD_MAKECODE,SD_MACHINECODE,SD_INDATE,SD_CLASS,SD_StandardVALUE,SD_ACTVALUE)
         */
        //插入数据
        String stepcode="",BgCode="";
        SqlRowList rs2 =  baseDao.queryForRowSet("select  st_code,st_badgroupcode from source left join step on sc_stepcode=st_code where sc_code=?",sccode);
        if(rs2.next()){
            stepcode =rs2.getGeneralString("st_code");
            BgCode = rs2.getGeneralString("st_badgroupcode");
        }
        baseDao.execute("insert into STEPTESTMAIN(SM_ID,SM_SN,SM_TSN,SM_MAKECODE,SM_STEPCODE,SM_SCCODE,SM_RESULT,SM_BADCODE,SM_ISINPUT,SM_INDATE,sm_machineCode,SM_SOURCETYPE,sm_sourceisok,sm_gwcode)" +
                "select ?,?,?,?,?,?,?,?,?,sysdate,?,'EIS',?,? from dual ",mainid,sncode,extendSequenceNumber,macode,stepcode,sccode,result,failureCode,isinput,machinecode,isok,gwcode);
        if(sqldata.size()>0){
            baseDao.execute(SqlUtil.getInsertSqlbyList(sqldata,"STEPTESTDETAIL","SD_ID"));
        }

       Object msstepcode = baseDao.getFieldDataByCondition("Makeserial", "ms_stepcode", "ms_sncode='" + sncode + "' and ms_makecode='" + macode + "'");
       Map<Object, Object> rmap = new HashMap<>();
       if ("FAIL".equals(result) && StringUtil.hasText(failureCode)) {
           //将历史的不良记录更新状态
           baseDao.execute("update makebad set mb_status=-1 where mb_sncode=? and mb_makecode=? and mb_stepcode=? and mb_status=0", sncode, macode);

           if("GX0030".equals(stepcode)) {  //只是这道工序需要这样
               int cn = baseDao.getJdbcTemplate().queryForObject(" select count(1) from MAKEBADCOUNT_USING " +
                       " where mbc_sncode=? and mbc_stepcode=? and nvl(mbc_status,0)=0", Integer.class, sncode, stepcode);
               if (cn == 0) {
                   //如果当前工序是第一次不良则不过站
                   baseDao.execute("insert into MAKEBADCOUNT_USING(mbc_id,mbc_sncode,mbc_stepcode,mbc_status,mbc_indate) " +
                           " values(MAKEBADCOUNT_USING_seq.nextval,?,?,0,sysdate)", sncode, stepcode);
                   throw new ApiStepWorkException(new StepWorkApiResult(false,400,"上传MES失败，第一次不良！"));
               } else {
                   //多个不良代码是用逗号分割的
                   String[] badcode = failureCode.split(",");
                   for (String item : badcode) {
                       baseDao.execute("insert into makebad(mb_id,mb_makecode,mb_mscode,mb_sncode,mb_inman,mb_indate,mb_stepcode,mb_sourcecode,mb_badcode,mb_badtable,mb_bgcode,mb_soncode,mb_status)" +
                               " select makebad_seq.nextval,ma_code,ms_code,ms_sncode,'EIS对接',sysdate,?,?,?,'',?,sp_soncode,0 from make left join makeserial on ms_makecode=ma_code left join " +
                               " stepproduct on sp_mothercode=ma_prodcode and sp_stepcode=ms_nextstepcode where ms_sncode=? and ms_makecode=?", stepcode, sccode, item, BgCode, sncode, macode);
                   }
                   //将不良的序列号的状态码设为3
                   baseDao.execute("update makeserial set ms_status='3' where ms_sncode=? and ms_makecode=?", sncode, macode);
                   stepPassed(macode, sccode, sncode, usercode, "NG");
               }
           }else{
               //多个不良代码是用逗号分割的
               String[] badcode = failureCode.split(",");
               for (String item : badcode) {
                   baseDao.execute("insert into makebad(mb_id,mb_makecode,mb_mscode,mb_sncode,mb_inman,mb_indate,mb_stepcode,mb_sourcecode,mb_badcode,mb_badtable,mb_bgcode,mb_soncode,mb_status)" +
                           " select makebad_seq.nextval,ma_code,ms_code,ms_sncode,'EIS对接',sysdate,?,?,?,'',?,sp_soncode,0 from make left join makeserial on ms_makecode=ma_code left join " +
                           " stepproduct on sp_mothercode=ma_prodcode and sp_stepcode=ms_nextstepcode where ms_sncode=? and ms_makecode=?", stepcode, sccode, item, BgCode, sncode, macode);
               }
               //将不良的序列号的状态码设为3
               baseDao.execute("update makeserial set ms_status='3' where ms_sncode=? and ms_makecode=?", sncode, macode);
               stepPassed(macode, sccode, sncode, usercode, "NG");
           }
       } else {
           //不良采集为良品是更新
             if (msstepcode!=null && msstepcode.toString().equals(stepcode) && result == "PASS") {
                Object[] ob = baseDao.getFieldsDataByCondition("makeserial", "ms_status,ms_craftcode,ms_prodcode", "ms_sncode='" + sncode + "' and ms_makecode='" + macode + "'");
                if (ob!=null){
                    String ms_status =ob[0].toString();
                    String ms_craftcode= ob[1].toString();
                    String ms_prodcode = ob[2].toString();
                    if (ms_status == "3") {
                        String nextstepcode =baseDao.getFieldDataByCondition("craft left join  craftdetail on cr_id=cd_crid ", "cd_nextstepcode", "cr_code='" + ms_craftcode + "' and cr_prodcode='" + ms_prodcode + "' and cd_stepcode='" + stepcode + "'").toString();
                        baseDao.updateByCondition("makeserial", "ms_status=1,ms_nextstepcode='" + nextstepcode + "'", "ms_sncode='" + sncode + "' and ms_makecode='" + macode + "'");
                        baseDao.updateByCondition("makebad", "mb_status=-1", "mb_sncode='" + sncode + "' and mb_makecode='" + macode + "'");
                        baseDao.updateByCondition("MAKEBADCOUNT_USING","mbc_status=-1","mbc_sncode='"+sncode+"' and mbc_stepcode='"+stepcode+"' and nvl(mbc_status,0)=0");
                    }
                }
            }
            baseDao.updateByCondition("MAKEBADCOUNT_USING","mbc_status=-1","mbc_sncode='"+sncode+"' and mbc_stepcode='"+stepcode+"' and nvl(mbc_status,0)=0");
           //转号：CS_SNCHANGEANDBURN,两个号一样不需要转号，实际就是返修工单m不需要转号
           if (StringUtil.hasText(extendSequenceNumber) && !sncode.equals(extendSequenceNumber) && "PASS".equals(result)) {
               snChange(macode, sccode, sncode, extendSequenceNumber.toString(), usercode);
           } else {
               stepPassed(macode, sccode, sncode, usercode, "PASS".equals(result) ? "OK" : "NG");
           }
       }
    }

    //记录日志
    private void insertLogger(String data,String type){
        baseDao.execute("insert into EISDATA(ed_id,ed_data,ed_indate,ED_TYPE)" +
                "values(EISDATA_seq.nextval,?,sysdate,?)", data,type);
    }

    @Transactional
    public StepWorkApiResult<Map<String,Object>> testmain(HttpServletRequest request,String data){
        Map<Object,Object> map =  BaseUtil.parseFormStoreToMap(data);
        String macode = " ";
        if(StringUtil.hasText(map.get("workOrderNo"))){//工单号可填写可不填
            macode = map.get("workOrderNo").toString();
        }
        Object sccode = map.get("stationCode");
        if(!StringUtil.hasText(sccode)){
            return StepWorkApiResponse.failRsp(400,"工位编码（stationCode）不能为空！");
        }
        Object stepcode = map.get("routeCode");
        if(!StringUtil.hasText(stepcode)){
            return StepWorkApiResponse.failRsp(400,"工序编号（routeCode）不能为空！");
        }
        Object sncode = map.get("sequenceNumber");
        if(!StringUtil.hasText(sncode)){
            return StepWorkApiResponse.failRsp(400,"产品SN（sequenceNumber）不能为空！");
        }
        //测试结果
        Object isok = map.get("eventResult");  //测试结果：PASS(合格)，FAIL（不合格） 必填 ，测试强制合格有的时候也会有不良代码
        Object failureCode =map.get("failureCode");
        if(!StringUtil.hasText(isok)){
            return StepWorkApiResponse.failRsp(400,"测试结果（eventResult）不能为空！");
        }else{
            if(!"PASS".equals(isok) && !"FAIL".equals(isok)){
                return StepWorkApiResponse.failRsp(400,"测试结果值【"+isok+"】,只能是PASS或者FAIL！");
            }
            if("FAIL".equals(isok) && !StringUtil.hasText(failureCode)){
                return StepWorkApiResponse.failRsp(400,"测试结果为不合格,不良代码（failureCode）值必填！");
            }
        }
        /*if(StringUtil.hasText(failureCode)) {
            String bccode = baseDao.getJdbcTemplate().queryForObject("select max(bc_code) from badcode where bc_code=?", String.class, failureCode);//oErrMessage = "不良代码"+BadCode[i]+"不存在";
            if (null == bccode) {
                throw new ApiStepWorkException(new StepWorkApiResult(false, 400, "测试不良代码：" + failureCode + "在MES系统不存在!"));
            }
        }*/
        String usercode = String.valueOf(request.getSession().getAttribute("usercode"));
        //工序校验
        Map<String,Object> remap =  checkStep(macode,sccode.toString(),sncode.toString(),usercode,stepcode.toString());
        if(Boolean.valueOf(remap.get("success").toString())){
            //指定返修：2025120011，不需要校验，如果有转号 map.get("extendSequenceNumber")，限制转号跟原来的要不一样，判断前6位
            //增加并且结果是良品的时候才需要校验
            if(!"2025120011".equals(remap.get("macode").toString()) && StringUtil.hasText(map.get("extendSequenceNumber"))
                    && (sncode.equals(map.get("extendSequenceNumber"))
                        || (sncode.toString().length()>6 && map.get("extendSequenceNumber").toString().length()>6
                        && sncode.toString().startsWith(map.get("extendSequenceNumber").toString().substring(0, Math.min(map.get("extendSequenceNumber").toString().length(),6))))
                       )
                    && "PASS".equals(isok)
            ){
                return StepWorkApiResponse.failRsp(400,"转号(extendSequenceNumber)【"+map.get("extendSequenceNumber")+"】" +
                        " 和产品序列号（sequenceNumber)【"+sncode+"】不能一样！");
            }
            //工序保存测试数据并且过站
            //刚采集过当前工序，不允许再次采集
            String mscode = baseDao.getJdbcTemplate().queryForObject("select wm_concat(ms_sncode) from source left join makeserial on ms_stepcode=sc_stepcode where ms_id=? and sc_code=? and nvl(ms_nextstepcode,' ')<>' ' and ms_status=1",String.class,remap.get("msid"),stepcode.toString());
            if(StringUtil.hasText(mscode)){
                return StepWorkApiResponse.successRsp(400, "【" + sncode + "】序列号工序【"+stepcode+"】已经过站，请勿重复过站!");
            }
            saveTestDataAndPassed(remap.get("macode").toString(),stepcode.toString(),sccode.toString(),sncode.toString(),
                    isok.toString(),failureCode.toString(),map.get("isinput"),map.get("machineTestData"),
                    map.get("extendSequenceNumber"),usercode);
            return StepWorkApiResponse.successRsp(200,"【"+sncode+"】产品序列号过站成功!");
        }else{
            return StepWorkApiResponse.failRsp(400,remap.get("msg").toString());
        }
    }

    @Transactional
    public StepWorkApiResult<Map<String,Object>> stationmain(HttpServletRequest request ,String data) {
        Map<Object, Object> map = BaseUtil.parseFormStoreToMap(data);
        String macode = " ";
        if (StringUtil.hasText(map.get("workOrderNo"))) {//工单号可填写可不填
            macode = map.get("workOrderNo").toString();
        }
        Object sccode = map.get("stationCode");
        if (!StringUtil.hasText(sccode)) {
            return StepWorkApiResponse.failRsp(400, "工位编码（stationCode）不能为空！");
        }
        Object stepcode = map.get("routeCode");
        if (!StringUtil.hasText(stepcode)) {
            return StepWorkApiResponse.failRsp(400, "工序编号（routeCode）不能为空！");
        }
        Object sncode = map.get("sequenceNumber");
        if (!StringUtil.hasText(sncode)) {
            return StepWorkApiResponse.failRsp(400, "产品SN（sequenceNumber）不能为空！");
        }
        String usercode = String.valueOf(request.getSession().getAttribute("usercode"));
        Map<String, Object> remap = checkStep(macode, sccode.toString(), sncode.toString(), usercode,stepcode.toString());
        if (Boolean.valueOf(remap.get("success").toString())) {
            //刚采集过当前工序，不允许再次采集
            String mscode = baseDao.getJdbcTemplate().queryForObject("select wm_concat(ms_sncode) from source left join makeserial on ms_stepcode=sc_stepcode where ms_id=? and sc_code=?",String.class,remap.get("msid"),stepcode.toString());
            if(StringUtil.hasText(mscode)){
                return StepWorkApiResponse.successRsp(400, "【" + sncode + "】序列号工序【"+stepcode+"】已经过站，请勿重复过站!");
            }
            stepPassed(remap.get("macode").toString(), stepcode.toString(), sncode.toString(), usercode, "OK");
            return StepWorkApiResponse.successRsp(200, "【" + sncode + "】产品序列号过站成功!");
        } else {
            return StepWorkApiResponse.failRsp(400, remap.get("msg").toString());
        }
    }

    private boolean snChange(String iMakeCode, String iSourceCode, String tsn,String iSN, String iUserCode) {
        //v_i_ifrechange in number default 0,-- 标识是否重复转号 0否,1是
        String msg = baseDao.callProcedure("CS_SNCHANGEANDBURN",
                tsn,iSN,iSourceCode,iUserCode,iMakeCode,0,
                  null,null,null,null,null,
                  iSN,null,null,null,null,null,null,null,null
              );
        if(StringUtil.hasText(msg)){
            throw new ApiStepWorkException(new StepWorkApiResult(false,400,msg));
        }else{
            return true;
        }
    }

      /* SqlRowList rs=baseDao.queryForRowSet("select nvl(st_ifinput,0)st_ifinput,nvl(st_ifoqc,0)st_ifoqc,nvl(st_ifweigh,0)st_ifweigh from "+Master+".source left join "+Master+".step on sc_stepcode=st_code where sc_code='"+iResCode+"'");
        if(rs.next()){
            String st_ifinput=rs.getString("st_ifinput");
            String st_ifoqc=rs.getString("st_ifinput");
            String st_ifweigh=rs.getString("st_ifweigh");
            if(st_ifinput.equals("-1")){
                oErrMessage = "上料工序必须在客户端进行过站";
                rmap.put("oErrMessage",oErrMessage);
                return rmap;
            }
            if(st_ifoqc.equals("-1")){
                oErrMessage = "OQC必须在客户端进行过站";
                rmap.put("oErrMessage",oErrMessage);
                return rmap;
            }
            if(st_ifweigh.equals("-1")){
                oErrMessage = "称重工序必须在客户端进行过站";
                rmap.put("oErrMessage",oErrMessage);
                return rmap;
            }
        }*/

}