package com.vci.client.workflow.task;

import java.awt.BorderLayout;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import com.vci.client.LogonApplication;
import com.vci.client.common.VCIBasePanel;
import com.vci.client.framework.rightConfig.object.FunctionObject;
import com.vci.client.ui.tree.VCIBaseTree;
import com.vci.client.ui.tree.VCIBaseTreeModel;
import com.vci.client.ui.tree.VCIBaseTreeNode;
import com.vci.client.workflow.commom.ClientHelper;
import com.vci.client.workflow.template.ProcessDefinitionPanel;
import com.vci.client.workflow.template.object.ProcessCategoryObject;
import com.vci.client.workflow.template.object.ProcessDefinitionObject;

public class ProcessTaskPanel extends VCIBasePanel {

	private static final long serialVersionUID = 3904757499482930815L;

	private VCIBaseTree leftTree = null;
	private VCIBaseTreeModel treeModel = null;
	private VCIBaseTreeNode rootNode = null;

	private ProcessTaskToolBar toolBar = null;
	JComponent rightPanel = null;
	JPanel rightEmptyPanel = new JPanel();

	private JSplitPane splitPane;
	
	FunctionObject funcObj = new FunctionObject();
	public ProcessTaskPanel(FunctionObject funcObj){
		super(funcObj);
		LogonApplication.getUserEntityObject().setModules(this.getClass().getName());
		init();
	}

	private void init() {
		JScrollPane leftScrPane = new JScrollPane();
		splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftScrPane, rightEmptyPanel);
		splitPane.setDividerSize(10);
		splitPane.setContinuousLayout(true);
		splitPane.setOneTouchExpandable(true);
		splitPane.setDividerLocation(200);
		this.setLayout(new BorderLayout());
		this.add(splitPane, BorderLayout.CENTER);
		initLeftPanel(leftScrPane);
	}

	private void initLeftPanel(JScrollPane leftJsp) {
		String rootObj = "root";
		rootNode = new VCIBaseTreeNode(this.getI18nString("treeRootNodeName"), rootObj);
		treeModel = new VCIBaseTreeModel(rootNode);
		leftTree = new VCIBaseTree(treeModel, new ProcessTaskTreeCellRender());
		leftTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
		leftTree.addTreeSelectionListener(new TreeSelectionListener() {
			public void valueChanged(TreeSelectionEvent e) {
				treeValueChanged(e);
			}
		});
		leftTree.addTreeExpansionListener(new TreeExpansionListener() {
			public void treeExpanded(TreeExpansionEvent event) {
				TreePath treePath = event.getPath();
				VCIBaseTreeNode selectNode = (VCIBaseTreeNode) treePath.getLastPathComponent();
				if (!selectNode.isExpand()&&!selectNode.getObj().equals("root")) {
					selectNode.removeAllChildren();
					getExpandTreeData(selectNode);
				}
			}

			public void treeCollapsed(TreeExpansionEvent event) {
			}
		});
		leftJsp.getViewport().add(leftTree);
		initLeftTree(rootNode);
	}

	protected void treeValueChanged(TreeSelectionEvent e) {
		TreePath treePath = e.getPath();
		if (treePath == null) {
			splitPane.setRightComponent(rightEmptyPanel);
			return;
		}

		VCIBaseTreeNode selectNode = (VCIBaseTreeNode) treePath.getLastPathComponent();
		Object object = selectNode.getObj();
		ProcessDefinitionObject processDefinitionObject = null;

		if (object instanceof ProcessDefinitionObject) {
			processDefinitionObject = (ProcessDefinitionObject) object;
			if (rightPanel == null) {
				rightPanel = new ProcessDefinitionPanel();
			}
			((ProcessDefinitionPanel) rightPanel).setObject(processDefinitionObject);
			splitPane.setRightComponent(rightPanel);
		} else if (object instanceof IdName) {
			IdName idName = (IdName) object;
			if ("todotask".equals(idName.getId())) {
				TodoTaskPanel instance = TodoTaskPanel.getInstance(funcObj,"");
//				instance.initData();
				instance.initializeData();
				splitPane.setRightComponent(instance);
			} else if ("donetask".equals(idName.getId())) {
				DoneTaskPanel doneTaskPanel = DoneTaskPanel.getInstance(funcObj,"");
				doneTaskPanel.initData();
				splitPane.setRightComponent(doneTaskPanel);
			} else if ("tracktask".equals(idName.getId())) {
				TrackTaskPanel instance = TrackTaskPanel.getInstance(funcObj,"");
				instance.initializeData();
				splitPane.setRightComponent(instance);
			}
//			else if("CCtask".equals(idName.getId())){
//				CCTaskPanel instance = CCTaskPanel.getInstance();
////				instance.initData();
//				instance.initializeData();
//				splitPane.setRightComponent(instance);
//			}
			else if("processControl".equals(idName.getId())){
				ProcessControlPanel instance = ProcessControlPanel.getInstance("");
//				instance.initData();
				instance.initializeData();
				splitPane.setRightComponent(instance);
			}
		} else {
			splitPane.setRightComponent(rightEmptyPanel);
		}
		int location = splitPane.getDividerLocation();
		splitPane.setDividerLocation(location);
	}

	public ProcessTaskToolBar getSpecialToolBar() {
		if (toolBar == null) {
			toolBar = new ProcessTaskToolBar(LogonApplication.frame, this);
		}
		return toolBar;
	}

	/**
	 * 返回当前选中的树节点
	 * 
	 * @return
	 */
	public VCIBaseTreeNode getCurrentSelectedTreeNode() {
		return (VCIBaseTreeNode) this.leftTree.getLastSelectedPathComponent();
	}

	public Object getCurrentSelectedObject() {
		return this.getCurrentSelectedTreeNode().getObj();
	}

	/**
	 * toolbar上的刷新按钮会调用该方法
	 */
	public void updateTree() {
		((VCIBaseTreeNode) this.leftTree.getLastSelectedPathComponent()).removeAllChildren();
		getExpandTreeData(((VCIBaseTreeNode) this.leftTree.getLastSelectedPathComponent()));
		this.leftTree.updateUI();
	}

	private void getExpandTreeData(VCIBaseTreeNode treeNode) {
		// try{
		String processCategoryId = "";
		Object nodeObject = treeNode.getObj();
		if (nodeObject instanceof String && nodeObject.toString().equals("root")) {
			initLeftTree(rootNode);
		} else {
			/*
			 * if (nodeObject instanceof ProcessCategoryObject) { processCategoryId = ((ProcessCategoryObject)nodeObject).getId(); } else if (nodeObject instanceof RMTypeObject) {
			 * TreeNode[] treeNodes = treeNode.getPath(); processCategoryId = ((ProcessCategoryObject)(((VCIBaseTreeNode)treeNodes[1]).getObj())).getId(); } //TODO refresh tree
			 * from db ProcessCategoryObject[] processCategories = new ProcessCustomClientDelegate(LogonApplication.getUserEntityObject()).getProcessCategories(processCategoryId);
			 * for (ProcessCategoryObject obj : processCategories) { VCIBaseTreeNode node = new VCIBaseTreeNode(obj.getName(), obj); treeModel.insertNodeInto(node, treeNode,
			 * treeNode.getChildCount()); treeNode.setExpand(true); }
			 * 
			 * ProcessDefinitionObject[] processDefinitions = new ProcessCustomClientDelegate(LogonApplication.getUserEntityObject()).getProcessDefinitions(processCategoryId); for
			 * (ProcessDefinitionObject processDefinitionObject : processDefinitions) { VCIBaseTreeNode node = new VCIBaseTreeNode(processDefinitionObject.getName(),
			 * processDefinitionObject); treeModel.insertNodeInto(node, treeNode, treeNode.getChildCount()); treeNode.setExpand(true); }
			 */
		}
		/*
		 * }catch(VCIException ex){ VCIOptionPane.showError(LogonApplication.frame, "RMIPWorkflow", ex); }
		 */
	}

	public void initLeftTree() {
		initLeftTree(this.rootNode);
	}

	public void initLeftTree(VCIBaseTreeNode treeNode) {
		// try{
		/*
		 * ProcessCustomClientDelegate delSrv = new ProcessCustomClientDelegate(LogonApplication.getUserEntityObject()); ProcessCategoryObject[] processCategories =
		 * delSrv.getProcessCategories("root");
		 */
		treeNode.removeAllChildren();
		List<IdName> taskTypes = getTaskTypes();
		for (IdName obj : taskTypes) {
			VCIBaseTreeNode node = new VCIBaseTreeNode(obj.getName(), obj);
			node.setLeaf(true);
			treeNode.add(node);
		}
		this.leftTree.setSelectionPath(new TreePath(treeNode));
		this.leftTree.updateUI();
		/*
		 * } catch (VCIException e) { VCIOptionPane.showError(LogonApplication.frame, "RMIPWorkflow", e); return; }
		 */
	}

	private List<IdName> getTaskTypes() {
		List<IdName> taskTypes = new ArrayList<IdName>();
//		taskTypes.add(new IdName("CCtask", "抄送给我的任务","0"));
		taskTypes.add(new IdName("todotask", "待办任务",""));
		taskTypes.add(new IdName("donetask", "已办任务",""));
		taskTypes.add(new IdName("tracktask", "跟踪任务",""));
//		taskTypes.add(new IdName("processControl", "流程监控",""));
		return taskTypes;
	}

	public void setEmptyPanel() {
		splitPane.setRightComponent(rightEmptyPanel);
		int location = splitPane.getDividerLocation();
		splitPane.setDividerLocation(location);
	}

	public void addNewObjectToTree(ProcessCategoryObject object) {
		VCIBaseTreeNode newNode = new VCIBaseTreeNode(object.getName(), object);
		this.treeModel.insertNodeInto(newNode, getCurrentSelectedTreeNode(), getCurrentSelectedTreeNode().getChildCount());
		this.leftTree.setSelectionPath(new TreePath(newNode.getPath()));
		this.leftTree.updateUI();
	}

	public void refreshModifyObjectToTree(ProcessCategoryObject object) {
		VCIBaseTreeNode modifyNode = getCurrentSelectedTreeNode();
		modifyNode.setUserObject(object.getName());
		modifyNode.setObj(object);
		this.leftTree.setSelectionPath(new TreePath(modifyNode.getPath()));
		this.leftTree.updateUI();
	}

	public void removeNode(VCIBaseTreeNode treeNode) {
		treeNode.removeFromParent();
		this.leftTree.updateUI();
	}

	public VCIBaseTree getLeftTree() {
		return leftTree;
	}

	private String getI18nString(String spCode) {
		return ClientHelper.getI18nStringForWorkflow(this.getClass().getName() + "." + spCode, this.getLocale());
	}
}