/*
 * @(#)BasicTrack.java	1.22 02/08/21
 *
 * Copyright (c) 1996-2002 Sun Microsystems, Inc.  All rights reserved.
 */

// TODO: make this an inner class of BasicPullParser if it makes sense. (ie if it works
// for wav and qt parsers)

package com.sun.media.parser;

import java.io.IOException;
import javax.media.*;
import javax.media.Format;
import javax.media.protocol.SourceStream;
import javax.media.protocol.PullSourceStream;

public class BasicTrack implements Track {

    private Format format;
    private boolean enabled = true;
    protected Time duration;
    private Time startTime;
    private int numBuffers;
    private int dataSize;
    private PullSourceStream stream;
    private long minLocation;
    private long maxLocation;
    private long maxStartLocation;
    private BasicPullParser parser; // TODO: Won't need this if inner class.
    private long sequenceNumber = 0;
    private TrackListener listener;
    private long seekLocation = -1L;
    private long mediaSizeAtEOM = -1L; // update when EOM implied by IOException occurs
    private boolean warnedUserOfReadPastEOM = false;

    public BasicTrack(BasicPullParser parser,
	       Format format, boolean enabled, Time duration, Time startTime,
	       int numBuffers, int dataSize, PullSourceStream stream) {
	this(parser, format,  enabled,  duration,  startTime,
	     numBuffers, dataSize, stream,
	     0L, Long.MAX_VALUE);
    }


    /**
     * Note to implementors who want to use this class.
     * If the maxLocation is not known, then
     * specify Long.MAX_VALUE for this parameter
     */
    public BasicTrack(BasicPullParser parser,
	       Format format, boolean enabled, Time duration, Time startTime,
	       int numBuffers, int dataSize, PullSourceStream stream,
	       long minLocation, long maxLocation) {
	this.parser = parser;

	this.format = format;
	this.enabled = enabled;
	this.duration = duration;
	this.startTime = startTime;
	this.numBuffers = numBuffers;
	this.dataSize = dataSize;
	this.stream = stream;
	this.minLocation = minLocation;
	this.maxLocation = maxLocation;
	maxStartLocation = maxLocation - dataSize;
    }

    public Format getFormat() {
	return format;
    }


    public void setEnabled(boolean t) {
	enabled = t;
    }

    public boolean isEnabled() {
	return enabled;
    }

    public Time getDuration() {
	return duration;
    }


    public Time getStartTime() {
	return startTime;
    }

    // TODO: create a list of TrackListeners
    public void setTrackListener(TrackListener l) {
	listener = l;
    }
    
    
    public synchronized void setSeekLocation(long location) {
	seekLocation = location;
    }

    public synchronized long getSeekLocation() {
	return seekLocation;
    }

    public void readFrame(Buffer buffer) {

	if (buffer == null)
	    return;

	if (!enabled) {
	    buffer.setDiscard(true);
	    return;
	}

	buffer.setFormat(format); // Need to do this every time ???
	Object obj = buffer.getData();
	byte[] data;
	long location;
	boolean needToSeek;
	
	synchronized(this) {
	    if (seekLocation != -1) {
		location = seekLocation;
		if (seekLocation < maxLocation)
		    seekLocation = -1;
		needToSeek = true;
	    } else {
		location = parser.getLocation(stream);
		needToSeek = false;
	    }
	}

	int needDataSize;

	//TODO START
	if (location < minLocation) {
	    // TODO: should probably seek or skip to minLocation
	    buffer.setDiscard(true);
	    return;
	} else if (location >= maxLocation) {
	    buffer.setLength(0);
	    buffer.setEOM(true);
	    return;
	} else if (location > maxStartLocation) {
	    needDataSize = dataSize - (int) (location - maxStartLocation);
	} else {
	    needDataSize = dataSize;
	}
	//TODO END

	if  ( (obj == null) ||
	      (! (obj instanceof byte[]) ) ||
	      ( ((byte[])obj).length < needDataSize) ) {
	    // System.out.println("readFrame creating new byte data of size " + needDataSize);
	    data = new byte[needDataSize];
	    buffer.setData(data);
	} else {
	    data = (byte[]) obj;
	}
	try {
	    if ( (parser.cacheStream != null) && (listener != null) ) {
		if ( parser.cacheStream.willReadBytesBlock(location, needDataSize) ) {
		    // System.out.println("read will block: " + location + " : " +
		    // needDataSize);
		    listener.readHasBlocked(this);
		}
	    }
	    if (needToSeek) {
		// TODO: need to handle case where the stream is not seekable and
		// caching is not beeing done (ie cacheStream is null)
		long pos = ((javax.media.protocol.Seekable)stream).seek(location);
		if ( pos == com.sun.media.protocol.BasicSourceStream.LENGTH_DISCARD) {
		    buffer.setDiscard(true);
		    return;
		}
	    }
	    if (parser.getMediaTime() != null)
		buffer.setTimeStamp(parser.getMediaTime().getNanoseconds());
	    else
		buffer.setTimeStamp(Buffer.TIME_UNKNOWN);
	    buffer.setDuration(Buffer.TIME_UNKNOWN);

	    int actualBytesRead = parser.readBytes(stream, data, needDataSize);
	    buffer.setOffset(0);
	    buffer.setLength(actualBytesRead);
	    // TODO: need setSequenceNumber and getSequenceNumber in Buffer
	    buffer.setSequenceNumber(++sequenceNumber);
// 	    System.out.println("Time stamp: " + (buffer.getTimeStamp())/1.E9);
	} catch (IOException e) {
	    if (maxLocation != Long.MAX_VALUE) {
		// Known maxLocation. So, this is a case of
		// deliberately reading past EOM
		if (!warnedUserOfReadPastEOM) {
		    com.sun.media.Log.warning("Warning: Attempt to read past End of Media");
		    com.sun.media.Log.warning("This typically happens if the duration is not known or");
		    com.sun.media.Log.warning("if the media file has incorrect header info");
		    warnedUserOfReadPastEOM = true;
		}
		buffer.setLength(0); // Need this??
		buffer.setEOM(true);
	    } else {
		// Unknown maxLocation, due to unknown content length
		// EOM reached before the required bytes could be read.
		long length = parser.streams[0].getContentLength();
		if ( length != SourceStream.LENGTH_UNKNOWN ) {
		    // If content-length is known, discard this buffer, update
		    // maxLocation, maxStartLocation and mediaSizeAtEOM.
		    //  The next readFrame will read the remaining data till EOM.
		    maxLocation = length;
		    maxStartLocation = maxLocation - dataSize;
		    mediaSizeAtEOM = maxLocation - minLocation;
		    buffer.setLength(0); // Need this??
		    buffer.setDiscard(true);
		} else {
		    // Content Length is still unknown after an IOException.
		    // We can still discard this buffer and keep discarding
		    // until content length is known. But this may go into
		    // into an infinite loop, if there are real IO errors
		    // So, return EOM
		    maxLocation = parser.getLocation(stream);
		    maxStartLocation = maxLocation - dataSize;
		    mediaSizeAtEOM = maxLocation - minLocation;
		    buffer.setLength(0); // Need this??
		    buffer.setEOM(true);

		}
			   
	    }
	    // TODO: $$$$ Update maxFrame and duration
	}
	
	// System.out.println("parser's location: " + parser.getLocation(stream));
	// parser.getMediaTime(); // Side effect printout
    }

    public int mapTimeToFrame(Time t) {
	return FRAME_UNKNOWN;
    }

    public Time mapFrameToTime(int frameNumber) {
	return TIME_UNKNOWN;
    }


    public long getMediaSizeAtEOM() {
	return mediaSizeAtEOM; // updated when EOM implied by IOException occurs
    }
}