/*
    *  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.plugin.opennap.user;
  
  import java.util.LinkedList;
  import java.util.List;
  
  import javax.swing.Action;
  
  import org.xnap.XNap;
  import org.xnap.peer.AbstractHotlistItem;
  import org.xnap.peer.HotlistManager;
  import org.xnap.plugin.opennap.action.OpenNapBrowseAction;
  import org.xnap.plugin.opennap.action.OpenNapChatAction;
  import org.xnap.plugin.opennap.action.OpenNapEditGlobalUserAction;
  import org.xnap.plugin.opennap.action.OpenNapLookupAction;
  import org.xnap.plugin.opennap.action.OpenNapRemoveFromHotlistAction;
  import org.xnap.plugin.opennap.net.OpenNapServer;
  import org.xnap.plugin.opennap.net.msg.MessageHandler;
  import org.xnap.plugin.opennap.net.msg.client.AddHotlistEntryMessage;
  import org.xnap.plugin.opennap.net.msg.client.RemoveHotlistEntryMessage;
  import org.xnap.plugin.opennap.net.msg.client.WhoisRequestMessage;
  
  public class OpenNapGlobalUser extends AbstractHotlistItem {
  
      //--- Constant(s) ---
  
      //--- Constant(s) ---
  
      public static int TRANSFER_DEFAULT = -1;
      public static int TRANSFER_NEVER = 0;
      public static int TRANSFER_UNLIMITED = Integer.MAX_VALUE;
  
      //--- Data field(s) ---
  
      private GlobalOpenNapUserData data;
      private boolean inHotlist;
      private List servers = new LinkedList();
      private int queuedCount = 0;
      private int downloadCount = 0;
      private int uploadCount = 0;
      private String status;
  	private boolean minimumSharesMessageSent = false;
  
      //--- Constructor(s) ---
  
      /***
       *
       */
      public OpenNapGlobalUser(String name)
      {
  		data = new GlobalOpenNapUserData();
  
  		data.name = name;
  
  		updateStatus();
      }
  
      /***
       * @see OpenNapUserManager
       */
      public OpenNapGlobalUser(GlobalOpenNapUserData data)
      {
  		this.data = data;
  
  		setInHotlist(true);
  
  		updateStatus();
      }
  
      //--- Method(s) ---
  
      public void add(OpenNapServer server)
      {
  		synchronized (servers) {
  			servers.add(server);
  		}
  		updateStatus();
      }
  
  	public void downloadStarted()
  	{
 		synchronized(this) {
 			downloadCount++;
 		}
 		stateChanged();
 	}
 
 	public void downloadStopped()
 	{
 		synchronized(this) {
 			downloadCount--;
 		}
 		stateChanged();
 	}
 
     public Action[] getActions()
     {
 		return new Action[] { 
 			new OpenNapBrowseAction(this),
 			new OpenNapChatAction(this),
 			new OpenNapLookupAction(this),
 			new OpenNapRemoveFromHotlistAction(this), 
 			new OpenNapEditGlobalUserAction(this),
 		};
     }
 
     public String getCategory()
     {
 		return getData().category;
     }
 
     public String getComment()
     {
 		return getData().comment;
     }
 
 	public OpenNapServer getConnectedServer(OpenNapServer preferred)
 	{
 		if (preferred != null && preferred.isConnected()) {
 			return preferred;
 		}
 
 		OpenNapServer[] servers = getServers();
 		for (int i = 0; i < servers.length; i++) {
 			if (servers[i].isConnected()) {
 				return servers[i];
 			}
 		}
 
 		return null;
 	}
 
     public synchronized int getDownloadCount()
     {
 		return downloadCount;
     }
 
     /***
      * Returns the number of allowed donwload from the peers represented by
      * this item.
      */
     public int getMaxDownloads()
     {
 		return getData().maxDownloads;
     }
 
     /***
      * Returns the number of allowed uploads to the peers represented by this
      * item.
      */
     public int getMaxUploads()
     {
 		return getData().maxUploads;
     }
     
     public String getName()
     {
 		return getData().name;
     }
 
     public synchronized int getQueuedCount()
     {
 		return queuedCount;
     }
 
 	public OpenNapServer[] getServers()
 	{
 		synchronized (servers) {
 			return (OpenNapServer[])servers.toArray(new OpenNapServer[0]);
 		}
 	}
 
     public String getStatus()
     {
 		return status;
     }
 
 	public synchronized int getUploadCount()
 	{
 		return uploadCount;
 	}
 
     /***
      * Returns true if chat messages from the peers represented by this item
      * are ignored.
      */
     public boolean isChatIgnored()
     {
 		return getData().ignoreChat;
     }
 
 	public boolean isMinimumSharesMessageSent()
 	{
 		return minimumSharesMessageSent;
 	}
 
     /***
      * Returns true, if the user was added to the {@link HotlistManager}.
      */
     public boolean isInHotlist()
     {
 		return inHotlist;
     }
 
 	public void lookup()
 	{
 		MessageHandler.send(new WhoisRequestMessage(getName()));
 	}
 
 	public synchronized void setMinimumSharesMessageSent(boolean sent)
 	{
 		minimumSharesMessageSent = sent;
 	}
 
     /***
      * Set <code>newValue</code> to true to ignore chat messages from the 
      * peers represented by this item.
      */
     public void setChatIgnored(boolean newValue)
     {
 		getData().ignoreChat = newValue;
     }
 
     /***
      * Sets the category to <code>newValue</code>.
      */
     public void setCategory(String newValue)
     {
 		getData().category = newValue;
     }
 
     /***
      * Sets the comment to <code>newValue</code>.
      */
     public void setComment(String newValue)
     {
 		getData().comment = newValue;
     }
 
     /***
      * Sets the maximum allowed downloads from the peers represented by this 
      * item to <code>newValue</code>.
      */
     public void setMaxDownloads(int newValue)
     {
 		getData().maxDownloads = newValue;
     }
 
     /***
      * Sets the maximum allowed uploads to the peers represented by this 
      * item to <code>newValue</code>.
      */
     public void setMaxUploads(int newValue)
     {
 		getData().maxUploads = newValue;
     }
 
     public synchronized void setQueued(boolean isQueued)
     {
 		queuedCount += (isQueued) ? 1 : -1;
     }
 
     public void setStatus(String newValue)
     {
 		status = newValue;
 		stateChanged();
     }
 
     public void remove(OpenNapServer server)
     {
 		synchronized (servers) {
 			servers.add(server);
 		}
 		updateStatus();
     }
 
     public void setInHotlist(boolean newValue)
     {
 		if (newValue != isInHotlist()) {
 			inHotlist = newValue;
 			if (newValue) {
 				HotlistManager.getInstance().add(this);
 				MessageHandler.send(new AddHotlistEntryMessage(getName()));
 			}
 			else {
 				HotlistManager.getInstance().remove(this);
 				MessageHandler.send(new RemoveHotlistEntryMessage(getName()));
 			}
 		}
     }
 
     GlobalOpenNapUserData getData()
     {
 		return data;
     }
 
     private void updateStatus()
     {
 		setStatus((servers.size() > 0) 
 				  ? XNap.tr("Online") : XNap.tr("Offline"));
     }
 
 	public void uploadStarted()
 	{
 		synchronized(this) {
 			uploadCount++;
 		}
 		stateChanged();
 	}
 
 	public void uploadStopped()
 	{
 		synchronized(this) {
 			uploadCount--;
 		}
 		stateChanged();
 	}
 
 }