package com.vci.server.base.utility;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

import com.vci.omd.objects.OtherInfo;
import com.vci.server.cache.OMCacheProvider;
import com.vci.common.qt.object.ChildrenInfo;
import com.vci.common.qt.object.Condition;
import com.vci.common.qt.object.ConditionItem;
import com.vci.common.qt.object.Connector;
import com.vci.common.qt.object.LeafInfo;
import com.vci.common.qt.object.LeafValue;
import com.vci.common.qt.object.Operator;
import com.vci.common.qt.object.OrderInfo;
import com.vci.common.qt.object.PageInfo;
import com.vci.common.qt.object.QTConstants;
import com.vci.common.qt.object.QueryTemplate;
import com.vci.corba.common.VCIError;
import com.vci.corba.omd.atm.AttribItem;

public class OQueryHelper {

	/**
	 * 在根节点上循环增加qtNode
	 * 
	 * @param doc
	 * @return
	 */
	public static Element addDoc(Element rootNode, QueryTemplate qt) {
		Element qtNode = rootNode.addElement(QTConstants.QUERYTEMPLATE);
		qtNode.addAttribute(QTConstants.ID, qt.getId());
		qtNode.addAttribute(QTConstants.TYPE, qt.getType());
		// 设置clauseList
		List<String> clauseList = qt.getClauseList();
		String claValue = QTConstants.BLANK;
		for (int i = 0; i < clauseList.size(); i++) {
			claValue += clauseList.get(i);
			if (i < clauseList.size() - 1) {
				claValue += ",";
			}
		}
		Element claListNode = qtNode.addElement(QTConstants.CLAUSELIST);
		claListNode.setText(claValue);

		// 设置查询的linkType
		String linkType = qt.getLinkType();
		Element ltNode = qtNode.addElement(QTConstants.LINKTYPE);
		if (linkType != null) {
			ltNode.setText(linkType);
		}
		// 设置查询的btmType
		String btmType = qt.getBtmType();
		Element btmNode = qtNode.addElement(QTConstants.BTMTYPE);
		if (btmType != null) {
			btmNode.setText(btmType);
		}
		// 查询业务对象时，是否查询子类型
		if (qt.getType().equals(QTConstants.TYPE_BTM)) {
			boolean queryChildrenFlag = qt.isQueryChildren();
			Element queryChildrenFlagNode = qtNode.addElement(QTConstants.QUERYCHILDRENFLAG);
			queryChildrenFlagNode.setText(String.valueOf(queryChildrenFlag));
		}
		// 是否查询是否包含下一级(链接查询)
		boolean isQueryIsLeaf = qt.isQueryISLeaf();
		Element queryIsLeafNode = qtNode.addElement(QTConstants.QUERYISLEAF);
		queryIsLeafNode.setText(String.valueOf(isQueryIsLeaf));
		// 查询时是否加入权限，默认加权限
		boolean rightFlag = qt.isRightFlag();
		Element rightFlagNode = qtNode.addElement(QTConstants.RIGHTFlag);
		rightFlagNode.setText(String.valueOf(rightFlag));

		// weidy@2018-06-19 增加密级控制
		boolean secretFlag = qt.isSecretFlag();
		Element secretFlagNode = qtNode.addElement(QTConstants.SECRETFLAG);
		secretFlagNode.setText(String.valueOf(secretFlag));// end weidy
		// 设置版本版次信息
		int version = qt.getVersion();
		Element versionNode = qtNode.addElement(QTConstants.VERSION);
		versionNode.setText(String.valueOf(version));
		// 设置链接查询的递归层次
		int levelRec = qt.getLevel();
		Element levelRecNode = qtNode.addElement(QTConstants.LEVELREC);
		levelRecNode.setText(String.valueOf(levelRec));
		// 递归返回数据模式
		int recReturnMode = qt.getRecReturnMode();
		Element recReturnModeNode = qtNode.addElement(QTConstants.RECRETURNMODE);
		recReturnModeNode.setText(String.valueOf(recReturnMode));

		if (qt.getType().equals(QTConstants.TYPE_LINK)) {
			// 设置链接查询方向
			String direction = qt.getDirection();
			Element directionNode = qtNode.addElement(QTConstants.DIRECTION);
			directionNode.setText(direction);
		}
		// 设置PageInfo
		PageInfo pageInfo = qt.getPageInfo();
		if (pageInfo != null) {
			Element pageInfoNode = qtNode.addElement(QTConstants.PAGEINFO);
			Element pageNONode = pageInfoNode.addElement(QTConstants.PAGENO);
			int pageNO = pageInfo.getPageNO();
			pageNONode.setText(String.valueOf(pageNO));
			Element rowCountNode = pageInfoNode.addElement(QTConstants.ROWCOUNT);
			int rowCount = pageInfo.getRowCount();
			rowCountNode.setText(String.valueOf(rowCount));
		}
		// 设置ORDER BY
		List<OrderInfo> orderInfoList = qt.getOrderInfoList();
		if (orderInfoList != null && orderInfoList.size() > 0) {
			Element orderInfosNode = qtNode.addElement(QTConstants.ORDERINFOS);
			for (int i = 0; i < orderInfoList.size(); i++) {
				OrderInfo o = orderInfoList.get(i);
				if (o == null) {
					continue;
				}
				Element orderInfoNode = orderInfosNode.addElement(QTConstants.ORDERINFO);
				String orderField = o.getOrderField();
				Element orderFieldNode = orderInfoNode.addElement(QTConstants.ORDERFIELD);
				orderFieldNode.setText(orderField == null ? QTConstants.BLANK : orderField);
				String orderMode = o.getOrderMode();
				Element orderModeNode = orderInfoNode.addElement(QTConstants.ORDERMODE);
				orderModeNode.setText(orderMode == null ? QTConstants.BLANK : orderMode);
				int level = o.getLevel();
				Element levelNode = orderInfoNode.addElement(QTConstants.LEVEL);
				levelNode.setText(String.valueOf(level));
			}
		}
		// 设置Condition
		Condition condition = qt.getCondition();
		if (condition != null) {
			Element conditionNode = qtNode.addElement(QTConstants.CONDITION);
			conditionNode.addAttribute(QTConstants.ROOTCINAME, condition.getRootCIName());
			Map<String, ConditionItem> ciMap = condition.getCIMap();
			if (ciMap != null) {
				for (Iterator<String> i = ciMap.keySet().iterator(); i.hasNext();) {
					String ciId = i.next();
					// 设置conditionItem
					ConditionItem cItem = ciMap.get(ciId);
					Element cItemNode = conditionNode.addElement(QTConstants.CONDITIONITEM);
					cItemNode.addAttribute(QTConstants.ID, cItem.getId());
					// 设置是否是叶子节点
					boolean isLeaf = cItem.isLeaf();
					Element leafFlagNode = cItemNode.addElement(QTConstants.LEAFFLAG);
					leafFlagNode.setText(String.valueOf(cItem.isLeaf()));
					// 设置conditionItem的leafData
					if (isLeaf) {
						LeafInfo leafInfo = cItem.getLeafInfo();
						Element leafInfoNode = cItemNode.addElement(QTConstants.LEAFINFO);
						Element clauseNode = leafInfoNode.addElement(QTConstants.CLAUSE);
						clauseNode.setText(leafInfo.getClause());
						Element operatorNode = leafInfoNode.addElement(QTConstants.OPERATOR);
						String operator = leafInfo.getOperator();
						/**
						 * 因<, <= 在xml中不能正确存储, 故将查询模板的<, <=存为LT, LTE; 从xml读取operator为LT, LTE时,
						 * 再转换成查询模板的<, <=. 将>, >= 做相同处理.
						 */
						if (operator.equals(Operator.LT)) {
							operator = Operator.LTTEXT;
						} else if (operator.equals(Operator.LTE)) {
							operator = Operator.LTETEXT;
						} else if (operator.equals(Operator.GT)) {
							operator = Operator.GTTEXT;
						} else if (operator.equals(Operator.GTE)) {
							operator = Operator.GTETEXT;
						}
						operatorNode.setText(operator);
						// 设置conditionItem的leafData的LDValue
						LeafValue lDValue = leafInfo.getValue();
						Element valueNode = leafInfoNode.addElement(QTConstants.VALUE);
						Element ordinaryValueNode = valueNode.addElement(QTConstants.ORDINARYVALUE);
						String ordinaryValue = lDValue.getOrdinaryValue();
						if (ordinaryValue != null) {
							ordinaryValueNode.setText(ordinaryValue);
						}
						Element queryTemplateNode = valueNode.addElement(QTConstants.REFQT);
						QueryTemplate refQt = lDValue.getQueryTemplate();
						if (refQt != null) {
							addDoc(rootNode, refQt);
							queryTemplateNode.setText(lDValue.getQueryTemplate().getId());
						}
					} else {
						// 设置conditionItem的childrenData
						Element childrenInfoNode = cItemNode.addElement(QTConstants.CHILDRENINFO);
						ChildrenInfo cdInfo = cItem.getChildrenInfo();
						Element leftNode = childrenInfoNode.addElement(QTConstants.LEFT);
						leftNode.setText(cdInfo.getLeftCIName());
						Element rightNode = childrenInfoNode.addElement(QTConstants.RIGHT);
						rightNode.setText(cdInfo.getRightCIName());
						Element conncectorNode = childrenInfoNode.addElement(QTConstants.CONNECTOR);
						conncectorNode.setText(cdInfo.getConnector());
					}
				}
			}

		}

		return rootNode;
	}

	/**
	 * 将查询模板结构转化成查询模板text
	 * 
	 * @param qt
	 * @return
	 */
	public static String getQTTextByQT(QueryTemplate qt) {
		return qtTOXMl(qt).asXML();
	}

	/**
	 * 将查询模板, 以及其关联的查询模板
	 * 
	 * @param qt
	 * @return
	 */
	private static Document qtTOXMl(QueryTemplate qt) {
		Document document = DocumentHelper.createDocument();
		Element rootNode = document.addElement(QTConstants.DATA);
		addDoc(rootNode, qt);
		return document;
	}


	/**
	 * 将查询模板text转化成查询模板结构
	 * 
	 * @param qtName : 查询模板name
	 * @param qtText : 查询模板text
	 * @return
	 * @throws DocumentException
	 * @throws VCIError
	 */
	public static QueryTemplate getQTByQTText(String qtName, String qtText) throws VCIError, DocumentException {
		
		return getQTByDoc(DocumentHelper.parseText(qtText), qtName);
	}

	/**
	 * 根据Document, Document中的模板名获取查询模板
	 * 
	 * @throws VCIError
	 */
	private static QueryTemplate getQTByDoc(Document doc, String name) throws VCIError {
		QueryTemplate qt = new QueryTemplate();

		Element rootNode = doc.getRootElement();
		List<Element> qtNodes = rootNode.elements(QTConstants.QUERYTEMPLATE);
		for (Iterator<Element> i = qtNodes.iterator(); i.hasNext();) {
			Element qtNode = i.next();
			if (qtNode.attributeValue(QTConstants.ID).equals(name)) {
				// 设置Id
				qt.setId(name);
				String type = qtNode.attributeValue(QTConstants.TYPE);
				if (type == null || (!type.equals(QTConstants.TYPE_BTM) && !type.equals(QTConstants.TYPE_LINK))) {
					throw new VCIError("P0010QT-00011", new String[] { "没有正确设置查询模板的类型" });
				} else {
					qt.setType(type);
				}
				// 设置clauseList
				List<String> clauseList = new ArrayList<String>();
				String[] clauses = qtNode.elementText(QTConstants.CLAUSELIST).split(",");
				for (int k = 0; k < clauses.length; k++) {
					clauseList.add(clauses[k]);
				}
				qt.setClauseList(clauseList);
				// 设置查询的linkType
				String linkType = qtNode.elementText(QTConstants.LINKTYPE);
				qt.setLinkType(linkType == null ? QTConstants.BLANK : linkType);
				// 设置查询的btmType
				String btmType = qtNode.elementText(QTConstants.BTMTYPE);
				qt.setBtmType(btmType == null ? QTConstants.BLANK : btmType);
				if (qt.getType().equals(QTConstants.TYPE_BTM)) {
					// 是否查询业务类型的子类型
					String queryChildrenFlag = qtNode.elementText(QTConstants.QUERYCHILDRENFLAG);
					qt.setQueryChildrenFlag(Boolean.valueOf(queryChildrenFlag));
				}
				// 是否查询是否包含下一级(链接查询)
				String queryIsLeaf = qtNode.elementText(QTConstants.QUERYISLEAF);
				if (queryIsLeaf == null || queryIsLeaf.equals("")) {
					queryIsLeaf = String.valueOf(Boolean.FALSE);
				}
				qt.setQueryISLeaf(Boolean.valueOf(queryIsLeaf));
				// 查询时是否加入权限，默认加权限
				String rightFlag = qtNode.elementText(QTConstants.RIGHTFlag);
				if (rightFlag == null || rightFlag.equals("")) {
					rightFlag = String.valueOf(Boolean.TRUE);
				}
				qt.setRightFlag(Boolean.valueOf(rightFlag));
				// weidy@2018-06-19 增加密级控制
				String secretFlag = qtNode.elementText(QTConstants.SECRETFLAG);
				if (secretFlag == null || secretFlag.equals("")) {
					secretFlag = String.valueOf(Boolean.TRUE);
				}
				qt.setSecretFlag(Boolean.valueOf(secretFlag));
				// 设置版本版次信息
				String versionStr = qtNode.elementText(QTConstants.VERSION);
				int version = Integer.valueOf(versionStr == null ? "0" : versionStr);
				qt.setVersion(version);

				// 设置链接查询递归的层次
				String levelRecStr = qtNode.elementText(QTConstants.LEVELREC);
				int levelRec = Integer.valueOf(levelRecStr == null ? "1" : levelRecStr);
				qt.setLevel(levelRec);

				// 递归返回数据模式
				String recReturnModeStr = qtNode.elementText(QTConstants.RECRETURNMODE);
				int recReturnMode = Integer.valueOf(recReturnModeStr == null ? "1" : recReturnModeStr);
				qt.setRecReturnMode(recReturnMode);

				// 设置链接查询方向
				if (qt.getType().equals(QTConstants.TYPE_LINK)) {
					String direction = qtNode.elementText(QTConstants.DIRECTION);
					if (direction == null || (!direction.equals(QTConstants.DIRECTION_POSITIVE)
							&& !direction.equals(QTConstants.DIRECTION_OPPOSITE))) {
						qt.setDirection(QTConstants.DIRECTION_POSITIVE);
					} else {
						qt.setDirection(direction);
					}
				}
				// 设置PageInfo
				Element pageInfoNode = qtNode.element(QTConstants.PAGEINFO);
				if (pageInfoNode != null && pageInfoNode.element(QTConstants.PAGENO) != null
						&& pageInfoNode.element(QTConstants.ROWCOUNT) != null) {
					PageInfo pageInfo = new PageInfo();
					String pageNO = pageInfoNode.element(QTConstants.PAGENO).getText();
					String rowCount = pageInfoNode.element(QTConstants.ROWCOUNT).getText();
					if (pageNO != null && !pageNO.equals("")) {
						pageInfo.setPageNO(Integer.parseInt(pageNO));
					}
					if (rowCount != null && !rowCount.equals("")) {
						pageInfo.setRowCount(Integer.parseInt(rowCount));
					}
					qt.setPageInfo(pageInfo);
				}
				// 设置orderInfoList
				Element orderInfosNode = qtNode.element(QTConstants.ORDERINFOS);
				if (orderInfosNode != null && orderInfosNode.elements(QTConstants.ORDERINFO) != null) {
					List<OrderInfo> orderInfoList = new ArrayList<OrderInfo>();
					List<Element> orderInfoNodes = orderInfosNode.elements(QTConstants.ORDERINFO);
					for (Iterator<Element> ite = orderInfoNodes.iterator(); ite.hasNext();) {
						Element orderInfoNode = ite.next();
						if (orderInfoNode.element(QTConstants.ORDERFIELD) != null
								&& orderInfoNode.element(QTConstants.ORDERMODE) != null
								&& orderInfoNode.element(QTConstants.LEVEL) != null) {
							OrderInfo obj = new OrderInfo();
							obj.setOrderField(orderInfoNode.elementText((QTConstants.ORDERFIELD)));
							obj.setOrderMode(orderInfoNode.elementText((QTConstants.ORDERMODE)));
							if (orderInfoNode.elementText((QTConstants.LEVEL)) != null
									&& !orderInfoNode.elementText((QTConstants.LEVEL)).equals("")) {
								obj.setLevel(Integer.valueOf(orderInfoNode.elementText((QTConstants.LEVEL))));
							}
							orderInfoList.add(obj);
						}
					}
					qt.setOrderInfoList(orderInfoList);
				}
				Element conditionNode = qtNode.element(QTConstants.CONDITION);
				// 设置condition
				if (conditionNode != null
						&& !conditionNode.attributeValue(QTConstants.ROOTCINAME).equals(QTConstants.BLANK)) {
					Condition condition = new Condition();
					qt.setCondition(condition);
					condition.setRootCIName(conditionNode.attributeValue(QTConstants.ROOTCINAME));
					HashMap<String, ConditionItem> cIMap = new HashMap<String, ConditionItem>();
					condition.setCIMap(cIMap);
					List<Element> ciNodes = conditionNode.elements(QTConstants.CONDITIONITEM);
					for (Iterator<Element> ite = ciNodes.iterator(); ite.hasNext();) {
						Element ciNode = ite.next();
						// 设置conditionItem
						ConditionItem conditionItem = new ConditionItem();
						conditionItem.setId(ciNode.attributeValue(QTConstants.ID));
						conditionItem.setLeafFlag(Boolean.valueOf(ciNode.elementText(QTConstants.LEAFFLAG)));

						// 设置conditionItem的leafInfo
						Element ldNode = ciNode.element(QTConstants.LEAFINFO);
						if (ldNode != null && ldNode.element(QTConstants.CLAUSE) != null) {
							LeafInfo leafData = new LeafInfo();
							conditionItem.setLeafInfo(leafData);
							leafData.setClause(ldNode.elementText(QTConstants.CLAUSE));
							String operator = ldNode.elementText(QTConstants.OPERATOR);
							/**
							 * 因<, <= 在xml中不能正确存储, 故将查询模板的<, <=存为LT, LTE; 从xml读取operator为LT, LTE时,
							 * 再转换成查询模板的<, <=. 将>, >= 做相同处理.
							 */
							if (operator.equals(Operator.LTTEXT)) {
								operator = Operator.LT;
							} else if (operator.equals(Operator.LTETEXT)) {
								operator = Operator.LTE;
							} else if (operator.equals(Operator.GTTEXT)) {
								operator = Operator.GT;
							} else if (operator.equals(Operator.GTETEXT)) {
								operator = Operator.GTE;
							}
							leafData.setOperator(operator);
							// 设置conditionItem的leafData的LDValue
							Element valueNode = ldNode.element(QTConstants.VALUE);
							LeafValue ldValue = new LeafValue();
							leafData.setValue(ldValue);
							ldValue.setOrdinaryValue(valueNode.elementText(QTConstants.ORDINARYVALUE));
							String qtName = valueNode.elementText(QTConstants.REFQT);
							if (qtName != null && !qtName.equals(QTConstants.BLANK)) {
								ldValue.setQueryTemplate(getQTByDoc(doc, qtName));
							}
						}

						// 设置conditionItem的childrenInfo
						Element cdNode = ciNode.element(QTConstants.CHILDRENINFO);
						if (cdNode != null) {
							ChildrenInfo cdData = new ChildrenInfo();
							conditionItem.setChildrenInfo(cdData);
							cdData.setLeftCIName(cdNode.elementText((QTConstants.LEFT)));
							cdData.setRightCIName(cdNode.elementText((QTConstants.RIGHT)));
							cdData.setConnector(cdNode.elementText((QTConstants.CONNECTOR)));
						}

						cIMap.put(conditionItem.getId(), conditionItem);
					}
				}
			}
		}
		return qt;
	}



	/**
	 * 将查询模板中查询条件的值参数, 替换为map中给定的值
	 * 
	 * @param qt
	 * @param map
	 * @throws VCIError
	 */
	public static QueryTemplate replaceQTValues(QueryTemplate qt, Map<String, String> map) throws VCIError {
		try {
			if (qt == null || map == null) {
				return qt;
			}
			Condition condition = qt.getCondition();
			if (condition == null) {
				return qt;
			}
			Map<String, ConditionItem> ciMap = condition.getCIMap();
			if (ciMap == null) {
				return qt;
			}
			for (Iterator<String> i = ciMap.keySet().iterator(); i.hasNext();) {
				String ciId = i.next();
				ConditionItem ci = ciMap.get(ciId);
				// 当ConditionItem是叶子结点, 并且值参数在map中时, 替换。
				if (ci.isLeaf()) {
					LeafInfo lInfo = ci.getLeafInfo();
					String value = lInfo.getValue().getOrdinaryValue();
					if (value != null && !value.equals("")) {
						if (map.containsKey(value)) {
							String value_ = map.get(value);
							lInfo.getValue().setOrdinaryValue(value_);
							// 替换自定义查询(非嵌套)in (select oid from ff where #val1# #val2# )
						} else if (value.contains("#")) {
							while (value.contains("#")) {
								int start = value.indexOf('#');
								int end = value.indexOf('#', start + 1);
								String key = value.substring(start + 1, end);
								String val = map.get(key);
								value = value.replace('#' + key + '#', val == null ? "null" : val);
							}
							lInfo.getValue().setOrdinaryValue(value);
						}

					} else {
						QueryTemplate refQT = lInfo.getValue().getQueryTemplate();
						QueryTemplate refQT_ = replaceQTValues(refQT, map);
						lInfo.getValue().setQueryTemplate(refQT_);
					}
				}
			}
			return qt;
		} catch (Throwable e) {
			e.printStackTrace();
			throw new VCIError("P0010QT-00008", new String[] { e.getMessage() });
		}
	}



	/**
	 * 把key, Value 封装成查询模板的Condition
	 * 
	 * @param map
	 * @return
	 */
	public static Condition getCondition(Map<String, String> map) {
		Condition cond = new Condition();
		Map<String, ConditionItem> ciMap = new HashMap<String, ConditionItem>();
		Iterator<String> ite = map.keySet().iterator();
		List<ConditionItem> list = new ArrayList<ConditionItem>();
		int idFlag = 1;
		while (ite.hasNext()) {
			String key = ite.next();
			String value = map.get(key);
			if (value == null || value.equals("")) {
				continue;
			}
			List<ConditionItem> list_ = getCIList(key, value, idFlag);
			if (list.size() > 0) {
				ConditionItem lCI = list.get(list.size() - 1);
				ConditionItem rCI = list_.get(list_.size() - 1);
				list.addAll(list_);
				idFlag = idFlag + list_.size();
				ConditionItem pCI = new ConditionItem();
				pCI.setId("ci" + idFlag);
				pCI.setLeafFlag(false);
				pCI.setLeafInfo(null);
				ChildrenInfo cInfo = new ChildrenInfo();
				cInfo.setLeftCIName(lCI.getId());
				cInfo.setConnector(Connector.AND);
				cInfo.setRightCIName(rCI.getId());
				pCI.setChildrenInfo(cInfo);
				list.add(pCI);
				idFlag++;
			} else {
				list.addAll(list_);
				idFlag = idFlag + list_.size();
			}
		}

		for (int i = 0; i < list.size(); i++) {
			ConditionItem ci = list.get(i);
			ciMap.put(ci.getId(), ci);
		}
		if (list.size() > 0) {
			ConditionItem rootCI = list.get(list.size() - 1);
			cond.setRootCIName(rootCI.getId());
			cond.setCIMap(ciMap);
			return cond;
		} else {
			return null;
		}
	}

	/**
	 * 根据value中包含的AND/OR解析出conditionItem组
	 * 
	 * @param key
	 * @param value
	 * @param idFlag
	 * @return
	 */
	public static List<ConditionItem> getCIList(String key, String value, int idFlag) {
		List<ConditionItem> list = new ArrayList<ConditionItem>();
		String connector = Connector.AND;
		while (value.length() > 0) {
			int indexAnd = value.indexOf("\\AND");
			int indexOr = value.indexOf("\\OR");
			ConditionItem ci = new ConditionItem();
			if (indexAnd > 0 || indexOr > 0) {
				String nextConnector = Connector.AND;
				String value_ = null;
				if ((indexAnd > 0 && indexAnd < indexOr) || indexOr < 0) {
					value_ = value.substring(0, indexAnd);
					nextConnector = Connector.AND;
					value = value.substring(indexAnd + 4);
				} else {
					value_ = value.substring(0, indexOr);
					nextConnector = Connector.OR;
					value = value.substring(indexOr + 3);
				}
				ci = getConditionItem(key, value_, idFlag);
				if (list.size() > 0) {
					ConditionItem lCI = list.get(list.size() - 1);
					list.add(ci);
					idFlag++;
					ConditionItem pCI = new ConditionItem();
					pCI.setId("ci" + idFlag);
					pCI.setLeafFlag(false);
					pCI.setLeafInfo(null);
					ChildrenInfo cInfo = new ChildrenInfo();
					cInfo.setLeftCIName(lCI.getId());
					cInfo.setConnector(connector);
					cInfo.setRightCIName(ci.getId());
					pCI.setChildrenInfo(cInfo);
					list.add(pCI);
					idFlag++;
				} else {
					list.add(ci);
					idFlag++;
				}
				connector = nextConnector;
			} else {
				ci = getConditionItem(key, value, idFlag);
				if (list.size() > 0) {
					ConditionItem lCI = list.get(list.size() - 1);
					list.add(ci);
					idFlag++;
					ConditionItem pCI = new ConditionItem();
					pCI.setId("ci" + idFlag);
					pCI.setLeafFlag(false);
					pCI.setLeafInfo(null);
					ChildrenInfo cInfo = new ChildrenInfo();
					cInfo.setLeftCIName(lCI.getId());
					cInfo.setConnector(connector);
					cInfo.setRightCIName(ci.getId());
					pCI.setChildrenInfo(cInfo);
					list.add(pCI);
					idFlag++;
				} else {
					list.add(ci);
					idFlag++;
				}
				value = "";
			}
		}
		return list;
	}

	/**
	 * 将原子value（不包含and/or）解析成单个ConditionItem
	 * 
	 * @param key
	 * @param value
	 * @param idFlag
	 * @return
	 */
	private static ConditionItem getConditionItem(String key, String value, int idFlag) {
		ConditionItem ci = new ConditionItem();
		ci.setId("ci" + idFlag);
		ci.setChildrenInfo(null);
		ci.setLeafFlag(true);
		LeafInfo lInfo = new LeafInfo();
		String operator = null;

		if (value.startsWith("\\NOTLIKE")) {
			operator = Operator.NOTLIKE;
			value = value.substring(8);
		} else if (value.startsWith(Operator.STAR) || value.endsWith(Operator.STAR)) {
			operator = Operator.LIKE;
		} else if (value.startsWith(Operator.UNEQUAL)) {
			operator = Operator.UNEQUAL;
			value = value.substring(2);
		} else if (value.startsWith(Operator.GT)) { // add by caill 2016.4.7 为操作添加“大于”的判断 并在此判断中添加“大于等于”的判断
			operator = Operator.GT;
			if (value.startsWith(Operator.GTE)) {
				operator = Operator.GTE;
				value = value.substring(2);
			} else {
				value = value.substring(1);
			}

		} else if (value.startsWith(Operator.LT)) { // add by caill 2016.4.7 为操作添加“小于”的判断 并在此判断中添加“小于等于”的判断
			operator = Operator.LT;
			if (value.startsWith(Operator.LTE)) {
				operator = Operator.LTE;
				value = value.substring(2);
			} else {
				value = value.substring(1);
			}
		} /*
			 * else if(value.startsWith(Operator.LTE)){ operator = Operator.LTE; value =
			 * value.substring(2); }else if(value.startsWith(Operator.GTE)){ operator =
			 * Operator.GTE; value = value.substring(2); }
			 */else if (value.startsWith("\\IN")) {
			operator = Operator.IN;
			value = value.substring(3);
		} else if (value.startsWith("\\NOTIN")) {
			operator = Operator.NOTIN;
			value = value.substring(6);
		} else {
			operator = Operator.EQUAL;
		}
		lInfo.setOperator(operator);
		if (key.toUpperCase().contains("T_OID.") || key.toUpperCase().contains("F_OID.")) {
			// 去掉T_OID.或者F_OID.
			String clause_ = key.substring(6);
			// 属性为参照属性
			if (clause_.contains(".")) {
				int fpIndex = clause_.indexOf(".");
				String refAbName = key.substring(0, fpIndex + 6);
				key = key.substring(fpIndex + 6 + 1);
				lInfo.setClause(refAbName);
				// 去掉T_OID.或者F_OID.
				refAbName = refAbName.substring(6);
				lInfo.setOperator(Operator.IN);
				QueryTemplate qt = getRefQT(refAbName, key, operator, value);
				LeafValue lValue = new LeafValue();
				lValue.setQueryTemplate(qt);
				lInfo.setValue(lValue);
				// 属性为非参照属性
			} else {
				lInfo.setClause(key);
				LeafValue lValue = new LeafValue();
				lInfo.setValue(lValue);
				lValue.setOrdinaryValue(value);
			}
		} else {
			// 属性为参照属性
			if (key.contains(".")) {
				int fpIndex = key.indexOf(".");
				String refAbName = key.substring(0, fpIndex);
				key = key.substring(fpIndex + 1);
				lInfo.setClause(refAbName);
				lInfo.setOperator(Operator.IN);
				QueryTemplate qt = getRefQT(refAbName, key, operator, value);
				LeafValue lValue = new LeafValue();
				lValue.setQueryTemplate(qt);
				lInfo.setValue(lValue);
				// 属性为非参照属性
			} else {
				lInfo.setClause(key);
				LeafValue lValue = new LeafValue();
				lInfo.setValue(lValue);
				lValue.setOrdinaryValue(value);
			}
		}
		ci.setLeafInfo(lInfo);
		return ci;
	}

	/**
	 * 获取参照的查询模板
	 * 
	 * @param refAbName:    参照属性名
	 * @param clause:       属性参照的业务类型中的属性
	 * @param operator
	 * @param ordinaryValue
	 * @return
	 */
	private static QueryTemplate getRefQT(String refAbName, String clause, String operator, String ordinaryValue) {
		QueryTemplate qt = new QueryTemplate();
		List<String> clauseList = new ArrayList<String>();
		clauseList.add("OID");
		qt.setClauseList(clauseList);
		AttribItem refAb = OMCacheProvider.getAttribute(refAbName);
		//refAb = ServerServiceProvider.getOMDService().getAttributeService().getAttribItemByName(refAbName);
		OtherInfo otherInfo = OtherInfo.getOtherInfoByText(refAb.other);
		int refFlag = otherInfo.getRefFlag();
		String type = otherInfo.getRefTypeName();
		if (refFlag == 0) {
			qt.setType(QTConstants.TYPE_BTM);
			qt.setBtmType(type);
		} else if (refFlag == 1) {
			qt.setType(QTConstants.TYPE_LINK);
			qt.setLinkType(type);
		}
		Condition condition = new Condition();
		qt.setCondition(condition);
		condition.setRootCIName("ci1");
		HashMap<String, ConditionItem> ciMap = new HashMap<String, ConditionItem>();
		condition.setCIMap(ciMap);
		ConditionItem ci = new ConditionItem();
		ci.setId("ci1");
		ciMap.put(ci.getId(), ci);
		ci.setLeafFlag(true);
		LeafInfo leafInfo = new LeafInfo();
		if (clause.contains(".")) {
			int fpIndex = clause.indexOf(".");
			String refAbName_ = clause.substring(0, fpIndex);
			clause = clause.substring(fpIndex + 1);
			leafInfo.setClause(refAbName_);
			leafInfo.setOperator(Operator.IN);
			QueryTemplate qt_ = getRefQT(refAbName_, clause, operator, ordinaryValue);
			LeafValue lValue = new LeafValue();
			lValue.setQueryTemplate(qt_);
			leafInfo.setValue(lValue);
			qt.setId("qt_" + refAbName + "_" + refAbName_);
		} else {
			leafInfo.setClause(clause);
			leafInfo.setOperator(operator);
			LeafValue lValue = new LeafValue();
			lValue.setOrdinaryValue(ordinaryValue);
			leafInfo.setValue(lValue);
			qt.setId("qt_" + refAbName + "_" + clause);
		}
		ci.setLeafInfo(leafInfo);
		condition.setCIMap(ciMap);
		return qt;
	}

	/**
	 * 
	 * @param direction
	 * @param oid
	 * @param btmType
	 * @param map
	 * @return
	 */
	public static Condition getConditionForLink(String direction, String oid, String btmType, Map<String, String> map) {
		Condition cond = new Condition();
		cond.setRootCIName("ci3");
		Map<String, ConditionItem> ciMap = new HashMap<String, ConditionItem>();
		if (direction.equals(QTConstants.DIRECTION_POSITIVE)) {
			ConditionItem ci1 = new ConditionItem();
			ci1.setId("ci1");
			ci1.setChildrenInfo(null);
			ci1.setLeafFlag(true);
			LeafInfo lInfo = new LeafInfo();
			lInfo.setClause("f_oid");
			lInfo.setOperator(Operator.EQUAL);
			LeafValue lValue = new LeafValue();
			lValue.setOrdinaryValue(oid);
			lInfo.setValue(lValue);
			ci1.setLeafInfo(lInfo);
			ciMap.put(ci1.getId(), ci1);

			ConditionItem ci2 = new ConditionItem();
			ci2.setId("ci2");
			ci2.setChildrenInfo(null);
			ci2.setLeafFlag(true);
			LeafInfo lInfo2 = new LeafInfo();
			lInfo2.setClause("t_nameOId");
			lInfo2.setOperator(Operator.IN);
			LeafValue lValue2 = new LeafValue();
			// 参照查询模板
			QueryTemplate refQT = new QueryTemplate();
			lValue2.setQueryTemplate(refQT);
			refQT.setId("refQT");
			refQT.setBtmType(btmType);
			refQT.setType(QTConstants.TYPE_BTM);
			List<String> list = new ArrayList<String>();
			list.add("nameOId");
			refQT.setClauseList(list);
			Condition cond2 = getCondition(map);
			refQT.setCondition(cond2);
			lInfo2.setValue(lValue2);
			ci2.setLeafInfo(lInfo2);
			ciMap.put(ci2.getId(), ci2);

			ConditionItem ci3 = new ConditionItem();
			ci3.setId("ci3");
			ci3.setLeafFlag(false);
			ci3.setLeafInfo(null);
			ChildrenInfo cInfo = new ChildrenInfo();
			ci3.setChildrenInfo(cInfo);
			cInfo.setLeftCIName(ci1.getId());
			cInfo.setConnector(Connector.AND);
			cInfo.setRightCIName(ci2.getId());
			ciMap.put(ci3.getId(), ci3);
		} else if (direction.equals(QTConstants.DIRECTION_OPPOSITE)) {
			ConditionItem ci1 = new ConditionItem();
			ci1.setId("ci1");
			ci1.setChildrenInfo(null);
			ci1.setLeafFlag(true);
			LeafInfo lInfo = new LeafInfo();
			lInfo.setClause("t_oid");
			lInfo.setOperator(Operator.EQUAL);
			LeafValue lValue = new LeafValue();
			lValue.setOrdinaryValue(oid);
			lInfo.setValue(lValue);
			ci1.setLeafInfo(lInfo);
			ciMap.put(ci1.getId(), ci1);

			ConditionItem ci2 = new ConditionItem();
			ci2.setId("ci2");
			ci2.setChildrenInfo(null);
			ci2.setLeafFlag(true);
			LeafInfo lInfo2 = new LeafInfo();
			lInfo2.setClause("f_oid");
			lInfo2.setOperator(Operator.IN);
			LeafValue lValue2 = new LeafValue();
			// 参照查询模板
			QueryTemplate refQT = new QueryTemplate();
			lValue2.setQueryTemplate(refQT);
			refQT.setId("refQT");
			refQT.setBtmType(btmType);
			refQT.setType(QTConstants.TYPE_BTM);
			List<String> list = new ArrayList<String>();
			list.add("oid");
			refQT.setClauseList(list);
			Condition cond2 = getCondition(map);
			refQT.setCondition(cond2);
			lInfo2.setValue(lValue2);
			ci2.setLeafInfo(lInfo2);
			ciMap.put(ci2.getId(), ci2);

			ConditionItem ci3 = new ConditionItem();
			ci3.setId("ci3");
			ci3.setLeafFlag(false);
			ci3.setLeafInfo(null);
			ChildrenInfo cInfo = new ChildrenInfo();
			ci3.setChildrenInfo(cInfo);
			cInfo.setLeftCIName(ci1.getId());
			cInfo.setConnector(Connector.AND);
			cInfo.setRightCIName(ci2.getId());
			ciMap.put(ci3.getId(), ci3);
		}
		cond.setCIMap(ciMap);
		return cond;
	}



	/**
	 * 获取业务类型属性总集合
	 * 
	 * @param btNames
	 * @return
	 */
	private static Set<String> getUserAttrNameSet(String[] btNames) {
		Set<String> set = new LinkedHashSet<String>();
		try {
			for (String btName : btNames) {
				String[] abNames = ServerServiceProvider.getOMDService().getBTMService().getBtmApNameArray(btName);
				for (String abName : abNames) {
					set.add(abName);
				}
			}
		} catch (Throwable e) {
			e.printStackTrace();
		}
		return set;
	}


	/**
	 * 视图cols viewName.col as col2
	 * 
	 * @param ltName
	 * @return
	 */
	public static List<String> getViewColsWithAlias(String[] btNames, String viewName) {
		List<String> cols = new ArrayList<String>();
		String[] sysAbItems = OmdHelper.getBTSysANames();
		for (String sysAbItem : sysAbItems) {
			cols.add(viewName + "." + sysAbItem + " AS " + sysAbItem + "2");
		}
		Set<String> userAttrNameSet = getUserAttrNameSet(btNames);
		for (String userAttrName : userAttrNameSet) {
			cols.add(viewName + "." + userAttrName + " AS " + userAttrName + "2");
		}
		return cols;
	}

	/**
	 * 获取查询条件的 值
	 * 
	 * @param con
	 * @param key
	 * @return
	 */
	public static String getConditionItemVlaue(Condition con, String key) {
		if (con == null) {
			return null;
		}
		Map<String, ConditionItem> ciMap = con.getCIMap();
		for (String ciId : ciMap.keySet()) {
			ConditionItem ci = ciMap.get(ciId);
			if (ci.isLeaf()) {
				LeafInfo leafInfo = ci.getLeafInfo();
				String clause = leafInfo.getClause();
				if (clause.equalsIgnoreCase(key)) {
					return leafInfo.getValue().getOrdinaryValue();
				}
			}
		}
		return null;
	}


}