import dependencies.*;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.Element;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

public class VerifierImpl implements Verifier {
    MessageDispatcher messageDispatcher = null;
    Request request = null;
    final static SimpleCalculator calc = new SimpleCalculator();
    Convert convert = null;
    private static Logger logger = Logger.getLogger(VerifierImpl.class);
    Document document = null;
    XMLType type = null;
    boolean ommFlag = false;
    private static boolean simpleMOFlag = false;

    @Override
    public boolean verify(Document document, Request request, boolean ommFlag, HashMapString, String subnetAndMeIDMap,
                          HashMapString, String eNodeBIdTddMap, HashMapString, String eNodeBIdFddMap) {
        boolean flag = true;
        try {
            init(document, request, ommFlag);
            AttributeList attributeList = request.getAttributeList();
            MapString, FieldInfoObject mocInfoMap = SystemConfigLoader.getInstance().getMocinfoObj().getMocinfo();

            //判断XML模板的类型
            if (isNotIlegalDocument(document, request)) return false;
            //{{{判断userlabel是否符合规则length=128, not include /  : * ? "   | ;
            flag = checkUserLabel(request.getUserLabel());
            String eNodeBTdd = null, eNodeBFdd = null;
            //List all items to verify them, according to excel column order.
            for (String excelHeader : SystemConfigLoader.getInstance().getExcelheaders()) {
                String excelValue = attributeList.get(excelHeader);
                String xpath = convert.getMocinfoXpath(excelHeader);
                String excelName = processExcelName(excelHeader);
                String radioMode = processRadioMode(excelHeader);
                //1.检查Excel值是否为空
                if (StringUtils.isBlank(excelValue)) {
                    //当XML的类型为OMMB时，判断子网id和网元id是否为空，若为空，报错并继续检查
                    flag = preCheckExcelName(excelHeader, excelValue, excelName);
                    continue;
                }
                //2.检查文件头是否被修改过
                if (isExcelChanged(excelHeader, xpath)) return false;
                //3.校验数据格式是否满足数组格式要求
                //3.1当preCheck未通过时,忽略下面的检查
                if (!preCheckExcelName(excelHeader, excelValue, excelName, radioMode)) {
                    flag = false;
                    continue;
                }
                String field = convertExcelName(excelHeader);
                //3.3检查同一基站下小区ID是否重复
                flag = isExistCellId(document, request, flag, excelHeader, excelValue, field);
                if (field.contains("eNodeB ID")) {
                    if (StringUtils.contains(xpath, "ENBFunctionFDD")) {
                        eNodeBFdd = excelValue;
                    } else if (StringUtils.contains(xpath, "ENBFunctionTDD")) {
                        eNodeBTdd = excelValue;
                    }
                }

                //5.检查枚举值类型数据是否符合规则
                FieldInfoObject fieldInfoObj = mocInfoMap.get(xpath);
                flag = chekCombo(flag, excelHeader, excelValue, fieldInfoObj);
                //6.检查IP类型的数据是否符合规则
                if (StringUtils.equals(fieldInfoObj.getWsfComponent(), "IP")) {
                    flag = checkIP(excelHeader, excelValue) && flag;
                }
                //7.检查引用的数据是否符合规则
                else if (fieldInfoObj.isRef()) {
                    flag = checkRef(flag, attributeList, excelHeader, excelValue, xpath);
                }
                //8.检查atmAddr这个字段的每个元素是否在range之间
                else if (isAtmAddr(xpath)) {
                    flag = checkAtmAddr(flag, excelHeader, excelValue, fieldInfoObj);
                }
                //9.如果是VLAN Parameters，检查VLAN标识是否重复
                else if (isEthernetLinkVlanId(excelHeader)) {
                    flag = checkVLANPara(excelHeader, excelValue) && flag;
                }
                //10.列：VLAN Parameters  VLAN参数。以太网链路所包含的VLAN标识列表不能重复
                else if (IsVlanIdForIp(excelHeader)) {
                    flag = checkVLANID(request, excelHeader, excelValue) && flag;
                }
                //MP priority有多个取值范围，配置文件里填了最大的范围，其他需要代码特殊处理判断
                else if (isMpPriority(excelHeader)) {
                    flag = checkMPpriority(excelValue) && flag;
                }
                //11.检查数字类型的字段是否符合其定义的规则
                else if (isIlegalField(field)) {
                    flag = checkNumber(type, fieldInfoObj, attributeList, excelHeader) && flag;
                } else {
                    continue;
                }
            }
            //flag = checkSubnetAndMeID(subnetAndMeIDMap, subnetID, meID) && flag;
            if (eNodeBTdd != null) {
                flag = checkeNodeBIDTDD(eNodeBIdTddMap, eNodeBTdd) && flag;
            }
            if (eNodeBFdd != null) {
                flag = checkeNodeBIDFDD(eNodeBIdFddMap, eNodeBFdd) && flag;
            }
            XMLUtility.addNullPara(document);
        } catch (Exception e) {
            logger.error("Verify Error!", e);
        }
        return flag;
    }

    private boolean isNotIlegalDocument(Document document, Request request) {
        if (isUnknownXMLType(document, request)) {
            return true;
        }
        if (!XMLUtility.isContainedHeader(document)) {
            processLmtHeadIllegalMessage(request);
            return true;
        }
        return false;
    }

    private boolean isIlegalField(String field) {
        return !field.equals("eNodeB UserLabel") && !field.equals("Cell UserLabel") && !field.equals("eNodeB Name")
                && !field.equals("User Defined NE ID") && !field.equals("Cell Alias");
    }

    private boolean isMpPriority(String excelHeader) {
        return excelHeader.contains("MP priority");
    }

    private boolean IsVlanIdForIp(String excelHeader) {
        return excelHeader.contains("VLAN ID For IP");
    }

    private boolean isEthernetLinkVlanId(String excelHeader) {
        return excelHeader.contains("EthernetLink VLAN ID MerberShip");
    }

    private boolean isAtmAddr(String xpath) {
        return StringUtils.contains(xpath, "atmAddr");
    }

    private boolean checkAtmAddr(boolean flag, String excelHeader, String excelValue, FieldInfoObject fieldInfoObj) {
        String[] atmAddr = this.split(excelValue);
        for (String str : atmAddr) {
            int errorCode = ValidateUtility.fieldDataByRule(str, fieldInfoObj.getWsfRange(), fieldInfoObj.getType());
            if (errorCode != ValidateUtility.VALUE_OK) {
                numberErrorMessage(errorCode, excelHeader, excelValue, fieldInfoObj.getWsfRange(), fieldInfoObj.getType(), fieldInfoObj.getWsfStepSize());
                flag = false;
                break;
            }
        }
        return flag;
    }

    private boolean checkRef(boolean flag, AttributeList attributeList, String excelHeader, String excelValue, String xpath) {
        if (StringUtils.contains(xpath, "refPlmn")) {
            flag = this.checkPLMN(excelHeader, excelValue) && flag;
        } else if (StringUtils.contains(xpath, "vid")) {
            //检查VID参数相关约束
            flag = checkVid(excelHeader, excelValue, xpath, attributeList) && flag;
        } else if (excelHeader.contains("Used HDLC channel")) {
            //检查HDLC参数相关约束
            flag = checkHdlc(excelHeader, attributeList) && flag;
        }
        return flag;
    }

    private boolean chekCombo(boolean flag, String excelHeader, String excelValue, FieldInfoObject fieldInfoObj) {
        if (StringUtils.equals(fieldInfoObj.getWsfComponent(), "ComboBox") && !fieldInfoObj.isRef()) {
            return checkCombo(fieldInfoObj, excelHeader, excelValue) && flag;
        }
        return flag;
    }

    private String convertExcelName(String excelHeader) {
        return StringUtils.substringBetween(excelHeader, "@excelName='", "']");
    }

    private boolean isExistCellId(Document document, Request request, boolean flag, String excelHeader, String value, String field) {
        if (field.contains("Cell Identity") || field.contains("Local Cell Identity")) {
            flag = checkCellID(value) && flag;
        }
        if (!field.equals("eNodeB UserLabel") && !field.equals("Cell UserLabel") && !field.equals("eNodeB Name") && !field.equals("Cell Alias")) {
            //4.1)校验记录条数是否一致
            //  2)检查属性为可以修改的字段值是否与XML中一致
            //  3)Userlabel不是必填字段，excel中可以为空，因此不做记录数检验。
            flag = checkRecordsNumber(type, request.getQuoteTemplateName(), document, excelHeader, value) && flag;
        }
        return flag;
    }

    private String processRadioMode(String excelHeader) {
        if (excelHeader.contains("TDD")) {
            return "TDD-LTE ";
        } else if (excelHeader.contains("FDD")) {
            return "FDD-LTE ";
        } else {
            return "";
        }
    }

    private boolean preCheckExcelName(String excelHeader, String value, String excelName) {
        if (excelName.contains("Subnetwork ID")) {
            processSubNetworkIllegalMessage(excelHeader, value);
            return false;
        }

        if (excelName.equals("ME ID")) {
            processMeIllegalMessage(excelHeader, value);
            return false;
        }
        return true;
    }

    private boolean preCheckExcelName(String excelHeader, String value, String excelName, String radioMode) {
        //当数据为cell userlabel时，按照userlabel的范围检测
        if (excelName.contains("eNodeB UserLabel") || excelName.contains("Cell UserLabel") || excelName.contains("Cell Alias")) {
            return this.checkUserLabel(value, radioMode + excelName);
        } else if (excelName.contains("eNodeB Name")) {
            return this.checkeNbName(value);
        } else {
            return preCheckExcelName(excelHeader, value);
        }
    }

    private boolean isExcelChanged(String excelHeader, String xpath) {
        if (StringUtils.isEmpty(xpath)) {
            //node[@radioMode='UMTS']/property[@excelName='Local Cell Identity']
            //截取出字段
            String field = StringUtils.substringBetween(excelHeader, "@excelName='", "']");
            processExcelChangedMessage(field);
            return true;
        }
        return false;
    }

    private boolean isUnknownXMLType(Document document, Request request) {
        //当模板类型未知时，发送消息
        if (type == XMLType.UNKNOWN) {
            processXMLTypeUnknownMessage(request);
            return true;
        }
        return false;
    }

    private void processExcelChangedMessage(String field) {
        String details = I18N.getFormatString(I18NC.VERIFY_EXCEL_CHANGED, field);
        String suggestion = I18N.getString(I18NC.VERIFY_EXCEL_CHANGED_SUG);
        sendMessage(details, suggestion);
    }

    private void processMeIllegalMessage(String excelHeader, String value) {
        String details = I18N.getFormatString(I18NC.VERIFY_ME_NULL_ILLEGAL, processExcelName(excelHeader), value);
        String suggestion = I18N.getFormatString(I18NC.VERIFY_ME_NULL_SUG, processExcelName(excelHeader));
        sendMessage(details, suggestion);
    }

    private void processSubNetworkIllegalMessage(String excelHeader, String value) {
        String details = I18N.getFormatString(I18NC.VERIFY_SUBNETWORKID_NULL_ILLEGAL, processExcelName(excelHeader), value);
        String suggestion = I18N.getFormatString(I18NC.VERIFY_SUBNETWORKID_NULL_SUG, processExcelName(excelHeader));
        sendMessage(details, suggestion);
    }

    private void processLmtHeadIllegalMessage(Request request) {
        String details = I18N.getFormatString(I18NC.VERIFY_LMTHEAD_ILLEGAL, request.getQuoteTemplateName());
        String suggestion = I18N.getString(I18NC.VERIFY_LMTHEAD_ILLEGAL_SUG);
        sendMessage(details, suggestion);
    }

    private void processXMLTypeUnknownMessage(Request request) {
        String details = I18N.getFormatString(I18NC.VERIFY_XMLTYPE_UNKNOWN, request.getQuoteTemplateName());
        String suggestion = I18N.getString(I18NC.VERIFY_XMLTYPE_UNKNOWN_SUG);
        sendMessage(details, suggestion);
    }

    private void delNullParas(Document document) {
        if (type == XMLType.OMMB) {
            XMLUtility.delNullParas(document);
        }
    }

    private void init(Document document, Request request, boolean ommFlag) {
        initField(document, request, ommFlag);
        SimpleMo.initMoName(simpleMOFlag);
        delNullParas(document);
    }

    private void initField(Document document, Request request, boolean ommFlag) {
        this.request = request;
        this.document = document;
        if (XMLUtility.isXMLSimpleType(document)) {
            simpleMOFlag = true;
        } else {
            simpleMOFlag = false;
        }
        this.ommFlag = ommFlag;
        messageDispatcher = SystemConfigLoader.getInstance().getMsgDispatcher();
        convert = SystemConfigLoader.getInstance().getConvert();
        type = XMLUtility.detectXMLType(document);
    }

    private boolean checkRecordsNumber(XMLType type, String xmlTemplate, Document document, String key, String value) {
        int elemCount = 0;
        //Excel中的数据
        String[] values = StringUtils.split(value, ";");
        //{{{增加缓存机制，加快记录条数校验的效率
        Cache cache = Cache.getInstance();
        Integer recordNumber = (Integer) cache.get(xmlTemplate, key);
        String valueNumbers = (String) cache.get(xmlTemplate, key + "Count");
        if (recordNumber != null) {
            elemCount = recordNumber;
        } else {
            String xpath = convert.getFastConfigXpath(key, type);
            if (simpleMOFlag) {
                xpath = SimpleMo.convertXpath(xpath);
            }
            List? elemList = document.selectNodes(xpath);
            elemCount = elemList.size();
            cache.put(xmlTemplate, key, elemCount);
            List? valueNodeList = document.selectNodes(xpath + "/" + SimpleMo.getValue());
            if (valueNodeList.size() != 0) {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i  elemCount; i++) {
                    Element elemTmp = (Element) elemList.get(i);
                    List? children = elemTmp.elements(SimpleMo.getValue());
                    int branchCount = children.size();
                    sb.append(i == elemCount - 1 ? branchCount : branchCount + ";");
                }
                valueNumbers = sb.toString();
                cache.put(xmlTemplate, key + "Count", sb.toString());
            }
            //判断元素的数量,当其有孩子节点/value的时候,数量设置为孩子节点的数量
            //elemCount = valueNodeList.size() == 0 ? elemList.size() : valueNodeList.size();
            //cache.put(xmlTemplate, key, elemCount);
            //如果不可以修改，则搜寻xml中的值
            if (!convert.isEditable(key)) {
                String tmpValues = "";
                //将XML中的数据读取出来,以a;a;a的方式存储
                if (elemList.size() != 0) {
                    for (int i = 0; i  elemList.size(); i++) {
                        Element tmp = (Element) elemList.get(i);
                        tmpValues = tmpValues + tmp.attributeValue(SimpleMo.getValue()) + ";";
                    }
                } else {
                    for (int i = 0; i  valueNodeList.size(); i++) {
                        Element tmp = (Element) valueNodeList.get(i);
                        tmpValues = tmpValues + tmp.getText() + ";";
                    }
                }
                //将此值保存到缓存中
                cache.put(xmlTemplate, key + "Values", StringUtils.substring(tmpValues, 0, -1));
            }
        }
        //}}}
        //判断excel中的记录数与xml文件的中是否一致
        if (elemCount != values.length) {
            String details = I18N.getFormatString(I18NC.VERIFY_NUMBER_INCONSIST, values.length, processExcelName(key), value, elemCount);
            String suggestion = I18N.getString(I18NC.VERIFY_NUMBER_INCONSIST_SUG);
            sendMessage(details, suggestion);
            return false;
        }
        //判断excel中一条记录的子记录是否一致
        if (valueNumbers != null) {
            String[] countArray = StringUtils.split(valueNumbers, ";");
            String[] valueCount = new String[values.length];
            for (int i = 0; i  values.length; i++) {
                valueCount[i] = StringUtils.split(values[i], ",").length + "";
            }
            for (int i = 0; i  elemCount; i++) {
                if (!StringUtils.equals(countArray[i], valueCount[i])) {
                    String details = I18N.getFormatString(I18NC.VERIFY_NUMBER_INCONSIST, valueCount[i], processExcelName(key), values[i],
                            countArray[i]);
                    String suggestion = I18N.getString(I18NC.VERIFY_NUMBER_INCONSIST_SUG);
                    sendMessage(details, suggestion);
                    return false;
                }
            }
        }
        //当字段不许修改时
        if (!convert.isEditable(key)) {
            String xmlValues = (String) cache.get(xmlTemplate, key + "Values");
            if (!StringUtils.equals(xmlValues, value)) {
                String details = I18N.getFormatString(I18NC.VERIFY_NOTWRITABLE, processExcelName(key), xmlValues, value);
                String suggestion = I18N.getFormatString(I18NC.VERIFY_NOTWRITABLE_SUG, xmlValues);
                sendMessage(details, suggestion);
                return false;
            }
        }
        return true;
    }

    /**
     * 预先检查每一个字段的值，是否正常的数组类型，确保Excel中的数据均为可以";"
     * 分解，而并不会出现空值
     *
     * @param value
     */
    private boolean preCheckExcelName(String key, String value) {
        if (StringUtils.isBlank(value)) {
            return true;
        }
        //match  1;2;3 or 1,2;1,3,4
        //not match ;1;2;3 or ,1,2
        String regex = "[-?\w\.]+((;|,)[-?\w\.]+)*";
        Pattern p = Pattern.compile(regex);
        if (!p.matcher(value).matches()) {
            String details = I18N.getFormatString(I18NC.VERIFY_FORMAT_ILLEGAL, processExcelName(key), value);
            String suggestion = I18N.getFormatString(I18NC.VERIFY_FORMAT_ILLEGAL_SUG, processExcelName(key));
            sendMessage(details, suggestion);
            return false;
        }
        return true;
    }

    /**
     * 检查字段是否在枚举值取值范围之中
     *
     * @param obj
     * @param key
     * @param value
     * @return
     */
    private boolean checkCombo(FieldInfoObject obj, String key, String value) {
        String[] excelValues = StringUtils.split(value, ";");
        if (StringUtils.contains(obj.getValueMap(), ":")) {
            String[] keyValues = StringUtils.split(obj.getValueMap(), ",");
            StringBuilder sb = new StringBuilder(50);
            for (int i = 0; i  excelValues.length; i++) {
                boolean flag = false;
                for (int j = 0; j  keyValues.length; j++) {
                    //here we should make sure that equals not contains
                    if (StringUtils.substringAfter(keyValues[j], ":").equals(excelValues[i])) {
                        sb.append(StringUtils.substringBefore(keyValues[j], ":") + ";");
                        flag = true;
                        break;
                    }
                }
                if (flag == false) {
                    String details = I18N.getFormatString(I18NC.VERIFY_COMBO_ILLEGAL, processExcelName(key), value);
                    String suggestion = I18N.getFormatString(I18NC.VERIFY_COMBO_ILLEGAL_SUG, processExcelName(key));
                    sendMessage(details, suggestion);
                    return false;
                }
                request.getAttributeList().put(key, sb.substring(0, sb.length() - 1));
            }
        } else {
            for (int i = 0; i  excelValues.length; i++) {
                int errorCode = ValidateUtility.fieldDataByRule(excelValues[i], obj.getWsfRange(), obj.getType());
                if (errorCode != ValidateUtility.VALUE_OK) {
                    numberErrorMessage(errorCode, key, value, obj.getWsfRange(), obj.getType(), obj.getWsfStepSize());
                    return false;
                }
            }
        }
        return true;
    }

    private boolean checkIP(String key, String value) {
        String[] values = StringUtils.split(value, ";");
        for (String ips : values) {
            String[] ipArr = StringUtils.split(ips, ",");
            for (String ip : ipArr) {
                if (!ValidateUtility.isValidIP(ip)) {
                    String details = I18N.getFormatString(I18NC.VERIFY_IP_ILLEGAL, processExcelName(key), value);
                    String suggestion = I18N.getFormatString(I18NC.VERIFY_IP_ILLEGAL_SUG, processExcelName(key));
                    sendMessage(details, suggestion);
                    return false;
                }
                // 增加约束
                // IP Address  OMC Server IP Address SCTP远端地址 地址不能为0.0.0.0
                // node[@radioMode='UMTS']/property[@excelName='Local Cell Identity']
                String field = processExcelName(key);
                if (field.equals("IP Address") || field.equals("OMC Server IP Address") || field.equals("Remote IP Address")) {
                    if (ip.equals("0.0.0.0")) {
                        String details = I18N.getFormatString(I18NC.VERIFY_IP_ILLEGAL_ALL_ZERO, field, value);
                        String suggestion = I18N.getFormatString(I18NC.VERIFY_IP_ILLEGAL_ALL_ZERO_SUG, field);
                        sendMessage(details, suggestion);
                        return false;
                    }
                }
            }
        }
        return true;
    }

    /**
     * 数值范围校验，OMMB界面值，LMT 内存值
     *
     * @param obj
     * @param attributeList
     * @param key
     * @return
     */
    private boolean checkNumber(XMLType type, FieldInfoObject obj, AttributeList attributeList, String key) {
        String numberRegex = "(-?)(\d+\.*\d*)(,\d+\.*\d*)*(;(-?)(\d+\.*\d*)(,\d+\.*\d*)*)*";
        String value = attributeList.get(key);
        String[] excelValues = StringUtils.split(value, ";");
        if (!value.matches(numberRegex)) {
            String details = I18N.getFormatString(I18NC.VERIFY_NUMBER_FORMAT_ERR, processExcelName(key), value);
            String suggestion = I18N.getFormatString(I18NC.VERIFY_NUMBER_FORMAT_ERR_SUG, processExcelName(key));
            sendMessage(details, suggestion);
            return false;
        }
        //{{拆分1,2;3,4合并成为{1,2,3,4}
        String temp[] = null;
        for (String tmp : excelValues) {
            temp = ArrayUtils.addAll(temp, StringUtils.split(tmp, ","));
        }
        excelValues = temp;
        //1.wsfformat为空时，无转换关系
        if (StringUtils.isEmpty(obj.getWsfFormat())) {
            for (String singleValue : excelValues) {
                int errorCode = ValidateUtility.fieldDataByRule(singleValue, obj.getWsfRange(), obj.getType());
                if (errorCode != ValidateUtility.VALUE_OK) {
                    numberErrorMessage(errorCode, key, value, obj.getWsfRange(), obj.getType(), obj.getWsfStepSize());
                    return false;
                }
                if (Integer.parseInt(singleValue) % Integer.parseInt(obj.getWsfStepSize()) != 0) {
                    numberErrorMessage(ValidateUtility.VALUE_STEP_INVALID, key, value, obj.getWsfRange(), obj.getType(), obj.getWsfStepSize());
                    return false;
                }
            }
        }
        //2.当wsfformat以"{"开头时，表明本此段存在对应转换关系
        else if (StringUtils.contains(obj.getWsfFormat(), "{")) {
            ListString[] wsfRangeList = obj.getWsfRangeList();
            MapString, String rangeMap = new HashMapString, String();
            for (String wsfRange[] : wsfRangeList) {
                rangeMap.put(wsfRange[1], wsfRange[2]);
            }
            ListString[] xyConvertList = obj.getXyConvert();
            MapString, String convertMap = new HashMapString, String();
            for (String[] xyConvert : xyConvertList) {
                convertMap.put(xyConvert[1], xyConvert[2]);
            }
            //获取其需要引用的字段
            String refField = wsfRangeList.get(0)[0];
            String refFieldKey = convert.getRefFieldKey(obj.getMocName(), refField);
            String refFieldValue = attributeList.get(refFieldKey);
            String[] refFieldValueArray = StringUtils.split(refFieldValue, ";");
            if (excelValues.length != refFieldValueArray.length) {
                String details = I18N.getFormatString(I18NC.VERIFY_REF_COUNT_ILLEGAL, processExcelName(key), value, processExcelName(refFieldKey));
                String suggestion = I18N.getFormatString(I18NC.VERIFY_REF_COUNT_ILLEGAL_SUG, processExcelName(key));
                sendMessage(details, suggestion);
                return false;
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i  excelValues.length; i++) {
                //获取对应的取值范围
                String range = rangeMap.get(refFieldValueArray[i]);
                //如果发现range为空，则表明再校验range的时候出现错误
                //则不进行对应频点的校验
                if (StringUtils.isEmpty(range)) {
                    continue;
                }
                int errorCode = ValidateUtility.checkStepSize(excelValues[i], obj.getWsfStepSize(), range, obj.getType());

                if (errorCode == ValidateUtility.VALUE_OK) {
                    sb.append(calc.getXYConvert(convertMap.get(refFieldValueArray[i]), excelValues[i]) + ";");
                } else {
                    numberErrorMessage(errorCode, key, value, obj.getWsfRange(), obj.getType(), obj.getWsfStepSize());
                    return false;
                }
            }
            //LMT需要进行内存值与显示值转换
            if (sb.length() != 0 && type == XMLType.LMT) {
                request.getAttributeList().put(key, sb.substring(0, sb.length() - 1));
            }
        }
        //3.其余情况只有一种转换关系
        else {
            StringBuilder sb = new StringBuilder();
            for (String singleValue : excelValues) {
                int errorCode = ValidateUtility.checkStepSize(singleValue, obj.getWsfStepSize(), obj.getWsfRange(), obj.getType());
                if (errorCode == ValidateUtility.VALUE_OK) {
                    sb.append(calc.getXYConvert(obj.getXyConvert().get(0)[2], singleValue) + ";");
                } else {
                    numberErrorMessage(errorCode, key, value, obj.getWsfRange(), obj.getType(), obj.getWsfStepSize());
                    return false;
                }
            }
            if (sb.length() != 0 && type == XMLType.LMT) {
                request.getAttributeList().put(key, sb.substring(0, sb.length() - 1));
            }
        }
        return true;
    }

    /**
     * 检查引用的PLMN是否合法，如果合法则替换PLMN为OperatorID
     *
     * @param key
     * @param value
     * @return
     */
    private boolean checkPLMN(String key, String value) {
        //Match: 460-01,460-01;460-01
        //Not Match: 460-1 
        String refPlmnRegex = "\d{3}-(\d{2}|\d{3})((,|;)\d{3}-(\d{2}|\d{3}))*";
        if (!value.matches(refPlmnRegex)) {
            String details = I18N.getFormatString(I18NC.VERIFY_PLMN_ILLEGAL, processExcelName(key), value);
            String suggestion = I18N.getFormatString(I18NC.VERIFY_PLMN_ILLEGAL_SUG, processExcelName(key));
            sendMessage(details, suggestion);
            return false;
        }
        //{{获取XML模板文件中的OperatorId数组
        String[] opeartorIds = (String[]) Cache.getInstance().get(request.getQuoteTemplateName(), "opeartorId");
        String[] opeartorArr = (String[]) Cache.getInstance().get(request.getQuoteTemplateName(), "opeartorId");
        if (opeartorIds == null || opeartorIds.length == 0) {
            //String operatorXPATH = "//Mo[@name='Operator']/Property[@name='%s']";
            String operatorXPATH = "//Mo[@name='Plmn']/Property[@name='parentLDN']";
            if (simpleMOFlag) {
                operatorXPATH = SimpleMo.convertXpath(operatorXPATH);
            }
            List? list = document.selectNodes(operatorXPATH);
            opeartorIds = new String[list.size()];
            opeartorArr = new String[list.size()];
            for (int i = 0; i  list.size(); i++) {
                Element tmp = (Element) list.get(i);
                opeartorIds[i] = tmp.attributeValue(SimpleMo.getValue());
                opeartorArr[i] = ((opeartorIds[i]).toString().split(",")[1]).split("=")[1];
            }
            Cache.getInstance().put(request.getQuoteTemplateName(), "opeartorId", opeartorArr);
        }
        //}}
        //{{将PLMN Parameters PLMN参数中的MCC与MNC拼接为460-01;460-02样式的数组
        String valuesMCC = request.getAttributeList().get("//node[@radioMode='PLAT']/property[@excelName='Mobile Country Code']");
        String valuesMNC = request.getAttributeList().get("//node[@radioMode='PLAT']/property[@excelName='Mobile Network Code']");
        String[] mccArray = StringUtils.split(valuesMCC, ";");
        String[] mncArray = StringUtils.split(valuesMNC, ";");
        int len = mccArray.length;
        String[] mccAndmnc = new String[len];
        for (int i = 0; i  len; i++) {
            mccAndmnc[i] = mccArray[i] + "-" + mncArray[i];
        }
        //}}
        //{{将匹配到的MCC-MNC替换为OperatorID
        String convertValue = StringUtils.replaceEach(value, mccAndmnc, opeartorArr);
        //}}
        //{{判断替换后的convertValue是否正确
        if (StringUtils.isEmpty(convertValue) || StringUtils.contains(convertValue, "-")) {
            String details = I18N.getFormatString(I18NC.VERIFY_REF_ILLEGAL, processExcelNa