/*
    *  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.awt.event.ActionEvent;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.Socket;
  import java.util.Hashtable;
  
  import javax.swing.Action;
  import javax.swing.Icon;
  
  import org.xnap.XNap;
  import org.xnap.io.Library;
  import org.xnap.io.MetaInfoFile;
  import org.xnap.io.MetaInfoManager;
  import org.xnap.net.NetHelper;
  import org.xnap.peer.Peer;
  import org.xnap.plugin.Plugin;
  import org.xnap.plugin.opennap.OpenNapPlugin;
  import org.xnap.plugin.opennap.net.msg.ExceptionListener;
  import org.xnap.plugin.opennap.net.msg.MessageHandler;
  import org.xnap.plugin.opennap.net.msg.client.DirectBrowseAckMessage;
  import org.xnap.plugin.opennap.net.msg.client.DirectShareFileMessage;
  import org.xnap.plugin.opennap.user.OpenNapUser;
  import org.xnap.transfer.AbstractTransfer;
  import org.xnap.transfer.DefaultSegment;
  import org.xnap.transfer.Segment;
  import org.xnap.transfer.Upload;
  import org.xnap.transfer.UploadManager;
  import org.xnap.transfer.action.AbstractStopAction;
  import org.xnap.util.FiniteStateMachine;
  import org.xnap.util.Range;
  import org.xnap.util.State;
  
  /***
   * 
   */
  public class OpenNapDirectBrowseUpload extends AbstractTransfer	
  	implements ExceptionListener, Upload, SocketListener {
  
  	//--- Constant(s) ---
  
  	public static final int SOCKET_TIMEOUT = 1 * 60 * 1000;
  
  	/***
  	 * The state transition table.
  	 */
      private static final Hashtable TRANSITION_TABLE;
      static {
  		State[][] table = new State[][] {
  			{ State.NOT_STARTED,  
  			  State.WAITING, },
  			{ State.WAITING,
  			  State.CONNECTING, State.FINISHED, State.STOPPING,  },
  			{ State.CONNECTING, 
  			  State.FINISHED, State.STOPPING, State.UPLOADING, },
  			{ State.UPLOADING, 
  			  State.FINISHED, State.STOPPING, },
  			{ State.STOPPING,
  			  State.FINISHED }
  		};
  		
  		TRANSITION_TABLE = FiniteStateMachine.createStateTable(table);
      }
  
  	//--- Data Field(s) ---
  
      private StateMachine sm = new StateMachine();
  
  	private OpenNapUser user;
  
  	private BrowseUploadSocket inSocket;
  
  	private long bytesTransferred;
  	private DefaultSegment segment;
  	private long size;
  
      //--- Constructor(s) ---
 
 	public OpenNapDirectBrowseUpload(OpenNapUser user) 
     {
 		this.user = user;
     }
 
     //--- Methods ---
 
     public void exceptionThrown(Exception e)
     {
 		setState(State.FAILED, e.getLocalizedMessage());
     }
 
 	public File getFile()
 	{
 		return null;
 	}
 
 	public String getFilename()
 	{
 		return XNap.tr("OpenNap Direct Browse");
 	}
 
     /***
      * 
      */
     public long getFilesize() 
 	{
         return size;
     }
 
     public Plugin getPlugin()
     {
 		return OpenNapPlugin.getInstance();
     }
 
 	/***
 	 * @see xnap.transfer.Transfer#getActions()
 	 */
 	public Action[] getActions() 
 	{
 		return new Action[] { new StopAction() };
 	}
 
 	/***
 	 * 
 	 */
 	public long getBytesTransferred() 
 	{
 		return bytesTransferred;
 	}
 
     public Icon getIcon()
     {
 		return OpenNapPlugin.ICON_16;
     }
 
 	/***
 	 * @see xnap.transfer.Transfer#getPeer()
 	 */
 	public Peer getPeer() 
 	{
 		return user;
 	}
 
 	public Segment[] getSegments()
 	{
 		return (segment != null) ? new Segment[] { segment } : null;
 	}
 
 	/***
 	 * @see xnap.transfer.Transfer#getStatus()
 	 */
 	public String getStatus() 
 	{
 		return sm.getDescription();
 	}
 
 	/***
 	 * @see xnap.transfer.Transfer#getTotalBytesTransferred()
 	 */
 	public long getTotalBytesTransferred() 
 	{
 		return (isDone()) ? bytesTransferred : 0;
 	}
 
     public boolean isDone()
     {
 		return sm.getState() == State.FINISHED;
     }
 
     public boolean isRunning()
     {
 		return sm.getState() == State.UPLOADING;
     }
 
 	public boolean socketReceived(IncomingSocket s)
 	{
 		if (s instanceof BrowseUploadSocket) {
 			// there is no way to verify if this socket is really ours
 			// so just take it
 			inSocket = (BrowseUploadSocket)s;
 			setState(State.CONNECTING);
 			return true;
 	    }
 		return false;
 	}
 
     void setState(State newState, String description)
     {
 		sm.setState(newState, description);
 		stateChanged();
     }
 
     void setState(State newState)
     {
 		sm.setState(newState);
 		stateChanged();
     }
 
 	void start()
 	{
 		setState(State.WAITING);
 	}
 
     //--- Inner Class(es) ---
 
     private class StateMachine extends FiniteStateMachine {
 
 		//--- Data Field(s) ---
 
 		private OpenNapDirectBrowseUploadRunner runner;
 		private Thread t;
 
 		//--- Constructor(s) ---
 
 		public StateMachine()
 		{
 			super(State.NOT_STARTED, TRANSITION_TABLE);
 		}
 
 		//--- Method(s) ---
 
 		protected synchronized void stateChanged(State oldState,
 												 State newState)
 		{
 			if (newState == State.WAITING) {
 				UploadManager.getInstance().add(OpenNapDirectBrowseUpload.this);
 
 				user.getServer().getListener().addSocketListener
 					(OpenNapDirectBrowseUpload.this);
 
 				DirectBrowseAckMessage msg 
 					= new DirectBrowseAckMessage(user.getName());
 				msg.setExceptionListener(OpenNapDirectBrowseUpload.this);
 				MessageHandler.send(user.getServer(), msg);
 
 				if (user.getHost() != null && user.getPort() > 0) {
 					this.setState(State.CONNECTING);
 				}
 			}
 			else if (newState == State.CONNECTING) {
 				runner = new OpenNapDirectBrowseUploadRunner(inSocket);
 				t = new Thread(runner, "OpenNapDirectBrowseUpload:" 
 							   + user.getName());
 				t.start();
 			}
 			else if (newState == State.UPLOADING) {
 				transferStarted();
 			}
 			else if (newState == State.STOPPING) {
 				if (oldState == State.CONNECTING
 					|| oldState == State.UPLOADING) {
 					runner.stop();
 					t.interrupt();
 				}
 				else {
 					this.setState(State.FINISHED);
 				}
 			}
 			else if (newState == State.FINISHED) {
 				UploadManager.getInstance().remove(OpenNapDirectBrowseUpload.this);
 			}
 
 			if (oldState == State.WAITING) {
 				user.getServer().getListener().removeSocketListener(OpenNapDirectBrowseUpload.this);
 			}
 			else if (oldState == State.UPLOADING) {
 				transferStopped();
 			}
 		}
 	}
 
 	private class StopAction extends AbstractStopAction {
 
 		public void actionPerformed(ActionEvent e) 
 		{
 			setState(State.STOPPING);
 		}
 
 	}
 
 	private class OpenNapDirectBrowseUploadRunner implements Runnable
 	{
 
 		private boolean die;
 		
 		private Socket socket;
 		private InputStream in;
 		private OutputStream out;
 
 		public OpenNapDirectBrowseUploadRunner(BrowseUploadSocket b)
 		{
 			if (b != null) {
 				socket = b.socket;
 				in = b.in;
 			}
 		}
 
 		public void run()
 		{
 			try {
 				if (socket != null) {
 					connect();
 				}
 				else {
 					connect(user.getHost(), user.getPort());
 				}
 
 				setState(State.UPLOADING);
 
 				if (OpenNapPlugin.getPreferences().getSendWholeRepository()) {
 					sendList(null);	
 				}
 				else {
 					Range[] ranges = user.getServer().getShared();
 					if (ranges != null) {
 						// FIX: the progress is incorrect
 						for (int i = 0; i < ranges.length; i++) {
 						sendList(ranges[i]);
 						}
 					}
 				}
 
 				setState(State.FINISHED, XNap.tr("Succeeded"));
 			}
 			catch (IOException e) {
 				setState(State.FINISHED, NetHelper.getErrorMessage(e));
 			}
 			catch (InterruptedException e) {
 				setState(State.FINISHED, XNap.tr("Stopped"));
 			}
 			finally {
 				close();
 			}
 		}		       
 
 		public void stop()
 		{
 			die = true;
 		}
 
 		private void close() 
 		{
 			try {
 				if (socket != null)
 					socket.close();
 				if (in != null)
 					in.close();
 				if (out != null)
 					out.close();
 			} 
 			catch (IOException e) {
 			}
 		}
 
 		private void connect(String host, int port) throws IOException
 		{
 			logger.debug("connecting to " + host + ":" + port 
 						 + " for direct browse push");
 			socket = new Socket(host, port);
 			socket.setSoTimeout(SOCKET_TIMEOUT);
 			out = socket.getOutputStream();
 			
 			write("SENDLIST " + user.getServer().getLocalPeer().getName() + "\n");
 		} 
 
 		private void connect() throws IOException
 		{
 			socket.setSoTimeout(SOCKET_TIMEOUT);
 			out = socket.getOutputStream();
 
 			write(user.getServer().getLocalPeer().getName() + "\n");
 			//write("\n");
 	    }
 
 		private void sendList(Range r) 
 			throws IOException, InterruptedException
 		{
 			if (r == null) {
 				r = new Range(0, Library.getInstance().size() - 1);
 			}
 
 			segment = new DefaultSegment(r.end - r.start + 1, 0, 
 										 r.end - r.start + 1, 0, 255);
 			for (int i = (int)r.start; i <= (int)r.end; i++) {
 				if (die) {
 					throw new InterruptedException();
 				}
 
 				MetaInfoFile f = Library.getInstance().get(i);
 				if (f != null && f.isShared()) {
 					MetaInfoManager.handle(f);
 
 					DirectShareFileMessage msg 
 						= new DirectShareFileMessage(i, f);
 					write(msg.data + "\n");
 				}
 				segment.setTransferred(i - r.start + 1);
 			}
 			write("\n");
 		}
 
 		private void write(String message) throws IOException
 		{
 			logger.debug("> " + message);
 			out.write(message.getBytes());
 			bytesTransferred += message.getBytes().length;
 			out.flush();
 		}
 		
 	}    
 
 }