/*
    *  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.net;
  
  import java.io.File;
  import java.util.Hashtable;
  import java.util.*;
  
  import org.apache.log4j.Logger;
  import org.xnap.*;
  import org.xnap.gui.StatusBar;
  import org.xnap.plugin.opennap.net.msg.MessageHandler;
  import org.xnap.plugin.opennap.net.msg.client.*;
  import org.xnap.plugin.opennap.net.msg.client.UploadAckMessage;
  import org.xnap.plugin.opennap.net.msg.server.DirectBrowseRequestMessage;
  import org.xnap.plugin.opennap.net.msg.server.UploadRequestMessage;
  import org.xnap.plugin.opennap.user.OpenNapUser;
  import org.xnap.plugin.opennap.util.OpenNapFileHelper;
  import org.xnap.transfer.*;
  import org.xnap.transfer.UploadManager;
  import org.xnap.util.Preferences;
  
  public class OpenNapTransferManager {
  
      //--- Constant(s) ---
  
      //--- Data field(s) ---
  
      private static Logger logger
  		= Logger.getLogger(OpenNapTransferManager.class);
  
  	/***
  	 * Stores a list of {@link OpenNapDownloadContainer} objects.
  	 */
  	private List downloads = new LinkedList();
  	private Hashtable uploadByRequest = new Hashtable();
  	private OpenNapResumeRepository repository = new OpenNapResumeRepository();
  
      //--- Constructor(s) ---
  
      public OpenNapTransferManager()
      {
      }
  
      //--- Method(s) ---
  
  	private synchronized void add(OpenNapDownloadContainer d)
  	{
  		DownloadManager.getInstance().add(d);
  		downloads.add(d);
  	}
  
  	public synchronized void clear()
  	{
  		for (Iterator i = downloads.iterator(); i.hasNext();) {
  			OpenNapDownloadContainer d = (OpenNapDownloadContainer)i.next();
  			d.stop();
  
  			DownloadManager.getInstance().remove(d);
  			i.remove(); 
  		}
  	}
  
  	public synchronized void done(OpenNapUpload u)
  	{
  		uploadByRequest.remove(u.getHash());
  	}
  
  	/***
  	 * Creates a new {@link OpenNapDownloadContainer} object for
  	 * results if no download for results is already running.  
  	 *
  	 * @return the created or running download */
  	public synchronized OpenNapDownloadContainer download
  		(OpenNapSearchResult results[]) 
  	{
  		for (Iterator it = downloads.iterator(); it.hasNext();) {
  			OpenNapDownloadContainer d 
  				= (OpenNapDownloadContainer)it.next();
  			if (d.add(results[0], true)) {
  				for (int i = 1; i < results.length; i++) {
  					d.add(results[i], true);
 				}
 				StatusBar.setText(XNap.tr("Results added to already running download"));
 				return d;
 			}
 		}
 
 		OpenNapDownloadContainer d = new OpenNapDownloadContainer(results);
 		add(d);
 		return d;
 	}
 
 	public OpenNapResumeRepository getResumeRepository()
 	{
 		return repository;
 	}
 
 	public synchronized void received(DirectBrowseRequestMessage msg)
 	{
 		OpenNapUser user = msg.getServer().getUser(msg.nick);
 		user.setHost(msg.ip);
 		user.setPort(msg.port);
 
 		OpenNapDirectBrowseUpload u = new OpenNapDirectBrowseUpload(user);
 
 		// no queueing, start it right away
 		u.start();
 	}
 
     public synchronized void received(UploadRequestMessage msg) 
     {
 		String hash = msg.nick + ":" + msg.filename;
 		OpenNapUpload u
 			= (OpenNapUpload)uploadByRequest.get(hash);
 		if (u == null) {
 			OpenNapUser user = msg.getServer().getUser(msg.nick);
 			File file = OpenNapFileHelper.getSharedFile(msg.filename);
 			if (user.isUploadDenied() || file == null) {
 				// invalid request
 				MessageHandler.send
 					(msg.getServer(), 
 					 new AcceptFailedMessage(msg.nick, msg.filename));
 				return;
 			}
 
 			// create new upload object
 			u = new OpenNapUpload(msg.getServer(), user, file, msg.filename);
 			u.setHash(hash);
 			uploadByRequest.put(hash, u);
 			u.start();
 
 			UploadManager.getInstance().add(u);
 			int pos = u.getQueuePosition();
 			if (pos > 0) {
 				QueueLimitMessage m 
 					= new QueueLimitMessage(msg.nick, msg.filename, pos);
 				MessageHandler.send(msg.getServer(), m);
 			}
 		}
 		else {
 			int pos = u.getQueuePosition();
 			if (pos == 0) {
 				// some clients need two confirmations before they start
 				// downloading
 				MessageHandler.send
 					(msg.getServer(), 
 					 new UploadAckMessage(msg.nick, msg.filename));
 			}
 			else {
 				QueueLimitMessage m 
 					= new QueueLimitMessage(msg.nick, msg.filename, pos);
 				MessageHandler.send(msg.getServer(), m);
 				// notify upload that it has been requested
 				u.requested();
 			}
 		}
 	}
 
 	public synchronized void remove(OpenNapDownloadContainer download)
 	{
 		downloads.remove(download);
 	}
 
 	/***
 	 * Restores the resumes.
 	 */
 	public synchronized void restore()
 	{
 		repository.restore
 			(new File(Preferences.getInstance().getIncompleteDir()));
 
 		for (Iterator it = repository.iterator(); it.hasNext(); ) {
 			OpenNapDownloadContainerData data 
 				= (OpenNapDownloadContainerData)it.next();
 			OpenNapDownloadContainer d = new OpenNapDownloadContainer(data);
 			add(d);
 		}
 	}
 
 	public void save()
 	{
 		repository.save
 			(new File(Preferences.getInstance().getIncompleteDir()));
 	}
 
 	public synchronized void startAllDownloads()
 	{
 		for (Iterator i = downloads.iterator(); i.hasNext();) {
 			OpenNapDownloadContainer d = (OpenNapDownloadContainer)i.next();
 			d.startTransfer();
 		}
 	}
 
 	// TOFIX
 //  		if (OpenNapPreferences.getInstance().getWhoisQueryOnTransfer()) {
 //  			server.getUser(nick).update(true);
 //  		}
 
 //  		File file = OpenNapFileHelper.getRepositoryFile(filename);
 //  		Upload u = new Upload(nick, file, server, filename);
 	
 //  		if (file == null || !server.getUser(nick).isAllowedToDownload()) {
 //  			logger.warn("rejecting leecher / invalid request: " + nick + " "
 //  		    			+ filename);
 //  			u.reject();
 //  			return;
 
 //  		  	if (file == null) {
 //  				logger.warn("invalid request: " + nick + " " + filename);
 //  				u.reject();
 //  				return;
 //  		  	}
 	
 //  		  	if (!server.getUser(nick).isAllowedToDownload()) {
 //  				logger.warn("rejecting leecher" + nick + " " + filename);
 //  				u.reject();
 //  				return;
 //  		  	}
 	
 //  		  	UploadQueue uq = UploadQueue.getInstance();
 //  		  	logger.debug("upload: " + nick + " " + filename);
 
 //  		  	boolean added = uq.add(u);
 //  		  	if (added) {
 //  				give the download queue a chance to start the download 
 //  					right away to avoid sending local queued responses
 //  					try {
 //  						Thread.currentThread().sleep(20);
 //  					}
 //  					catch (InterruptedException e) {
 //  					}
 //  		  	}
 
 //  		  	int pos = uq.getLocalQueuePos(u);
 //  		  	if (pos == -1 && !added) {
 //  		  	    if (uq.isRunning(u)) {
 //  					some clients need two confirmations before they start
 //  						downloading
 //  						MessageHandler.send
 //  						(server, new UploadAckMessage(nick, filename));
 //  		  	    }
 //  		  	    else {
 //  					logger.warn("upload queue rejected " + filename);
 //  					u.reject();
 //  		  	    }
 //  		  	}
 //  		  	else if (pos != -1) {
 //  				pos == 0 means busy, so we always send pos > 0
 //  					QueueLimitMessage m = new QueueLimitMessage(nick, filename,
 //  																pos + 1);
 //  		  	    MessageHandler.send(server, m);
 //  		  	}
 //  		}
 
 }