package com.corba.mnq.xls;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import com.corba.mnq.main.MNQmainFrame;
import com.corba.mnq.tool.Warehouse;
import com.corba.mnq.tool.idl.Args;
import com.corba.mnq.tool.idl.type.CTArray;
import com.corba.mnq.tool.idl.type.CTBasic;
import com.corba.mnq.tool.idl.type.CTDeclaration;
import com.corba.mnq.tool.idl.type.CTEnum;
import com.corba.mnq.tool.idl.type.CTSequence;
import com.corba.mnq.tool.idl.type.CTStruct;
import com.corba.mnq.tool.idl.type.CTUnion;
import com.corba.mnq.tool.idl.type.TypeBase;
import com.corba.mnq.ui.ArgsCellEditor;
import com.corba.mnq.ui.ArgsTable;
import com.corba.mnq.ui.MNQMutableTreeNode;

// note that here the op node means the op on workflow tree
// instead the op on top_ParaTree
public class ReplaceUtil {

	public static final int NODE_BEHIND = 1;

	public static final int NODE_AFTER = 2;

	// input a op type's node, return a List
	// the list conatin all parameters needed to be replaced
	// the list element is RepNode type
	private static Map op2paraList = new Hashtable();

	public static void clearAll() {
		op2paraList.clear();
	}

	public static void removeAllReplaceChild(MNQMutableTreeNode node) {
		List ls = ReplaceUtil.getReplacedChild(node);
		for (int i = 0; i < ls.size(); i++) {
			ReplaceUtil.removePara((MNQMutableTreeNode) ls.get(i));
		}
	}

	// only the op behind current op will appear
	public static List getSelectableNode(MNQMutableTreeNode node) {
		MNQMutableTreeNode op = getParaOpNode(node);
		return getBrother(op, ReplaceUtil.NODE_BEHIND);
	}

	// should be like "op[x].para[y].subpara[z]
	public static String getNodePathName(MNQMutableTreeNode node,
			MNQMutableTreeNode top) {
		String ret = "";
		MNQMutableTreeNode current = node;
		Object obj = node.getUserObject();
		ret = obj.toString();
		ret = ret + "[" + getNodeIndex(current) + "]";
		while (true) {
			current = (MNQMutableTreeNode) current.getParent();

			if (current == top)
				return ret;
			obj = current.getUserObject();
			ret = obj.toString() + "[" + getNodeIndex(current) + "]" + "."
					+ ret;
		}
	}

	public static MNQMutableTreeNode pathId2node(String id,
			MNQMutableTreeNode root) {
		// id like "1.2.3.4.0" from op on
		MNQMutableTreeNode current = root;
		String tmp = id.replace('.', ':');
		String[] ss = tmp.split(":");
		for (int i = 0; i < ss.length; i++) {
			int index = Integer.valueOf(ss[i]).intValue();
			try {
				current = (MNQMutableTreeNode) current.getChildAt(index);
			} catch (ArrayIndexOutOfBoundsException e) {
				return null;
			}
		}
		return current;
	}

	public static String getNodePathId(MNQMutableTreeNode node,
			MNQMutableTreeNode top) {
		String ret = "";
		MNQMutableTreeNode current = node;
		ret = ret + getNodeIndex(current);
		while (true) {
			current = (MNQMutableTreeNode) current.getParent();
			if (current == top)
				return ret;
			ret = getNodeIndex(current) + "." + ret;
		}
	}

	public static int getNodeIndex(MNQMutableTreeNode node) {
		MNQMutableTreeNode f = (MNQMutableTreeNode) node.getParent();
		// return f.getIndex(node);
		if (f == null) {
			System.out.println("parent is null");
			return 0;
		}
		int i = 0;
		i = f.getIndex(node);
		// for (Enumeration e = f.children(); e.hasMoreElements();) {
		// MNQMutableTreeNode mtn = (MNQMutableTreeNode) e.nextElement();
		// if (mtn == node)
		// return i;
		// i++;
		// }
		return i;

	}

	public static List getBrother(MNQMutableTreeNode node, int type) {
		List lst = new Vector();
		MNQMutableTreeNode f = (MNQMutableTreeNode) node.getParent();
		boolean isStart = false;
		for (Enumeration e = f.children(); e.hasMoreElements();) {
			MNQMutableTreeNode mtn = (MNQMutableTreeNode) e.nextElement();
			if (type == ReplaceUtil.NODE_AFTER) {
				if (isStart)
					lst.add(mtn);
				if (mtn == node)
					isStart = true;
			} else if (type == ReplaceUtil.NODE_BEHIND) {
				if (mtn == node)
					return lst;
				lst.add(mtn);
			}
		}
		return lst;
	}

	private static void getReplacedRecurredChild(MNQMutableTreeNode f, List lst) {
		if (findRepNode(f) != null) {
			lst.add(f);
		}
		if (!f.isLeaf()) {
			Enumeration e = f.children();
			while (e.hasMoreElements()) {
				MNQMutableTreeNode mtn = (MNQMutableTreeNode) e.nextElement();
				getReplacedRecurredChild(mtn, lst);
			}
		}
	}

	public static List getReplacedChild(MNQMutableTreeNode f) {
		List lst = new Vector();
		if (!f.isLeaf()) {
			Enumeration e = f.children();
			while (e.hasMoreElements()) {
				MNQMutableTreeNode mtn = (MNQMutableTreeNode) e.nextElement();
				getReplacedRecurredChild(mtn, lst);
			}
		}
		return lst;
	}

	// remove all parameters under the op
	// if other parameter reference to the para under this op
	// they should also be removed
	public static void removeList(MNQMutableTreeNode op) {
		// remove reference parameter;
		List lst = getBrother(op, ReplaceUtil.NODE_AFTER);
		for (int i = 0; i < lst.size(); i++) {
			List ls = getRepList((MNQMutableTreeNode) lst.get(i));
			if (ls != null) {
				for (int j = 0; j < ls.size(); j++) {
					RepNode rn = (RepNode) ls.get(j);
					MNQMutableTreeNode tmp = ReplaceUtil.pathId2node(rn.tid,
							MNQmainFrame.top_CaseTree);
					if (tmp != null && op == getParaOpNode(tmp)) {
						// remove reference
						ls.remove(rn);
						// re-loop, because index change
						j = 0;
					}
				}
			}
		}
		// remove op itself
		op2paraList.remove(op);
	}

	// remove a parameter from list
	public static void removePara(MNQMutableTreeNode para) {
		List lst = getRepList(para);
		if (lst != null) {
			for (int i = 0; i < lst.size(); i++) {
				RepNode rn = (RepNode) lst.get(i);
				String id = ReplaceUtil.getNodePathId(para,
						MNQmainFrame.top_CaseTree);
				if (rn.sid.equals(id)) {
					lst.remove(rn);
					return;
				}
			}
		}
	}

	public static String displayRepInfo(MNQMutableTreeNode para) {
		RepNode rn = findRepNode(para);
		if (rn == null)
			return null;
		MNQMutableTreeNode target = ReplaceUtil.pathId2node(rn.tid,
				MNQmainFrame.top_CaseTree);
		if (target == null)
			return null;
		String ret = getNodePathName(target, MNQmainFrame.top_CaseTree);

		return para.getUserObject().toString() + " was replaced by:\n	" + ret;
	}

	// get replace list by a parameter
	public static List getRepList(MNQMutableTreeNode para) {
		MNQMutableTreeNode op = getParaOpNode(para);
		Object o = op2paraList.get(op);
		if (o != null)
			return (List) o;
		else
			return null;
	}

	// if father node was already replaced, then it make no sence to replace
	// its child node, so give this method to judge
	public static boolean fatherRepExist(MNQMutableTreeNode para) {
		// MNQMutableTreeNode op=getParaOpNode(para);
		List lst = getRepList(para);
		if (lst == null) {
			return false;
		}
		// loop until up to op node
		MNQMutableTreeNode current = para;
		Object o = current.getUserObject();
		while (!(o instanceof OpFlowNode)) {
			current = (MNQMutableTreeNode) current.getParent();
			for (int i = 0; i < lst.size(); i++) {
				RepNode rn = (RepNode) lst.get(i);
				String id = ReplaceUtil.getNodePathId(current,
						MNQmainFrame.top_CaseTree);
				if (rn.sid.equals(id))
					return true;
			}
			o = current.getUserObject();
		}
		return false;
	}

	public static RepNode findRepNode(MNQMutableTreeNode src) {
		// MNQMutableTreeNode op=getParaOpNode(src);
		List lst = getRepList(src);
		if (lst == null)
			return null;
		for (int i = 0; i < lst.size(); i++) {
			RepNode rn = (RepNode) lst.get(i);
			String id = ReplaceUtil.getNodePathId(src,
					MNQmainFrame.top_CaseTree);
			if (rn.sid.equals(id))
				return rn;
		}
		return null;
	}

	public static void setRepParameterById(String sid, String tid) {
		MNQMutableTreeNode src = ReplaceUtil.pathId2node(sid,
				MNQmainFrame.top_CaseTree);
		RepNode rn = findRepNode(src);
		boolean isNew = false;
		if (rn == null) {
			isNew = true;
			rn = new RepNode();
		}
		rn.sid = sid;
		rn.tid = tid;
		if (isNew) {
			List lst = getRepList(src);
			if (lst == null)
				lst = new Vector();
			lst.add(rn);
			op2paraList.put(getParaOpNode(src), lst);
		}
	}

	public static void setRepParameter(MNQMutableTreeNode src,
			MNQMutableTreeNode target) {
		RepNode rn = findRepNode(src);
		boolean isNew = false;
		if (rn == null) {
			isNew = true;
			rn = new RepNode();
		}
		rn.sid = ReplaceUtil.getNodePathId(src, MNQmainFrame.top_CaseTree);
		rn.tid = ReplaceUtil.getNodePathId(target, MNQmainFrame.top_CaseTree);
		;
		if (isNew) {
			List lst = getRepList(src);
			if (lst == null)
				lst = new Vector();
			lst.add(rn);
			op2paraList.put(getParaOpNode(src), lst);
		}
	}

	public static MNQMutableTreeNode getParaOpNode(MNQMutableTreeNode para) {
		MNQMutableTreeNode current = para;
		Object o = current.getUserObject();

		while (true) {
			if (o instanceof OpFlowNode)
				return current;
			current = (MNQMutableTreeNode) current.getParent();
			o = current.getUserObject();
		}
	}

	// this method will be called before invoke a case
	public static void replace(MNQMutableTreeNode op) {
		List lst = getRepList(op);
		if (lst == null)
			return;
		// replace parameter one by one
		for (int i = 0; i < lst.size(); i++) {
			RepNode rn = (RepNode) lst.get(i);
			MNQMutableTreeNode src = ReplaceUtil.pathId2node(rn.sid,
					MNQmainFrame.top_CaseTree);
			MNQMutableTreeNode target = ReplaceUtil.pathId2node(rn.tid,
					MNQmainFrame.top_CaseTree);
			if (src == null || target == null)
				continue;
			replaceOnePara(src, target);
		}
	}

	private static void replaceOnePara(MNQMutableTreeNode src,
			MNQMutableTreeNode target) {
		Object srcObj = src.getUserObject();
		// replace ior
		Object oo = Warehouse.node2table.get(target);
		ArgsTable table = null;
		if (oo != null && (oo instanceof ArgsTable))
			table = (ArgsTable) oo;
		if (srcObj instanceof OpFlowNode) {
			OpFlowNode cn = (OpFlowNode) srcObj;
			cn.ior = table.getInputValue();
			return;
		}
		// replace parameter
		TypeBase srcType;

		// get srcType
		if (srcObj instanceof Args)
			srcType = ((Args) srcObj).pt;
		else
			// only Args & TypeBase on tree
			srcType = (TypeBase) srcObj;

		// set value, here assume that the node type is same between src &
		// target
		if (srcType instanceof CTBasic) {
			srcType.setValueToTree(table.getInputValue());
			if (srcType.rdn.equalsIgnoreCase("any")) {
				replaceOnePara((MNQMutableTreeNode) src.getFirstChild(),
						(MNQMutableTreeNode) target.getFirstChild());
			}
		} else if (srcType instanceof CTEnum) {
			srcType.setValueToTree(table.getInputValue());
		} else if (srcType instanceof CTUnion) {
			srcType.setValueToTree(table.getInputValue());
			if (!src.isLeaf()) {
				replaceOnePara((MNQMutableTreeNode) src.getFirstChild(),
						(MNQMutableTreeNode) target.getFirstChild());
			}
		} else if (srcType instanceof CTSequence) {
			src.removeAllChildren(true);
			Enumeration e = target.children();
			while (e.hasMoreElements()) {
				MNQMutableTreeNode mtn = (MNQMutableTreeNode) e.nextElement();
				TypeBase n_sib = ((CTSequence) srcType).t_in.cloneType();
				MNQMutableTreeNode dMTN_sib = new MNQMutableTreeNode(n_sib);
				src.add(dMTN_sib);
				n_sib.dmtn = dMTN_sib;
				ArgsCellEditor.createTreeCellEditorComponent(dMTN_sib,
						MNQmainFrame.caseTree);
				MNQmainFrame.buildParaSibling(dMTN_sib, n_sib,
						MNQmainFrame.caseTree);
				replaceOnePara(dMTN_sib, mtn);
			}
		} else if (srcType instanceof CTArray) {
			src.removeAllChildren(true);
			Enumeration e = target.children();
			while (e.hasMoreElements()) {
				MNQMutableTreeNode mtn = (MNQMutableTreeNode) e.nextElement();
				TypeBase n_sib = ((CTArray) srcType).t_in.cloneType();
				MNQMutableTreeNode dMTN_sib = new MNQMutableTreeNode(n_sib);
				src.add(dMTN_sib);
				n_sib.dmtn = dMTN_sib;
				ArgsCellEditor.createTreeCellEditorComponent(dMTN_sib,
						MNQmainFrame.caseTree);
				MNQmainFrame.buildParaSibling(dMTN_sib, n_sib,
						MNQmainFrame.caseTree);
				replaceOnePara(dMTN_sib, mtn);
			}
		} else if (srcType instanceof CTStruct) {
			Enumeration e1 = src.children();
			Enumeration e2 = target.children();
			while (e1.hasMoreElements() && e2.hasMoreElements()) {
				MNQMutableTreeNode mtn1 = (MNQMutableTreeNode) e1.nextElement();
				MNQMutableTreeNode mtn2 = (MNQMutableTreeNode) e2.nextElement();
				replaceOnePara(mtn1, mtn2);
			}
		} else if (srcType instanceof CTDeclaration) {
			replaceOnePara((MNQMutableTreeNode) src.getFirstChild(),
					(MNQMutableTreeNode) target.getFirstChild());
		} else {
			// assume that CTExcept will never be used
			System.out.println("Unexpected paramether replacement, ignored");
		}
	}

	/**
	 * @param args
	 */
	public static void main_(String[] args) {
		// TODO Auto-generated method stub

	}

}