/*
    *  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.BufferedInputStream;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.Socket;
  
  import org.apache.log4j.Logger;
  import org.xnap.XNap;
  import org.xnap.io.ThrottledOutputStream;
  import org.xnap.net.NetHelper;
  import org.xnap.plugin.opennap.net.msg.MessageHandler;
  import org.xnap.plugin.opennap.net.msg.client.DownloadCompleteMessage;
  import org.xnap.plugin.opennap.net.msg.client.DownloadingFileMessage;
  import org.xnap.plugin.opennap.user.OpenNapUser;
  import org.xnap.util.State;
  
  /***
   * Uploads a file.
   */
  public class OpenNapUploadRunner implements Runnable {
  
  	//--- Constant(s) ---
  
      /***
       * Socket timeout during connect.
       */
      public static final int CONNECT_TIMEOUT = 1 * 60 * 1000;
  
      /***
       * Abort transfer if stalled for this long.
       */
      public static final int TRANSFER_TIMEOUT = 2 * 60 * 1000;
  
  	//--- Data field(s) ---
  
  	private static Logger logger = Logger.getLogger(OpenNapUploadRunner.class);
  
  	private OpenNapUpload parent;
  	private boolean die;
  
      private Socket socket;
      private InputStream in;
      private OutputStream out;
  	private long offset;
  
  	//--- Constructor(s) ---
  	
  	public OpenNapUploadRunner(OpenNapUpload parent, UploadSocket u)
  	{
  		this.parent = parent;
  
  		if (u != null) {
  			this.socket = u.socket;
  			this.in = u.in;
  			this.offset = u.offset;
  		}
  	}
  
  	//--- Method(s) ---
  
  	public void run()
  	{
  		boolean messageSent = false;
  		try {
  			if (socket == null) {
  				OpenNapUser user = (OpenNapUser)parent.getPeer();
  				connect(user.getHost(), user.getPort());
  			}
  			else {
  				connect();
  			}
  
  			MessageHandler.send(new DownloadingFileMessage());
  			messageSent = true;
  
  			parent.setState(State.UPLOADING);
  
 			upload();
 
 			parent.setState(State.SUCCEEDED);
 		}
 		catch (IOException e) {
 			logger.debug("upload failed", e);
 			parent.setState(State.STOPPED, NetHelper.getErrorMessage(e));
 		}
 		catch (InterruptedException e) {
 			logger.debug("upload aborted");
 			parent.setState(State.STOPPED);
 		}
 		finally {
 			close();
 
 			if (messageSent) {
 				MessageHandler.send(new DownloadCompleteMessage());
 			}
 		}
 	}
 
 	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) {
         }
     }
 
     /***
      * Opens socket and requests file.
      */
     private void connect(String ip, int port) throws IOException
     {
 		logger.debug("opening socket to " + ip + ":" + port);
 
 		//socket = new Socket(ip, port);
 		socket = NetHelper.connect(ip, port, CONNECT_TIMEOUT);
 		socket.setSoTimeout(CONNECT_TIMEOUT);
 
 		out = socket.getOutputStream();
 		in = new BufferedInputStream(socket.getInputStream());
 
 		String message;
 
 		// read magic number '1'
 		char c = (char)in.read();
 		if (c != '1') {
 			throw new IOException(XNap.tr("invalid request"));
 		}
 	
 		message = "SEND";
 		out.write(message.getBytes());
 		out.flush();
 	
 		message = parent.getServer().getLocalPeer().getName() + " \"" 
 			+ parent.getRequestFilename() + "\" " + parent.getFilesize();
 		logger.debug("> " + message);
 		out.write(message.getBytes());
 		out.flush();
 
 		byte data[] = new byte[1000];
 		int j = in.read(data);
 	
 		if (j <= 0) {
 			throw new IOException(XNap.tr("Socket error"));
 		}
 
 		String response = new String(data, 0, j);
 		logger.debug("< " + response);
 		try {
 			offset = Long.parseLong(response);
 		}
 		catch (NumberFormatException e) {
 			throw new IOException(XNap.tr("invalid request"));
 		}		
 	
 		logger.debug("offset: " + response);
     }
 
 	private void connect() throws IOException
 	{
 		out = socket.getOutputStream();
 		socket.setSoTimeout(CONNECT_TIMEOUT);
 		
 		// write filesize
 		long size = parent.getFile().length();
 		out.write((new Long(size)).toString().getBytes());
 		out.flush();
 	}
 
 	/***
 	 *
 	 * <p>PRECONDITION<br>
 	 * socket != null, in != null, out != null
 	 */
 	private void upload() throws IOException, InterruptedException
 	{
 		byte[] buf = new byte[512];
 		//byte[] buf = new byte[ThrottledOutputStream.getBlocksize()];
 
 		out = new ThrottledOutputStream(out);
 		
 		BufferedInputStream inFile = new BufferedInputStream
 			(new FileInputStream(parent.getFile()));
 		
 		if (inFile.skip(offset) != offset) {
 			throw new IOException(XNap.tr("invalid offset"));
 		}
 		parent.setTotalBytesTransferred(offset);
 		
 		while (!die) {
 			int len = inFile.read(buf, 0, buf.length);
 			if (len <= 0) {
 				break;
 			}
 			
 			out.write(buf, 0, len);
 			
 			parent.commit(len);
 		}
 
 		if (die) {
 			throw new InterruptedException();
 		}
     }
 
 }