package com.c2kernel.gui;

import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.ToolTipManager;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import com.c2kernel.gui.tree.Node;
import com.c2kernel.gui.tree.NodeEntity;
import com.c2kernel.lookup.DomainPath;
import com.c2kernel.utils.Logger;

/**
 * Container for the tree browser
 * @version $Revision: 1.31 $ $Date: 2006/01/17 07:49:44 $
 * @author  $Author: abranson $
 */

 // must put in top level list of loaded items, so we don't have duplicates
public class TreeBrowser extends JPanel implements DomainKeyConsumer
{
    private EntityTabManager desktop;
    protected JTree tree;
    private Node userRoot;

    public TreeBrowser(EntityTabManager target, Node userRoot) {
        setLayout(new java.awt.BorderLayout());
        //record the desktop and node factory for our item frames
        this.desktop = target;
        this.userRoot = userRoot;
        this.setPreferredSize(new Dimension(300, 500));
        tree = new JTree(new DefaultTreeModel(userRoot.getTreeNode()));
        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        tree.setToggleClickCount(3); // need three clicks to expand a branch
        tree.addTreeExpansionListener(
            new TreeExpansionListener() {
                @Override
				public void treeCollapsed(TreeExpansionEvent e) {
                    //REVISIT: possible reaping here if things are getting heavy
                }
                @Override
				public void treeExpanded(TreeExpansionEvent e) {
                    TreePath p = e.getPath();
                    // find the clicked tree node
                    DefaultMutableTreeNode nodeClicked = (DefaultMutableTreeNode)p.getLastPathComponent();
                    // run the tree builder if it is there.
                    DefaultMutableTreeNode loadNode = (DefaultMutableTreeNode)nodeClicked.getFirstChild();
                    if (loadNode.getUserObject() instanceof DynamicTreeBuilder) {
                        DynamicTreeBuilder loading = (DynamicTreeBuilder)loadNode.getUserObject();
                        if (loading.state == DynamicTreeBuilder.IDLE) {
                            loading.buildInfo(tree);
                            loading.start();
                        }
                    }
                }
            }
        );

        //Enable tool tips.
        ToolTipManager.sharedInstance().registerComponent(tree);
        tree.setCellRenderer(new ItemRenderer());
        tree.addMouseListener(new TreeMouseListener());
        JScrollPane myScrollPane = new JScrollPane(tree);
        this.add(myScrollPane);
        DefaultMutableTreeNode loadNode = (DefaultMutableTreeNode)userRoot.getTreeNode().getFirstChild();
        DynamicTreeBuilder loading = (DynamicTreeBuilder)loadNode.getUserObject();
        loading.buildInfo(tree);
        loading.start();
    }

    @Override
	public void push(DomainPath target) {
    	Logger.debug("Opening tree node "+target);
        String[] components = target.getPath();
        Node currentNode = userRoot;
        Object[] treePath = new Object[components.length+1];
        treePath[0] = currentNode.getTreeNode();
        for (int i=0; i<components.length; i++) {
            // create sub-path
            String[] newPath = new String[i+1];
            for (int j=0; j<newPath.length; j++)
                newPath[j] = components[j];
            DomainPath nextNodePath = new DomainPath(newPath);
            Node nextNode = currentNode.getChildNode(nextNodePath);
            if (nextNode == null) {
                Logger.msg(6, "TreeBrowser.push() - creating "+nextNodePath);
                nextNode = currentNode.newNode(nextNodePath);
                currentNode.add(nextNode);
                DynamicTreeBuilder builder = currentNode.getTreeBuilder();
                builder.buildInfo(tree);
                builder.add(nextNode);
            }
            treePath[i+1] = nextNode.getTreeNode();
            currentNode = nextNode;
        }
        // select it
        TreePath targetNode = new TreePath(treePath);
        if (Logger.doLog(5)) dumpPath(targetNode, 5);

        tree.clearSelection();
        tree.addSelectionPath(targetNode);
        tree.makeVisible(targetNode);
        // open it
        if (currentNode instanceof NodeEntity) {
            MainFrame.status.setText("Opening "+currentNode.getName());
            desktop.add((NodeEntity)currentNode);
            MainFrame.status.setText("Done");
        }
    }

    @Override
	public void push(String name) {
    	// only interested in real paths
        JOptionPane.showMessageDialog(null, "'"+name+"' was not found.",
            "No results", JOptionPane.INFORMATION_MESSAGE);

    }

    private static void dumpPath(TreePath selPath, int logLevel) {
        if (selPath == null) { Logger.msg(logLevel, "TreeBrowser.dumpPath() - selPath null"); return; }
        for (int i =0; i<selPath.getPath().length; i++)
            Logger.msg(logLevel, "TreeBrowser.dumpPath() - selPath "+i+" = "+selPath.getPath()[i]);
    }

    private class ItemRenderer extends DefaultTreeCellRenderer {
        public ItemRenderer() {
        }

        @Override
		public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf,
            int row, boolean hasFocus) {
                super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
                Object thisLeaf = ((DefaultMutableTreeNode)value).getUserObject();
                if (thisLeaf instanceof Node) {
                    Node thisNode = (Node)thisLeaf;
                    if (thisNode.getIcon() !=null) setIcon(thisNode.getIcon());
                    setToolTipText(thisNode.getType());
                }
                else if (thisLeaf instanceof DynamicTreeBuilder) {
                    DynamicTreeBuilder thisLoader = (DynamicTreeBuilder)thisLeaf;
                    ImageIcon loadGif = thisLoader.getIcon();
                    setIcon(loadGif);
                    loadGif.setImageObserver(tree);
                    setToolTipText("Tree Content Loader");
                }
                return this;
        }
    }

    private class TreeMouseListener extends MouseAdapter {
    	@Override
		public void mousePressed(MouseEvent e) {
    		if (e.isPopupTrigger())
    			showPopup(e);
    		else {
    			Object source = getNodeAt(e);
                if (source == null) return;
    			if (e.getClickCount() == 2) {
                    if (source instanceof NodeEntity) {
                        NodeEntity thisNode = (NodeEntity)source;
    	                desktop.add(thisNode);
                        MainFrame.status.setText("Opened "+thisNode.getName());
            	    }
                    if (source instanceof DynamicTreeBuilder) {
                        DynamicTreeBuilder thisLoader = (DynamicTreeBuilder)source;
                        if (thisLoader.state == DynamicTreeBuilder.PARTIAL)
                            thisLoader.start();
                    }
                }
    		}
    	}
        @Override
		public void mouseReleased(MouseEvent e) {
            if (e.isPopupTrigger()) {
            	showPopup(e);
            }
        }
        private void showPopup(MouseEvent e) {
        	Object source = getNodeAt(e);
            if (source == null) return;
        	if (source instanceof Node) {
               	Node thisNode = (Node)source;
	           	thisNode.getPopupMenu().show(e.getComponent(), e.getX(), e.getY());
        	}
        }
        private Object getNodeAt(MouseEvent e) {
            Object source = null;
            TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
            if (selPath != null)
                try {
                    DefaultMutableTreeNode nodeClicked = (DefaultMutableTreeNode)selPath.getLastPathComponent();
                    source = nodeClicked.getUserObject(); // fetch its nodeItem
                }
            catch (Exception ex) { } // Not a node that was clicked on

            return source;
        }
    }
}