public class Track {

	private static Logger log = LoggerFactory.getLogger(Track.class);

	private final long id = System.nanoTime();

	// number of channels
	private int channelCount;

	// maximum seconds to buffer
	private int bufferedSeconds = 5;

	private AtomicInteger count = new AtomicInteger(0);

	private ReentrantLock lock;

	private volatile short[] buffer;

	private int capacity = 0;

	private int head = 0;

	private int tail = 0;

	public Track(int samplingRate, int channelCount) {
		// set the number of channels
		this.channelCount = channelCount;
		// size the buffer
		capacity = (samplingRate * channelCount) * bufferedSeconds;
		buffer = new short[capacity];
		// use a "fair" lock
		lock = new ReentrantLock(true);
	}

	/**
	 * Returns the number of samples currently in the buffer.
	 * 
	 * @return
	 */
	public int getSamplesCount() {
		int i = count.get();
		return i > 0 ? i / channelCount : 0;
	}

	/**
	 * Removes and returns the next sample in the buffer.
	 * 
	 * @return single sample or null if a buffer underflow occurs
	 */
	public Short remove() {
		Short sample = null;
		if (count.get() > 0) {
			// decrement sample counter
			count.addAndGet(-1);
			// reposition the head
			head = (head + 1) % capacity;
			// get the sample at the head
			sample = buffer[head];
		} else {
			log.debug("Buffer underflow");
		}
		return sample;
	}

	/**
	 * Adds a sample to the buffer.
	 * 
	 * @param sample
	 * @return true if added successfully and false otherwise
	 */
	public boolean add(short sample) {
		boolean result = false;
		if ((count.get() + 1) < capacity) {
			// increment sample counter
			count.addAndGet(1);
			// reposition the tail
			tail = (tail + 1) % capacity;
			// add the sample to the tail
			buffer[tail] = sample;
			// added!
			result = true;
		} else {
			log.debug("Buffer overflow");
		}
		return result;
	}

	/**
	 * Offers the samples for addition to the buffer, if there is enough capacity to 
	 * contain them they will be added.
	 * 
	 * @param samples
	 * @return true if the samples can be added and false otherwise
	 */
	public boolean offer(short[] samples) {
		boolean result = false;
		if ((count.get() + samples.length) <= capacity) {
			pushSamples(samples);
			result = true;
		}
		return result;
	}

	/**
	 * Adds an array of samples to the buffer.
	 * 
	 * @param samples
	 */
	public void pushSamples(short[] samples) {
		log.trace("[{}] pushSamples - count: {}", id, samples.length);
		try {
			lock.tryLock(10, TimeUnit.MILLISECONDS);
			for (short sample : samples) {
				log.trace("Position at write: {}", tail);
				if (!add(sample)) {
					log.warn("Sample could not be added");
					break;
				}
			}
		} catch (InterruptedException e) {
			log.warn("Exception getting samples", e);
		} finally {
			if (lock.isHeldByCurrentThread()) {
				lock.unlock();
			}
		}
	}

	/**
	 * Returns a single from the buffer.
	 * 
	 * @return
	 */
	public Short popSample(int channel) {
		log.trace("[{}] popSample - channel: {}", id, channel);
		Short sample = null;
		if (channel < channelCount) {
			log.trace("Position at read: {}", head);
			try {
				lock.tryLock(10, TimeUnit.MILLISECONDS);
				sample = remove();
			} catch (InterruptedException e) {
				log.warn("Exception getting sample", e);
			} finally {
				if (lock.isHeldByCurrentThread()) {
					lock.unlock();
				}
			}
		}
		return sample;
	}
}