/*
    *  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.IOException;
  
  import org.xnap.plugin.opennap.util.OpenNapFileHelper;
  import org.xnap.transfer.Segment;
  
  /***
   * 
   */
  public class OpenNapSegmentManager {
  
  	//--- Constant(s) ---
  	
  	/***
  	 * The number of bytes two segments need to overlap.
  	 */
  	public static final int OVERLAP = 100;
  	
  	//--- Data Field(s) ---
  
  	private OpenNapSegment root;
  	private Segment[] segments = new Segment[0];
  	private OpenNapDownloadContainer parent;
  	private boolean multiSourceDownloading;
  
      //--- Constructor(s) ---
  
      public OpenNapSegmentManager
  		(OpenNapDownloadContainer parent,
  		 boolean multiSourceDownloading,
  		 OpenNapSegmentData[] data) 
      {
  		this.parent = parent;
  		this.multiSourceDownloading = multiSourceDownloading;
  
  		if (data != null && data.length > 0) {
  			if (data[0].start != 0 
  				|| data[0].file.length() > parent.getFilesize()) {
  				// invalid segment
  				return;
  			}
  
  			// use the first segment as root segment
  			root = new OpenNapSegment(data[0], parent.getFilesize());
  			add(root);
  
  			// restore segments
  			OpenNapSegment previous = root;
  			for (int i = 1; i < data.length; i++) {
  				long minStart = previous.getStart() 
  					+ previous.getTransferred() - OVERLAP;
  
  				if (data[i].start < minStart
  					|| (data[i].start + data[i].file.length() 
  						> parent.getFilesize())) {
  					// invalid segment
  					return;
  				}
  
  				// append new segment
  				OpenNapSegment next 
  					= new OpenNapSegment(data[i], parent.getFilesize());
  				previous.append(next);
  				add(next);
  
  				previous = next;
  			}
  	    }
  
      }
  
      public OpenNapSegmentManager
  		(OpenNapDownloadContainer parent, 
  		 boolean multiSourceDownloading) 
      {
  		this(parent, multiSourceDownloading, null);
      }
  
     //--- Methods ---
 
 	public long getBytesTransferred()
 	{
 		long bytesTransferred = 0;
 		long previousEnd = 0;
 		for (int i = 0; i < segments.length; i++) {
 			bytesTransferred += segments[i].getTransferred();
 			// subtract overlap
 			bytesTransferred -= previousEnd - segments[i].getStart();
 			previousEnd += segments[i].getEnd();
 		}
 		return bytesTransferred;
 	}
 	
 	public OpenNapSegment getRoot()
 	{
 		return root;
 	}
 
 	/***
      * 
      */
     public Segment[] getSegments() 
 	{
 		return segments;
     }
 
 	synchronized OpenNapSegment requestSegment(OpenNapDownload d)
 	{
 		if (root == null) {
 			root = new OpenNapSegment
 				(0, parent.getFilesize(), parent.getFilesize());
 			root.setDownload(d);
 			add(root);
 			return root;
 		}
 
 		if (!multiSourceDownloading) {
 			// do not create any segments besides root if root is busy
 			if (root.getDownload() == null) {
 				root.setDownload(d);
 				return root;
 			}
 			else {
 				return null;
 			}
 		}
 
 		OpenNapSegment next = root;
 		OpenNapSegment slowest = null;
 		while (next != null) {
 			if (!next.isFinished()) {
 				if (next.getDownload() == null) {
 					next.setDownload(d);
 					return next;
 				}
 				else {
 					if (slowest == null
 						|| (next.getDownload().getAverageRate() 
 							< slowest.getDownload().getAverageRate())) {
 						slowest = next;
 					}
 				}
 			}
 			next = next.getNext();
 		}
 
 		if (slowest != null) {
 			// no free segment found, split the slowest
 			OpenNapSegment s = slowest.split(OVERLAP);
 
 			if (s == null) {
 				// too bad, we couldn't split, try the next best
 				next = root;
 				while (s == null && next != null) {
 					if (!next.isFinished() && next.getDownload() == null) {
 						s = next.split(OVERLAP);
 					}
 					next = next.getNext();
 				}
 			}
 
 			if (s != null) {
 				s.setDownload(d);
 				add(s);
 				return s;
 			}
 		}
 
 		return null;
 	}
 
 	synchronized void returnSegment(OpenNapSegment s) throws IOException
 	{
 		s.setDownload(null);
 		
 		merge(s, s.getNext());
 		merge(s.getPrevious(), s);
 	}
 
 	private synchronized boolean merge(OpenNapSegment p, OpenNapSegment s) 
 		throws IOException
 	{
 		if (p == null 
 			|| p.getFile() == null 
 			|| p.getDownload() != null
 			|| !p.isFinished() 
 			|| s == null 
 			|| s.getFile() == null 
 			|| s.getDownload() != null) {
 			// one of the segments is not ready to be merged
 			return false;
 		}
 			
 		int overlap = (int)(p.getEnd() - s.getStart());
 		OpenNapFileHelper.match(p.getFile(), s.getFile(), overlap);
 		OpenNapFileHelper.append(p.getFile(), s.getFile(), overlap);
 
 		s.getFile().delete();
 
 		// merge s into p and dump s
 		p.merge(s, overlap);
 		remove(s);
 
 		return true;
 	}
 
 	private synchronized void add(OpenNapSegment segment)
 	{
 	    OpenNapSegment[] tmp = new OpenNapSegment[segments.length + 1];
 		System.arraycopy(segments, 0, tmp, 0, segments.length);
 		tmp[tmp.length - 1] = segment;
 		segments = tmp;
 		parent.setSegments(tmp);
 	}
 
 	private synchronized void remove(OpenNapSegment segment)
 	{
 		for (int i = 0; i < segments.length; i++) {
 			if (segments[i] == segment) {
 				OpenNapSegment[] tmp = new OpenNapSegment[segments.length - 1];
 				System.arraycopy(segments, 0, tmp, 0, i);
 				System.arraycopy(segments, i + 1, tmp, i, 
 								 segments.length - i - 1);
 				segments = tmp;
 				parent.setSegments(tmp);
 				return;
 			}
 		}
 	}
 
 }