/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by
    *  the Free Software Foundation.
    *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.xnap.gui.viewer;
  
  import java.io.File;
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.HashSet;
  import java.util.Hashtable;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.apache.log4j.Logger;
  import org.xnap.event.ListListener;
  import org.xnap.event.ListSupport;
  import org.xnap.util.FileHelper;
  import org.xnap.util.Preferences;
  
  /***
   * This class keeps track of the installed viewers and their handled file
   * extensions. It follows the singleton pattern.
   * 
   * {@link ListListener}s can be notified of additions or removals of viewers.
   */
  public class ViewerManager
  {
  
      //--- Constant(s) ---
  
      //--- Data field(s) ---
  
  	private static Logger logger = Logger.getLogger(ViewerManager.class);
      private static Preferences prefs = Preferences.getInstance();
      private static ViewerManager instance = new ViewerManager();
  
  	private ListSupport listeners = new ListSupport(this);
  
      /***
       * Maps extensions to viewers.
       */
      private Hashtable viewersByExtension = new Hashtable();
  	/***
  	 * Map of all registered viewers.
  	 */
  	private HashSet allViewers = new HashSet();
  	
  	private List independentViewers = new LinkedList();
  
      //--- Constructor(s) ---
  
      private ViewerManager()
      {
      }
  
      //--- Method(s) ---
  
      public static ViewerManager getInstance() 
      {
  		return instance;
      }
  
  	public void addListListener(ListListener listener)
  	{
  		listeners.addListListener(listener);
  	}
  
  	public void removeListListener(ListListener listener)
  	{
  		listeners.removeListListener(listener);
  	}
      /***
       * Returns the <code>Viewer</code> object that is registered to handle
       * <code>file</code>.
       *
       * @return null, if no suitable viewer was found; the viewer, otherwise
       */
      public synchronized Viewer getDefaultViewer(File file)
      {
  		Viewer[] viewers = getViewers(file);
  		return (viewers != null) ? viewers[0] : null;
      }
      
     /***
      * Returns array of all viewers registered for this type of file.
      *
      * @param file the file's extension is used to determine the viewers
      * @return array of viewers or null
      */
     public synchronized Viewer[] getViewers(File file)
     {
 		String ext = FileHelper.extension(file.getName());
 		LinkedList list = new LinkedList();
 		
 		LinkedList extList = (LinkedList)viewersByExtension.get(ext);
 		if (extList != null) {
 			list.addAll(extList);
 		}
 		list.addAll(independentViewers);
 		if (list.size() > 0) {
 			return (Viewer[])list.toArray(new Viewer[0]);
 		}
 		return null;
     }
 
 	/***
 	 * Returns an array of all registered vierwers.
 	 */
 	public synchronized Viewer[] getViewers()
 	{
 		Viewer[] v = (Viewer[])allViewers.toArray(new Viewer[0]);
 		Arrays.sort(v, new ViewerComparator());
 		return v;
 	}
 
     /***
      * Registers <code>viewer</code> to handle files with extension
      * <code>extension</code>.
      */
     public synchronized void register(String extension, Viewer viewer)
     {
 		LinkedList list = (LinkedList)viewersByExtension.get(extension);
 		if (list == null) {
 			list = new LinkedList();
 			viewersByExtension.put(extension, list);
 		}
 		if (viewer.getName().equals(prefs.getDefaultViewer(extension))) {
 			list.addFirst(viewer);
 		}
 		else {
 			list.addLast(viewer);
 		}
 		add(viewer);
     }
 	
     /***
      * Registers <code>viewer</code> to handle files with any extension.
      */
     public synchronized void register(Viewer viewer)
     {
     	independentViewers.add(viewer);
     	add(viewer);
     }
     
     /***
      * Registers <code>viewer</code> to handle files with extension
      * <code>extensions</code>.
      */
     public synchronized void register(String[] extensions, Viewer viewer)
     {
 		for (int i = 0; i < extensions.length; i++) {
 			register(extensions[i], viewer);
 		}
     }
 
     /***
      * Unregisters <code>viewer</code> to handle files with extension
      * <code>extensions</code>.
      */
     public synchronized void unregister(String extension, Viewer viewer)
     {
 		LinkedList list = (LinkedList)viewersByExtension.get(extension);
 		if (list != null) {
 			list.remove(viewer);
 		}
 		remove(viewer);
     }
     
     /***
      * Unregisters <code>viewer</code> to handle files with any extension.
      */
     public synchronized void unregister(Viewer viewer)
     {
     	independentViewers.remove(viewer);
     	remove(viewer);
     }
     
     /***
      * Registers <code>viewer</code> to handle files with extension
      * <code>extensions</code>.
      */
     public synchronized void unregister(String[] extensions, Viewer viewer)
     {
 		for (int i = 0; i < extensions.length; i++) {
 			unregister(extensions[i], viewer);
 		}
     }
 
     public synchronized void setDefaultViewer(File file, Viewer viewer)
     {
 		String extension = FileHelper.extension(file.getName());
 		prefs.setDefaultViewer(extension, viewer.getName());
 		LinkedList list = (LinkedList)viewersByExtension.get(extension);
 		if (list != null) {
 			if (list.remove(viewer)) {
 				list.addFirst(viewer);
 			}
 		}
     }
 	
 	private void add(Viewer viewer)
 	{
 		if (allViewers.add(viewer)) {
 			listeners.fireItemAdded(viewer);
 		}
 	}
 
 	private void remove(Viewer viewer)
 	{
 		if (allViewers.remove(viewer)) {
 			listeners.fireItemRemoved(viewer);
 		}
 	}
 
 	/***
 	 * Compares {@link Viewer} objects by name.
 	 */
 	private class ViewerComparator implements Comparator
 	{
 		public int compare(Object o1, Object o2)
 		{
 			return ((Viewer)o1).getName().compareToIgnoreCase
 				(((Viewer)o2).getName());
 		}
 	}
 }