/*
    *  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 org.xnap.transfer.Segment;
  
  /***
   * <p>The end of the segment can change through a split.
   */
  public class OpenNapSegment implements Cloneable, Segment {
  
  	//--- Constant(s) ---
  
  	/***
  	 * The minimun size for a single segment.
  	 */
  	public static final long MIN_SEGEMENT_SIZE = 100 * 1024;
  
  	//--- Data Field(s) ---
  
  	private OpenNapSegmentData data;
  	private long end;
  	private long total;
  	private long transferred;
  	private OpenNapSegment previous;
  	private OpenNapSegment next;
  	private OpenNapDownload download;
  	
      //--- Constructor(s) ---
  
      public OpenNapSegment(long start, long end, long total) 
      {
  		data = new OpenNapSegmentData();
  		
  		data.start = start;
  		this.end = end;
  		this.total = total;
  	}
  
  	/***
  	 * Creates a new segment based on resume data. The segment spans from
  	 * <code>data.start</code> to <code>total</code>.
  	 */
  	public OpenNapSegment(OpenNapSegmentData data, long total) 
  	{
  		this.data = data;
  		
  		this.transferred = (data.file != null) ? data.file.length() : 0;
  		this.end = total;
  		this.total = total;
  	}
  
      //--- Methods ---
  
  	public Object clone()
  	{
  		OpenNapSegment n = new OpenNapSegment(data.start, end, total);
  
  		n.data.file = data.file;
  		n.data.mergeFailCount = data.mergeFailCount;
  		n.download = download;
  		n.previous = previous;
  		n.next = next;
  		n.transferred = transferred;
  
  		return n;
  	}
  
  	public int getAvailability()
  	{
  		return (download != null) ? 128 : 0;
  	}
  
  	OpenNapSegmentData getData()
  	{
  		return data;
  	}
  
  	public long getEnd() 
  	{
 		return this.end;
 	}
 
 	/***
 	 * Returns the download currently downloading the segment.
 	 *
 	 * @return null, if this segment is currently idle
 	 */
 	public OpenNapDownload getDownload()
 	{
 		return download;
 	}
 
 	/***
 	 * Returns the download offset that should be sent to the peer.
 	 */
 	public long getDownloadOffset()
 	{
 		return data.start + transferred - getOverlap();
 	}
 
 	/***
 	 * Returns the file offset to seek to when matching the overlap
 	 */
 	public long getFileOffset()
 	{
 		return transferred - getOverlap();
 	}
 
  	public File getFile()
  	{
  		return data.file;
  	}
 	
 	public OpenNapSegment getNext()
 	{
 		return next;
 	}
 
 	/***
 	 * Returns the number of bytes that need to be matched.
 	 */
 	public int getOverlap()
 	{
 		return (transferred < OpenNapSegmentManager.OVERLAP) 
 			? (int)transferred
 			: OpenNapSegmentManager.OVERLAP;
 	}
 
 	public OpenNapSegment getPrevious()
 	{
 		return previous;
 	}
 
 	public long getStart() 
 	{
 		return data.start;
 	}
 
 	public long getTotal() 
 	{
 		return total;
 	}
 
 	public long getTransferred() 
 	{
 		return transferred;
 	}
 
 	public boolean isFinished()
 	{
 		return getRemaining() == 0;
 	}
 
 	public void setDownload(OpenNapDownload download)
 	{
 		this.download = download;
 	}
 
 	/***
 	 * <p>Modifies: <code>file</code>
 	 */
 	public synchronized void setFile(File file)
 	{
 		data.file = file;
 	}
 
 	/***
 	 * Commits l bytes as transferred.
 	 *
 	 * <p>Modifies: <code>transferred</code>.
 	 *
 	 */
 	synchronized void commit(int l)
 	{
 		transferred += l;
 	}
 
 	/***
 	 * Commits l bytes as transferred.
 	 *
 	 * <p>Modifies <code>transferred</code>, <code>offset</code>.
 	 *
 	 * @return the number of bytes that were accepted and should
 	 *         be written to file
 	 */
 	synchronized int commitToFile(int l)
 	{
 		if (data.start + transferred + l > end) {
 			l = (int)(end - data.start - transferred);
 		}
 
 		transferred += l;
 
 		return l;
 	}
 
 	synchronized long getRemaining()
 	{
 		return end - data.start - transferred;
 	}
 
 	/***
 	 * Appends <code>n</code> after this segment. Shortens this segment.
 	 *
 	 * <p>Modifies: <code>end</code>
 	 */
 	synchronized void append(OpenNapSegment next)
 	{
 		if (next.data.start 
 			< this.data.start + this.transferred - OpenNapSegmentManager.OVERLAP) {
 
 			throw new IllegalArgumentException("invalid start");
 		}
 
 		// shorten previous segment
 		this.end = next.data.start + OpenNapSegmentManager.OVERLAP;
 
 		this.next = next;
 		next.previous = this;
 	}
 
 	/***
 	 * Merges next into this segment by appending it.
 	 */
 	synchronized void merge(OpenNapSegment next, int overlap)
 	{
 		this.end = next.getEnd();
 		this.transferred += next.getTransferred() - overlap;
 
 		this.next = next.getNext();
 		if (this.next != null) {
 			this.next.previous = this;
 		}
 
 		next.previous = null;
 		next.next = null;
 	}
 
 
 	/***
 	 * <p>Modifies: <code>end</code>
 	 */
 	synchronized OpenNapSegment split(int overlap)
 	{
 		long oldEnd = end;
 		long half = getRemaining() / 2;
 
 		if (half < MIN_SEGEMENT_SIZE) {
 			return null;
 		}
 	
 		// shrink
 		end = data.start + transferred + half;
 		OpenNapSegment s = new OpenNapSegment(end - overlap, oldEnd, getTotal());
 
 		s.next = this.next;
 		if (s.next != null) {
 			s.next.previous = s;
 		}
 		s.previous = this;
 		this.next = s;
 		return s;
 	}
 
 	synchronized void trim()
 	{
 		end = data.start + transferred;
 	}
 }