package com.vci.client.workflow.task;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;

import javax.swing.JComponent;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
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.swing.VCISwingUtil;
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;

/**
 * 申请任务任务箱                                  
 * @author liudi
 *
 * 2013-1-4
 */
public class ApplicationTaskPanel 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;
	private JPopupMenu taskMenu;
	FunctionObject funcObject = new FunctionObject();
	private JMenuItem refMenuItem = new JMenuItem("刷新", VCISwingUtil.createImageIcon("arrow_refresh.png"));//刷新
	public ApplicationTaskPanel(FunctionObject object) {
		super(object);
		this.funcObject = object;
		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);
		refMenuItem.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				TreePath selectionPath = leftTree.getSelectionPath();
				treeInitRightData(selectionPath);
				updateTree();
			}
		});
		initLeftPanel(leftScrPane);
		setComponentPopupMenu(leftTree, getWorkFlowMenu());
	}

	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();
		treeInitRightData(treePath);
	}

	/**
	 * 加载右侧数据
	 * @param treePath
	 */
	private void treeInitRightData(TreePath treePath) {
		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 = null;
				if(funcObject.isShowTodoData()){
					instance = TodoTaskPanel.getInstance(funcObject,idName.getTaskType());
					LinkedHashMap<String, String[]>  map = funcObject.getMap();
					instance.setShowDataIds(map.get("taskId"));
				}else{
					instance = TodoTaskPanel.getInstance(funcObject,idName.getTaskType());
				}
				instance.initData();
				instance.initializeData();
				splitPane.setRightComponent(instance);
				if(funcObj.isShowTodoData()){
					instance.setTableToSelect();
				}
			} else if ("donetask".equals(idName.getId())) {
				DoneTaskPanel doneTaskPanel = DoneTaskPanel.getInstance(funcObject,idName.getTaskType());
				doneTaskPanel.initData();
				splitPane.setRightComponent(doneTaskPanel);
			} else if ("tracktask".equals(idName.getId())) {
				TrackTaskPanel instance = TrackTaskPanel.getInstance(funcObject,idName.getTaskType());
				instance.initializeData();
				splitPane.setRightComponent(instance);
			} else if("doneprocess".equals(idName.getId())){
				DoneProcessPanel doneProcessPanel = DoneProcessPanel.getInstance(funcObject,idName.getTaskType());
				doneProcessPanel.initData();
				splitPane.setRightComponent(doneProcessPanel);
			}
		} 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) {
		VCIBaseTreeNode selectNode = treeNode;
		String selectTreeNodeName = "";
		if(funcObj.isShowTodoData()){
			selectTreeNodeName = funcObj.getMap().get("taskType")[0];
		}
		treeNode.removeAllChildren();
		List<IdName> taskTypes = getTaskTypes();
		boolean flag = true;
		for (IdName obj : taskTypes) {
			VCIBaseTreeNode node = new VCIBaseTreeNode(obj.getName(), obj);
			if(flag && obj.getName().equals(selectTreeNodeName)){
				selectNode = node;
				flag = false;
			}
			node.setLeaf(true);
			treeNode.add(node);
		}
		
		this.leftTree.setSelectionPath(new TreePath(treeModel.getPathToRoot(selectNode)));
		this.leftTree.updateUI();
	}

	private List<IdName> getTaskTypes() {
		List<IdName> taskTypes = new ArrayList<IdName>();
		taskTypes.add(new IdName("todotask", "待办任务","0"));
//		taskTypes.add(new IdName("donetask", "已办任务","0"));
		taskTypes.add(new IdName("doneprocess", "已完成流程","0"));
		taskTypes.add(new IdName("tracktask", "跟踪任务","0"));
		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());
	}
	
	private JPopupMenu getWorkFlowMenu() {
		if(taskMenu == null) {
			taskMenu = new JPopupMenu();
		}
		return taskMenu;
	}
	
	/**
	 * 右键菜单
	 * @param parent
	 * @param menu
	 */
	private void setComponentPopupMenu(final java.awt.Component parent,
			final javax.swing.JPopupMenu menu) {
		parent.addMouseListener(new java.awt.event.MouseAdapter() {
			public void mouseReleased(java.awt.event.MouseEvent e) {
				
				int x = e.getX();
				int y = e.getY();
				TreePath treePath = leftTree.getPathForLocation(x, y);
				if(treePath == null) return;
				
				leftTree.setSelectionPath(treePath);
				
				
				Object currentSelectedObject = getCurrentSelectedObject();
				taskMenu.add(refMenuItem);
				if (currentSelectedObject!=null&&e.isPopupTrigger()){
					menu.show(parent, e.getX(), e.getY());
				}
			}

//			public void mouseReleased(java.awt.event.MouseEvent e) {
//				if (e.isPopupTrigger())
//					menu.show(parent, e.getX(), e.getY());
//			}
		});
	}
}