path: root/dozentenmodul/src/main/java/org/openslx/dozmod/gui/control/LocationSelector.java

package org.openslx.dozmod.gui.control;

import java.awt.Component;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;

import javax.swing.Box;
import javax.swing.ButtonGroup;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openslx.bwlp.thrift.iface.Location;
import org.openslx.dozmod.gui.Gui;
import org.openslx.dozmod.gui.changemonitor.AbstractControlWrapper;
import org.openslx.dozmod.gui.changemonitor.DialogChangeMonitor;
import org.openslx.dozmod.gui.control.JCheckBoxTree.CheckChangeEventListener;
import org.openslx.dozmod.gui.helper.GridManager;
import org.openslx.dozmod.gui.helper.I18n;
import org.openslx.dozmod.thrift.Session;
import org.openslx.dozmod.thrift.cache.MetaDataCache;
import org.openslx.thrifthelper.Comparators;
import org.openslx.util.QuickTimer;
import org.openslx.util.QuickTimer.Task;

/**
 * 
 * Widget to select the locations of a lecture. The UI is simply two JLists and
 * a button panel to move the elements from one list to the other. Use the
 * getters to read the values of the lists/checkbox: get
 * 
 * @author Jonathan Bauer
 * 
 */
public class LocationSelector extends JPanel {

	/**
	 * Version for serialization.
	 */
	private static final long serialVersionUID = 3847194308363804953L;

	private final static Logger LOGGER = LogManager.getLogger(LocationSelector.class);

	private final JRadioButton btnLimitToLocations;
	private final JRadioButton btnPrioritizeInLocations;
	private final ButtonGroup grpLocationExclusive;
	/**
	 * Flag for the initialization state
	 */
	private boolean initDone = false;

	/**
	 * List of IDs of locations to set the selection to when we finished
	 * initializing
	 */
	private List<Integer> preselection = null;
	
	private JCheckBoxTree locationTree = new JCheckBoxTree();
	private HashMap<Integer, DefaultMutableTreeNode> locationNodesMap = new HashMap<Integer, DefaultMutableTreeNode>();

	private AbstractControlWrapper<?> treeChangeHandler = null;

	/**
	 * Constructor. Initializes the grid layout, the location lists and
	 * initializes the data
	 */
	public LocationSelector() {
		btnLimitToLocations = new JRadioButton(
				I18n.CONTROL.getString("LocationSelector.RadioButton.limitToLocations.text"));
		btnPrioritizeInLocations = new JRadioButton(
				I18n.CONTROL.getString("LocationSelector.RadioButton.prioritizeInLocations.text"));
		btnPrioritizeInLocations.setSelected(true);

		grpLocationExclusive = new ButtonGroup();
		grpLocationExclusive.add(btnLimitToLocations);
		grpLocationExclusive.add(btnPrioritizeInLocations);

		// build the grid
		GridManager grid = new GridManager(this, 1);
		grid.add(new JScrollPane(locationTree)).fill(true, true).expand(true, true);
		grid.nextRow();
		grid.add(btnLimitToLocations);
		grid.nextRow();
		grid.add(btnPrioritizeInLocations);
		grid.nextRow();
		grid.add(Box.createVerticalGlue());
		grid.nextRow();
		grid.finish(false);

		// initialise the data
		init();
	}

	/**
	 * Async fetching of the list of the locations from the server
	 */
	private void init() {
		QuickTimer.scheduleOnce(new Task() {
			@Override
			public void fire() {
				final List<Location> locsList = MetaDataCache.getLocations();
				if (locsList == null)
					return;
				Gui.asyncExec(new Runnable() {
					@Override
					public void run() {
						fillLocationsList(locsList);
						initDone = true;
						// check if preselection was set before we were done
						// initialising
						if (preselection != null) {
							setSelectionInternal(preselection);
							preselection = null;
							if (treeChangeHandler != null) {
								treeChangeHandler.reset();
							}
						}
					}
				});
			}
		});
	}

	/**
	 * Sets the list of available locations. Should be called with the list of
	 * locations given by the server. This function will build the tree
	 * represented by the 'locationid'/'parentlocationid' fields of locations
	 * and set the generated tree as model for the JCheckboxTree used in the UI
	 * of this widget.
	 * 
	 * @param locations list of locations to set the available list to
	 */
	private void fillLocationsList(final List<Location> locations) {
		DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(Session.getSatelliteAddress());
		DefaultTreeModel treeModel = new DefaultTreeModel(rootNode, true);
		// build map containing the node object for each location
		for (Location loc : locations) {
			if (loc == null)
				continue;
			locationNodesMap.put(loc.getLocationId(), new DefaultMutableTreeNode(loc, true));
		}
		// now go over nodes and insert em
		for (Integer id : locationNodesMap.keySet()) {
			Location location = MetaDataCache.getLocationById(id);
			if (location == null)
				continue;
			// determine which node this is a child of
			DefaultMutableTreeNode parentNode = null;
			if (location.getParentLocationId() == 0)
				parentNode = rootNode;
			else
				parentNode = locationNodesMap.get(location.getParentLocationId());
			// determine the right index to insert the child into
			int childrenCount = parentNode.getChildCount();
			int insertionIndex = childrenCount;
			if (childrenCount != 0) {
				// loop through kids
				Enumeration<?> enumeration = parentNode.children();
				while (enumeration.hasMoreElements()) {
					DefaultMutableTreeNode currentChild = (DefaultMutableTreeNode) enumeration.nextElement();
					if (currentChild == null)
						continue;
					Location childLocation = (Location) currentChild.getUserObject();
					if (childLocation == null)
						continue;
					if (Comparators.location.compare(location, childLocation) <= 0) {
						insertionIndex = parentNode.getIndex(currentChild);
						break;
					}
				}
			}
			// insert the current node in the tree model
			treeModel.insertNodeInto(locationNodesMap.get(location.getLocationId()), // what
					parentNode, // parent?
					insertionIndex); // index

		}
		locationTree.setModel(treeModel);
		locationTree.updateUI();
		locationTree.repaint();
	}

	/**
	 * Setter for the "show only in selection" checkbox
	 * 
	 * @param limited true to enable the "limited" radio button, false to enable
	 *            the other
	 */
	public void setOnlyInSelection(boolean limited) {
		btnLimitToLocations.setSelected(limited);
		btnPrioritizeInLocations.setSelected(!limited);
	}

	/**
	 * Getter for the "show only in selection" checkbox
	 * 
	 * @return true if checked, false otherwise
	 */
	public boolean getOnlyInSelection() {
		return btnLimitToLocations.isSelected();
	}

	/**
	 * Sets the selection to the locations corresponding to the given list of
	 * ids.
	 * 
	 * @param list location ids to select
	 */
	public void setSelectedLocationsAsIds(List<Integer> list) {
		if (list == null) {
			LOGGER.error("No list given!");
			return;
		}
		if (initDone) {
			// if we are already initialised, we need to explicitly set the selection
			setSelectionInternal(list);
		} else {
			if (treeChangeHandler != null) {
				treeChangeHandler.mute();
			}
			preselection = list;
		}
	}

	/**
	 * Gets the selected locations as a list of id's
	 * 
	 * @return list of ids of the selection as Integer, empty list if the
	 *         selection is empty
	 */
	public List<Integer> getSelectedLocationsAsIds() {
		TreePath[] paths = locationTree.getCheckedPaths();
		if (paths == null || paths.length == 0) {
			return new ArrayList<Integer>();
		}
		// first try to reduce the amount of locations pushed to the server
		// by removing those which are implicitly selected:
		// all children of a node in the selection => keep only parent
		// transform the array of paths to a list of leaf nodes
		List<TreePath> leavesPathsList = new ArrayList<TreePath>();
		for (TreePath path : paths) {
			DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
			if (node != null && node.isLeaf()) {
				leavesPathsList.add(path);
			}
		}

		List<TreePath> currentList = leavesPathsList;
		List<TreePath> tmp;
		do {
			tmp = currentList;
			currentList = minify(currentList);
		} while (!tmp.equals(currentList));

		// now get the locationId of the nodes in the TreePath list
		List<Integer> idList = new ArrayList<Integer>(currentList.size());
		// iterate over the paths
		for (TreePath path : currentList) {
			if (path == null)
				continue;
			DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) path.getLastPathComponent();
			if (currentNode == null)
				continue;
			Object currentDataObject = currentNode.getUserObject();
			if (currentDataObject instanceof Location) {
				Location currentLocation = (Location) currentDataObject;
				idList.add(currentLocation.getLocationId());
			}
		}
		Collections.sort(idList);
		return idList;
	}

	/**
	 * Minimize the given set of TreePath: if all children of an inner node are
	 * selected, remove all child from the result list and just keep the inner
	 * node
	 * 
	 * @param leavesPathsList as a List of TreePath to minimize
	 * @return Resulting minimal list of TreePaths
	 */
	private List<TreePath> minify(final List<TreePath> leavesPathsList) {
		List<TreePath> resultList = new ArrayList<TreePath>();
		for (TreePath leaf : leavesPathsList) {
			DefaultMutableTreeNode leafNode = (DefaultMutableTreeNode) leaf.getLastPathComponent();
			if (leafNode.getParent() == null)
				continue;
			if (leafNode.getLevel() == 1) {
				resultList.add(getPath(leafNode));
				continue;
			}
			Enumeration<?> leafSiblings = leafNode.getParent().children();
			List<TreePath> selectedSiblings = new ArrayList<TreePath>();
			while (leafSiblings.hasMoreElements()) {
				DefaultMutableTreeNode leafSibling = (DefaultMutableTreeNode) leafSiblings.nextElement();
				if (leavesPathsList.contains(getPath(leafSibling))) {
					selectedSiblings.add(getPath(leafSibling));
				}
			}
			if (selectedSiblings.size() == leafNode.getParent().getChildCount()) {
				// all selected, keep parent
				if (!resultList.contains(getPath(leafNode.getParent())))
					resultList.add(getPath(leafNode.getParent()));
			} else {
				for (TreePath sibling : selectedSiblings) {
					if (!resultList.contains(sibling))
						resultList.add(sibling);
				}
			}
		}
		return resultList;
	}

	/**
	 * Helper to get the TreePath of the given TreeNode
	 * 
	 * @param treeNode node to get the TreePath of
	 * @return TreePath of the given TreeNode if it can be determined, null
	 *         otherwise
	 */
	public static TreePath getPath(TreeNode treeNode) {
		List<Object> nodes = new ArrayList<Object>();
		if (treeNode != null) {
			nodes.add(treeNode);
			treeNode = treeNode.getParent();
			while (treeNode != null) {
				nodes.add(0, treeNode);
				treeNode = treeNode.getParent();
			}
		}
		return nodes.isEmpty() ? null : new TreePath(nodes.toArray());
	}

	/**
	 * Internal helper to set the selection of the list of location
	 * corresponding the the given list of ids
	 * 
	 * @param list ids to set the selected locations to
	 */
	private void setSelectionInternal(List<Integer> list) {
		if (list == null || list.isEmpty()) {
			return;
		}
		// first, deselect everything
		List<TreePath> selectedPathsList = new ArrayList<>(Math.max(MetaDataCache.getLocations().size(),
				list.size()));
		for (Location location : MetaDataCache.getLocations()) {
			DefaultMutableTreeNode current = locationNodesMap.get(location.locationId);
			if (current == null)
				continue;
			TreePath path = new TreePath(current.getPath());
			selectedPathsList.add(path);
		}
		locationTree.setCheckedState(selectedPathsList, false);
		// get the paths in the tree of the given id list of nodes
		selectedPathsList.clear();
		for (Integer id : list) {
			DefaultMutableTreeNode current = locationNodesMap.get(id);
			if (current == null)
				continue;
			TreePath path = new TreePath(current.getPath());
			selectedPathsList.add(path);
		}
		locationTree.setCheckedState(selectedPathsList, true);
		locationTree.repaint();
	}

	public void addToChangeMonitor(DialogChangeMonitor changeMonitor) {
		treeChangeHandler = changeMonitor.add(locationTree);
		changeMonitor.add(grpLocationExclusive);
	}

	public void addCheckChangeEventListener(CheckChangeEventListener checkChangeEventListener) {
		locationTree.addCheckChangeEventListener(checkChangeEventListener);
	}
}

class LocationRenderer extends DefaultListCellRenderer {

	/**
	 * Version for serialization.
	 */
	private static final long serialVersionUID = -2460263478937939299L;

	@Override
	public Component getListCellRendererComponent(JList<? extends Object> list, Object value, int index,
			boolean isSelected, boolean cellHasFocus) {
		if (value instanceof Location) {
			return super.getListCellRendererComponent(list, ((Location) value).getLocationName(), index,
					isSelected, cellHasFocus);
		}
		return super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
	}
}