package org.jdesktop.swingx.search;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.security.AccessControlException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Logger;
import java.util.prefs.BackingStoreException;
import java.util.prefs.Preferences;

import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JTextField;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

import org.jdesktop.swingx.JXSearchField;
import org.jdesktop.swingx.plaf.UIManagerExt;

/**
 * Maintains a list of recent searches and persists this list automatically
 * using {@link Preferences}. A recent searches popup menu can be installed on
 * a {@link JXSearchField} using {@link #install(JXSearchField)}.
 * 
 * @author Peter Weishapl <petw@gmx.net>
 * 
 */
public class RecentSearches implements ActionListener {
	private Preferences prefsNode;

	private int maxRecents = 5;

	private List<String> recentSearches = new ArrayList<String>();

	private List<ChangeListener> listeners = new ArrayList<ChangeListener>();

	/**
	 * Creates a list of recent searches and uses <code>saveName</code> to
	 * persist this list under the {@link Preferences} user root node. Existing
	 * entries will be loaded automatically.
	 * 
	 * @param saveName
	 *            a unique name for saving this list of recent searches
	 */
	public RecentSearches(String saveName) {
		this(null, saveName);
	}

	/**
	 * Creates a list of recent searches and uses <code>saveName</code> to
	 * persist this list under the <code>prefs</code> node. Existing entries
	 * will be loaded automatically.
	 * 
	 * @param prefsNode
	 *            the preferences node under which this list will be persisted.
	 *            If prefsNode is <code>null</code> the preferences node will
	 *            be set to the user root node
	 * @param saveName
	 *            a unique name for saving this list of recent searches. If
	 *            saveName is <code>null</code>, the list will not be
	 *            persisted
	 */
	public RecentSearches(Preferences prefs, String saveName) {
		if (prefs == null) {
			try {
				prefs = Preferences.userRoot();
			} catch (AccessControlException ace) {
				// disable persistency, if we aren't allowed to access
				// preferences.
				Logger.getLogger(getClass().getName()).warning("cannot acces preferences. persistency disabled.");
			}
		}

		if (prefs != null && saveName != null) {
			this.prefsNode = prefs.node(saveName);
			load();
		}
	}

	private void load() {
		// load persisted entries
		try {
			String[] recent = new String[prefsNode.keys().length];
			for (String key : prefsNode.keys()) {
				recent[prefsNode.getInt(key, -1)] = key;
			}
			recentSearches.addAll(Arrays.asList(recent));
		} catch (Exception ex) {
			// ignore
		}
	}

	private void save() {
		if (prefsNode == null) {
			return;
		}

		try {
			prefsNode.clear();
		} catch (BackingStoreException e) {
			// ignore
		}

		int i = 0;
		for (String search : recentSearches) {
			prefsNode.putInt(search, i++);
		}
	}

	/**
	 * Add a search string as the first element. If the search string is
	 * <code>null</code> or empty nothing will be added. If the search string
	 * already exists, the old element will be removed. The modified list will
	 * automatically be persisted.
	 * 
	 * If the number of elements exceeds the maximum number of entries, the last
	 * entry will be removed.
	 * 
	 * @see #getMaxRecents()
	 * @param searchString
	 *            the search string to add
	 */
	public void put(String searchString) {
		if (searchString == null || searchString.trim().length() == 0) {
			return;
		}

		int lastIndex = recentSearches.indexOf(searchString);
		if (lastIndex != -1) {
			recentSearches.remove(lastIndex);
		}
		recentSearches.add(0, searchString);
		if (getLength() > getMaxRecents()) {
			recentSearches.remove(recentSearches.size() - 1);
		}
		save();
		fireChangeEvent();
	}

	/**
	 * Returns all recent searches in this list.
	 * 
	 * @return the recent searches
	 */
	public String[] getRecentSearches() {
		return recentSearches.toArray(new String[] {});
	}

	/**
	 * The number of recent searches.
	 * 
	 * @return number of recent searches
	 */
	public int getLength() {
		return recentSearches.size();
	}

	/**
	 * Remove all recent searches.
	 */
	public void removeAll() {
		recentSearches.clear();
		save();
		fireChangeEvent();
	}

	/**
	 * Returns the maximum number of recent searches.
	 * 
	 * @see #put(String)
	 * @return the maximum number of recent searches
	 */
	public int getMaxRecents() {
		return maxRecents;
	}

	/**
	 * Set the maximum number of recent searches.
	 * 
	 * @see #put(String)
	 * @param maxRecents
	 *            maximum number of recent searches
	 */
	public void setMaxRecents(int maxRecents) {
		this.maxRecents = maxRecents;
	}

	/**
	 * Add a change listener. A {@link ChangeEvent} will be fired whenever a
	 * search is added or removed.
	 * 
	 * @param l
	 *            the {@link ChangeListener}
	 */
	public void addChangeListener(ChangeListener l) {
		listeners.add(l);
	}

	/**
	 * Remove a change listener.
	 * 
	 * @param l
	 *            a registered {@link ChangeListener}
	 */
	public void removeChangeListener(ChangeListener l) {
		listeners.remove(l);
	}

	/**
	 * Returns all registered {@link ChangeListener}s.
	 * 
	 * @return all registered {@link ChangeListener}s
	 */
	public ChangeListener[] getChangeListeners() {
		return listeners.toArray(new ChangeListener[] {});
	}

	private void fireChangeEvent() {
		ChangeEvent e = new ChangeEvent(this);

		for (ChangeListener l : listeners) {
			l.stateChanged(e);
		}
	}

	/**
	 * Creates the recent searches popup menu which will be used by
	 * {@link #install(JXSearchField)} to set a search popup menu on
	 * <code>searchField</code>.
	 * 
	 * Override to return a custom popup menu.
	 * 
	 * @param searchField
	 *            the search field the returned popup menu will be installed on
	 * @return the recent searches popup menu
	 */
	protected JPopupMenu createPopupMenu(JTextField searchField) {
		return new RecentSearchesPopup(this, searchField);
	}

	/**
	 * Install a recent the searches popup menu returned by
	 * {@link #createPopupMenu(JXSearchField)} on <code>searchField</code>.
	 * Also registers an {@link ActionListener} on <code>searchField</code>
	 * and adds the search string to the list of recent searches whenever a
	 * {@link ActionEvent} is received.
	 * 
	 * Uses {@link NativeSearchFieldSupport} to achieve compatibility with the native
	 * search field support provided by the Mac Look And Feel since Mac OS 10.5.
	 * 
	 * @param searchField
	 *            the search field to install a recent searches popup menu on
	 */
	public void install(JTextField searchField) {
		searchField.addActionListener(this);
		NativeSearchFieldSupport.setFindPopupMenu(searchField, createPopupMenu(searchField));
	}

	/**
	 * Remove the recent searches popup from <code>searchField</code> when
	 * installed and stop listening for {@link ActionEvent}s fired by the
	 * search field.
	 * 
	 * @param searchField
	 *            uninstall recent searches popup menu
	 */
	public void uninstall(JXSearchField searchField) {
		searchField.removeActionListener(this);
		if (searchField.getFindPopupMenu() instanceof RecentSearchesPopup) {
			removeChangeListener((ChangeListener) searchField.getFindPopupMenu());
			searchField.setFindPopupMenu(null);
		}
	}

	/**
	 * Calls {@link #put(String)} with the {@link ActionEvent}s action command
	 * as the search string.
	 */
	@Override
    public void actionPerformed(ActionEvent e) {
		put(e.getActionCommand());
	}

	/**
	 * The popup menu returned by
	 * {@link RecentSearches#createPopupMenu(JXSearchField)}.
	 */
	public static class RecentSearchesPopup extends JPopupMenu implements ActionListener, ChangeListener {
		private RecentSearches recentSearches;

		private JTextField searchField;

		private JMenuItem clear;

		/**
		 * Creates a new popup menu based on the given {@link RecentSearches}
		 * and {@link JXSearchField}.
		 * 
		 * @param recentSearches
		 * @param searchField
		 */
		public RecentSearchesPopup(RecentSearches recentSearches, JTextField searchField) {
			this.searchField = searchField;
			this.recentSearches = recentSearches;

			recentSearches.addChangeListener(this);
			buildMenu();
		}

		/**
		 * Rebuilds the menu according to the recent searches.
		 */
		private void buildMenu() {
			setVisible(false);
			removeAll();

			if (recentSearches.getLength() == 0) {
				JMenuItem noRecent = new JMenuItem(UIManagerExt.getString("SearchField.noRecentsText"));
				noRecent.setEnabled(false);
				add(noRecent);
			} else {
				JMenuItem recent = new JMenuItem(UIManagerExt.getString("SearchField.recentsMenuTitle"));
				recent.setEnabled(false);
				add(recent);

				for (String searchString : recentSearches.getRecentSearches()) {
					JMenuItem mi = new JMenuItem(searchString);
					mi.addActionListener(this);
					add(mi);
				}

				addSeparator();
				clear = new JMenuItem(UIManagerExt.getString("SearchField.clearRecentsText"));
				clear.addActionListener(this);
				add(clear);
			}
		}

		/**
		 * Sets {@link #searchField}s text to the {@link ActionEvent}s action
		 * command and call {@link JXSearchField#postActionEvent()} to fire an
		 * {@link ActionEvent}, if <code>e</code>s source is not the clear
		 * menu item. If the source is the clear menu item, all recent searches
		 * will be removed.
		 */
		@Override
        public void actionPerformed(ActionEvent e) {
			if (e.getSource() == clear) {
				recentSearches.removeAll();
			} else {
				searchField.setText(e.getActionCommand());
				searchField.postActionEvent();
			}
		}

		/**
		 * Every time the recent searches fires a {@link ChangeEvent} call
		 * {@link #buildMenu()} to rebuild the whole menu.
		 */
		@Override
        public void stateChanged(ChangeEvent e) {
			buildMenu();
		}
	}
}
