package com.vci.client.oq.ui.linkqtimport;

import java.awt.Color;
import java.awt.event.MouseEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

import javax.swing.JTable;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import com.vci.client.LogonApplication;
import com.vci.client.common.providers.ServiceProvider;
import com.vci.client.omd.linktype.LinkTypeStart;
import com.vci.client.oq.QTClient;
import com.vci.client.oq.QTDClient;
import com.vci.client.oq.ui.export.QTExportQTNode;
import com.vci.client.oq.ui.linkqtexport.LinkQTExportBTMNode;
import com.vci.client.oq.ui.linkqtexport.LinkQTExportData;
import com.vci.client.portal.NewNewUI.Export.ExportTreeCellRenderer;
import com.vci.client.portal.NewNewUI.Export.VCIImportTree;
import com.vci.client.ui.swing.CheckBoxLabel;
import com.vci.client.ui.swing.VCIOptionPane;
import com.vci.client.ui.tree.CheckBoxTreeCellRenderer;
import com.vci.client.ui.tree.CheckBoxTreeManager;
import com.vci.corba.common.VCIError;
import com.vci.corba.omd.ltm.LinkType;
import com.vci.corba.omd.qtm.QTD;
import com.vci.corba.omd.qtm.QTInfo;

public class LinkQTImportTree extends VCIImportTree {

	private static final long serialVersionUID = 1L;
	private CheckBoxTreeManager treeManager = null;
	// private BtmItem[] btmArray = null;
	// private QTInfo[] qts = null;
	private List<LinkType> btmItemNew = new ArrayList<LinkType>();
	private List<QTInfo> qTWrapperNew = new ArrayList<QTInfo>();
	private LinkQTExportData qtExportData = null;
	// private QTExportData qtExportDataNewData= null;
	private Map<String/* 类型名称 */, QTD[]/* 查询模板定义 */> norepQTDs = new HashMap<String, QTD[]>();

	public LinkQTImportTree(DefaultTreeModel treeModel) {
		super(treeModel);
		// TODO Auto-generated constructor stub
	}

	public LinkQTImportTree() {
		super(new DefaultTreeModel(new DefaultMutableTreeNode("链接类型")));
		this.setCellRenderer(new ExportTreeCellRenderer());
	}

	/**
	 * 
	 */
	public void init() {
		this.getSelectionModel().setSelectionMode(
				TreeSelectionModel.SINGLE_TREE_SELECTION);
		// 刷新分类树
		// this.getPathForRow(0).
		// initTree(this.getPathForRow(0));
		if (treeManager == null) {
			treeManager = new CheckBoxTreeManager(this);
		}
	}

	@Override
	public void initTree(String filePath) {
		// TODO Auto-generated method stub
		this.getSelectionModel().setSelectionMode(
				TreeSelectionModel.SINGLE_TREE_SELECTION);
		btmItemNew.clear();
		qTWrapperNew.clear();
		norepQTDs.clear();
		qtExportData = null;
		if (filePath != null && !filePath.equals("")) {
			try {
				ObjectInputStream obj = new ObjectInputStream(
						new FileInputStream(filePath));
				this.qtExportData = (LinkQTExportData) obj.readObject();
			} catch (Exception e) {
				VCIOptionPane
						.showMessage(LogonApplication.frame, "导入对象未获取成功！！");
				e.printStackTrace();
			}
		}
		if(qtExportData == null){
			this.setModel(new DefaultTreeModel(new DefaultMutableTreeNode("链接类型")));
		}else{
			addImportData();
			LinkType[] btmArray = (LinkType[]) btmItemNew
					.toArray(new LinkType[btmItemNew.size()]);
			QTInfo[] qts = (QTInfo[]) qTWrapperNew
					.toArray(new QTInfo[qTWrapperNew.size()]);
			this.setModel(new DefaultTreeModel(new DefaultMutableTreeNode("链接类型")));
			DefaultTreeModel dtml = (DefaultTreeModel) this.getModel();
			DefaultMutableTreeNode node = (DefaultMutableTreeNode) this
					.getPathForRow(0).getLastPathComponent();
			addExportTreeNode(dtml, node, btmArray, qts);
			// 展开所有树节点
			TreeNode rootNode = (TreeNode) this.getModel().getRoot();
			TreePath rootPath = new TreePath(rootNode);
			this.expandAllTreeNode(rootPath, true);
		}
		
	//	this.expandPath(rootPath);
		if (treeManager == null) {
			treeManager = new CheckBoxTreeManager(this){
				 public void mouseClicked(MouseEvent me){
	               //覆盖点击选择事件			
				 }
			};
		}else{
			TreePath[] paths = treeManager.getSelectionModel().getSelectionPaths();
			if(paths != null)
			treeManager.getSelectionModel().removeSelectionPaths(paths);
		}
		treeManager.getSelectionModel().setSelectionPath(new TreePath(this.getModel().getRoot()));
		
		CheckBoxTreeCellRenderer render = (CheckBoxTreeCellRenderer)this.getCellRenderer();
	    this.updateUI();
		for (int i = 0; i < render.getComponentCount(); i++) {
			if( render.getComponent(i).getClass().getName().equals("com.vci.base.ui.swing.CheckBoxLabel") ){
				CheckBoxLabel label	= (CheckBoxLabel)render.getComponent(i);
				label.setEnabled(false);
			}			
		}
		// this.setVisible(false);
	}

	public Map<String, QTD[]> getNorepQTDs() {
		return norepQTDs;
	}

	public void setNorepQTDs(Map<String, QTD[]> norepQTDs) {
		this.norepQTDs = norepQTDs;
	}

	// 加载树节点
	private void addExportTreeNode(DefaultTreeModel dtml,
			DefaultMutableTreeNode node, LinkType[] allBtm, QTInfo[] qts) {
		// TODO Auto-generated method stub
		// node.removeAllChildren();
		String curBtmName = "";
		Object userObject = node.getUserObject();
		if (!(userObject instanceof String)) {
			// 链接类型对象节点
			if (userObject instanceof LinkQTExportBTMNode) {
				LinkType pac = ((LinkQTExportBTMNode) userObject).getBean();
				curBtmName = pac.name; // 链接类型名称
				/*for (LinkType plac : allBtm) {
					if (plac.fName.equals(curBtmName)) {
						QTExportBTMNode qtExportBTMNode = new QTExportBTMNode(
								plac);
						if (plac.name.endsWith("@#链接类型已存在$%")) {
							plac.name = plac.name.replace("@#链接类型已存在$%", "");
							qtExportBTMNode.setMessage("【链接类型已存在，不导入】");
						}
						if (plac.name.endsWith("@#链接类型存在但属性不一致$%")) {
							plac.name = plac.name.replace("@#链接类型存在但属性不一致$%",
									"");
							qtExportBTMNode.setMessage("【链接类型存在但属性不一致，不导入】");
						}
						if (plac.name.endsWith("@#链接类型不存在$%")) {
							plac.name = plac.name.replace("@#链接类型不存在$%", "");
							qtExportBTMNode.setMessage("【链接类型不存在，不导入】");
						}
						DefaultMutableTreeNode child = new DefaultMutableTreeNode(
								qtExportBTMNode);
						dtml.insertNodeInto(child, node, node.getChildCount());
						addExportTreeNode(dtml, child, allBtm, qts);
					}
				}*/
				// 添加查询模板对象子节点
				for (QTInfo qtItem : qts) {
					if ((!curBtmName.equals(""))
							&& qtItem.btmName.equals(curBtmName)) {

						QTExportQTNode exportQTNode = new QTExportQTNode(qtItem);
						/* TreePath newChildTreePath = new TreePath(newChild); */
						if (qtItem.qtName.endsWith("@#查询模板已存在，不导入$%")) {
							qtItem.qtName = qtItem.qtName.replace(
									"@#查询模板已存在，不导入$%", "");
							exportQTNode.setMessage("【查询模板已存在，不导入】");

						}
						if (qtItem.qtName.endsWith("@#查询模板所属链接类型属性不一致，不导入$%")) {
							qtItem.qtName = qtItem.qtName.replace(
									"@#查询模板所属链接类型属性不一致，不导入$%", "");
							exportQTNode.setMessage("【查询模板所属链接类型属性不一致，不导入】");
							
						}
						if (qtItem.qtName.endsWith("@#查询模板所属链接类型不存在，不导入$%")) {
							qtItem.qtName = qtItem.qtName.replace(
									"@#查询模板所属链接类型不存在，不导入$%", "");
							exportQTNode.setMessage("【查询模板所属链接类型不存在，不导入】");
							
						}
						if (qtItem.qtName.endsWith("@#查询模板不存在，导入$%")) {
							qtItem.qtName = qtItem.qtName.replace(
									"@#查询模板不存在，导入$%", "");
							exportQTNode.setMessage("【查询模板不存在，可导入】");
							exportQTNode.setFontColor(Color.black);
						}
						DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(
								exportQTNode);
						dtml.insertNodeInto(newChild, node,
								node.getChildCount());
					}
				}
			}
		} else {
			// 添加链接类型根节点
			for (LinkType plAction : allBtm) {
//				if (plAction.fName.equals("")) {
					LinkQTExportBTMNode qtExportBTMNode = new LinkQTExportBTMNode(
							plAction);
					if (plAction.name.endsWith("@#链接类型已存在$%")) {
						plAction.name = plAction.name
								.replace("@#链接类型已存在$%", "");
						qtExportBTMNode.setMessage("【链接类型已存在，不导入】");
					}

					if (plAction.name.endsWith("@#链接类型存在但属性不一致$%")) {
						plAction.name = plAction.name.replace(
								"@#链接类型存在但属性不一致$%", "");
						qtExportBTMNode.setMessage("【链接类型存在但属性或关联的业务类型不一致，不导入】");
					}
					if (plAction.name.endsWith("@#链接类型不存在$%")) {
						plAction.name = plAction.name
								.replace("@#链接类型不存在$%", "");
						qtExportBTMNode.setMessage("【链接类型不存在，不导入】");
					}
					DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(
							qtExportBTMNode);// , false
					dtml.insertNodeInto(newChild, node, node.getChildCount());
					addExportTreeNode(dtml, newChild, allBtm, qts);
//				}
			}
		}
		dtml.reload(node);
	}

	public CheckBoxTreeManager getTreeManager() {
		return treeManager;
	}

	public void setTreeManager(CheckBoxTreeManager treeManager) {
		this.treeManager = treeManager;
	}

	// 数据过滤
	private void addImportData() {
		// TODO Auto-generated method stub
		Map<String/* 类型名称 */, QTD[]/* 查询模板定义 */> allQTDs = this.qtExportData
				.getAllQTDs();
		Map<String/* 类型名称 */, LinkType/* 类型对象 */> selectedBtmItems = this.qtExportData
				.getSelectedBtmItems();
		Map<String/* 类型名称 */, String[]/* 类型所属属性 */> selectedBtmAttrs = this.qtExportData
				.getSelectedBtmAttrs();
		Map<String/* 查询模板名称 */, QTInfo/* 查询模板对象 */> allSelectedQTs = this.qtExportData
				.getAllQTs();
		if (allQTDs.size() == 0 || allQTDs == null
				|| selectedBtmItems.size() == 0 || selectedBtmItems == null
				|| selectedBtmAttrs.size() == 0 || selectedBtmAttrs == null
				|| allSelectedQTs.size() == 0 || allSelectedQTs == null) {
			VCIOptionPane.showMessage(LogonApplication.frame, "导入的模板数据有误！！！");
			return;
		}
		Set<Entry<String, QTD[]>> pLActions = allQTDs.entrySet();
		Set<Entry<String, QTInfo>> pLQts = allSelectedQTs.entrySet();
		Set<Entry<String, LinkType>> LinkpLQts = selectedBtmItems.entrySet();
		for (Entry<String, QTD[]> entry : pLActions) {
			String string = entry.getKey();
			QTD[] qtds = entry.getValue();
			getPLQtIsInDB(string, qtds);
			// getPLQtBtmItem(string);
		}
//		for (Entry<String, String[]> entry : pLAttrs) {
//			String string = entry.getKey();
//			String[] attrs = entry.getValue();
//			getPLQtBtmItem(string, attrs);
//		}
		for (Entry<String, LinkType> entry : LinkpLQts) {
			String string = entry.getKey();
			LinkType LinkType = entry.getValue();
			getPLQtBtmItem(string, LinkType);
		}
		for (Entry<String, QTInfo> entry : pLQts) {
			String string = entry.getKey();
			QTInfo qtWrapper = entry.getValue();
			getPLQtWrapper(string, qtWrapper);
		}

	}

	private void getPLQtWrapper(String string, QTInfo qtWrapper) {/*
		// TODO Auto-generated method stub
		try {
			QTInfo[] qtws = QTClient.getService().getAllQTS();
			boolean islaet = true;
			for (int i = 0; i < qtws.length; i++) {
				if (string.equals(qtws[i].qtName)) {
					qtws[i].qtName += "@#查询模板已存在，不导入$%";
					qTWrapperNew.add(qtws[i]);
					islaet = false;
				}
			}
			if (islaet) {
				qtWrapper.qtName += "@#查询模板不存在，导入$%";
				qTWrapperNew.add(qtWrapper);
			}
		} catch (VCIError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	*/
		// TODO Auto-generated method stub
		try {
			QTInfo[] qtws = ServiceProvider.getOMDService().getQTDService().getAllQTs();
			boolean islaet = true;
			for (int i = 0; i < qtws.length; i++) {
				if (string.equals(qtws[i].qtName)) {
					islaet = false;
					for (LinkType btmItem : btmItemNew) {
						if (qtWrapper.btmName.equals(btmItem.name.substring(0,
								btmItem.name.indexOf("@")))) {
							if (btmItem.name.endsWith("@#链接类型已存在$%")) {
								qtWrapper.qtName += "@#查询模板已存在，不导入$%";
								qTWrapperNew.add(qtWrapper);
							}else if(btmItem.name.endsWith("@#链接类型存在但属性不一致$%")){
								qtWrapper.qtName += "@#查询模板所属链接类型属性不一致，不导入$%";
								qTWrapperNew.add(qtWrapper);
							}else{
								qtWrapper.qtName += "@#查询模板所属链接类型不存在，不导入$%";
								qTWrapperNew.add(qtWrapper);
							}
						}
					}
//					qtws[i].qtName += "@#查询模板已存在，不导入$%";
//					qTWrapperNew.add(qtws[i]);					
				}
			}
			if (islaet) {
				for (LinkType btmItem : btmItemNew) {
					if (qtWrapper.btmName.equals(btmItem.name.substring(0,
							btmItem.name.indexOf("@")))) {
						if (btmItem.name.endsWith("@#链接类型已存在$%")) {
							qtWrapper.qtName += "@#查询模板不存在，导入$%";
							qTWrapperNew.add(qtWrapper);
						}else if(btmItem.name.endsWith("@#链接类型存在但属性不一致$%")){
							qtWrapper.qtName += "@#查询模板所属链接类型属性不一致，不导入$%";
							qTWrapperNew.add(qtWrapper);
						}else{
							qtWrapper.qtName += "@#查询模板所属链接类型不存在，不导入$%";
							qTWrapperNew.add(qtWrapper);
						}
					}
				}
//				qtWrapper.qtName += "@#查询模板不存在，导入$%";
//				qTWrapperNew.add(qtWrapper);
			}
		} catch (VCIError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private void getPLQtBtmItem(String string, LinkType linkType) {
		// TODO Auto-generated method stub
		try {
			// List<BtmItem> es = new ArrayList<BtmItem>();
//			BtmItem[] btmArray = BtmClient.getService().getAllBtmItem("");
			LinkType[] btmArray = LinkTypeStart.getService().getLinkTypes();
			String[] strings = LinkTypeStart.getService().getLinkType(string).attributes;
			String[] stringsFrom = LinkTypeStart.getService().getLinkType(string).btmItemsFrom;
			String[] stringsTo = LinkTypeStart.getService().getLinkType(string).btmItemsTo;
			boolean b = true;
			for (int i = 0; i < btmArray.length; i++) {
				if (btmArray[i].name.equals(string)) {
					b = false;
					if (Arrays.equals(linkType.attributes, strings)
							&& Arrays
									.equals(linkType.btmItemsFrom, stringsFrom)
							&& Arrays.equals(linkType.btmItemsTo, stringsTo)) {
						btmArray[i].name += "@#链接类型已存在$%";
						/* this.btmArray[i] = btmArray[i]; */
						btmItemNew.add(btmArray[i]);
					} else {
						btmArray[i].name += "@#链接类型存在但属性不一致$%";
						btmItemNew.add(btmArray[i]);
					}
				}
			}
			if (b) {				
				linkType.name += "@#链接类型不存在$%";
				btmItemNew.add(linkType);
			}

		} catch (VCIError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private void getPLQtIsInDB(String string, QTD[] qtds) {
		// TODO Auto-generated method stub
		try {
			QTD[] qtds2 = ServiceProvider.getOMDService().getQTDService().getBizTypeQTDs(string);
			QTD[] qtdsNewQtds = null;
			List<QTD> es = new ArrayList<QTD>();
			for (QTD qtd : qtds) {
				boolean isleat = true;
				for (int i = 0; i < qtds2.length; i++) {
					if (qtd.name.equals(qtds2[i].name)) {
						isleat = false;
						break;
					}
				}
				if (isleat) {
					es.add(qtd);
				}
			}
			if (es.size() != 0) {
				qtdsNewQtds = (QTD[]) es.toArray(new QTD[es.size()]);
				norepQTDs.put(string, qtdsNewQtds);
			}
			// qtExportDataNewData.setAllQTDs(norepQTDs);
		} catch (VCIError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public boolean hasSelectImportContent() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void exeImport(PrintWriter logFileWriter, JTable tblExportLog) {
		// TODO Auto-generated method stub

	}

	public String getExportDataFileName(String filePath, Long currentTimes) {
		// TODO Auto-generated method stub
		return filePath + File.separator + "VCIQTMODELFILE" + currentTimes
				+ ".log";
	}

}