/*
 * AudioThread.java
 *
 * Created on May 28, 2007, 8:58 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package jblackout.util;


import jblackout.exception.SegmentNotLoadedException;
import com.sun.tools.javac.code.Source;
import java.lang.Thread;
import java.lang.*;
import java.net.URL;
import java.awt.Dimension;
import java.io.IOException;
import javax.sound.sampled.*;
import javazoom.jl.player.advanced.*;
import javazoom.jl.player.*;
import javax.sound.sampled.*;
import java.io.*;



/**
 * Thread that plays mp3 Music.
 * @author Jason R. Ederle
 */
public class AudioThread implements Runnable {
    
    
    AudioInputStream in;
    AudioInputStream din;
    AudioFormat decodedFormat;
    AudioFormat baseFormat;
    SourceDataLine line;
    FloatControl volume;
    CacheManager cacheManager;
    ByteArrayInputStream bis;
    
    byte[] data;
    byte[] tempData;
    int mediaId;
    Thread thread;
    URL pathToSong;
    boolean isSongPaused = false;    //set to true when caller wants song to pause.
    boolean songIsPlaying = false;    //set true when song is actively playing audio, false when no audio is loaded, false after song ends.
    boolean timeToExitThread = false; //this tells the thread when to exit the play loop.
    
    /** Creates a new instance of AudioThread */
    public AudioThread(int playMediaId, CacheManager cacheManagerRef) {
        if(thread == null){
            thread = new Thread(this, "Audio Thread.");
        }
        mediaId = playMediaId;
        cacheManager = cacheManagerRef;
        thread.start();
    }
    
     
    /**
     * The thread plays a song and sleeps on pause.
     */
    public void run(){
        
        try{
            //the thread will play the song, and exit when it's finished.
            playSong();
        } catch(Exception e){
            e.printStackTrace();
        }
        
    }
    
    
    private SourceDataLine getLine(AudioFormat audioFormat) throws LineUnavailableException {
        SourceDataLine res = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
        res = (SourceDataLine) AudioSystem.getLine(info);      
        res.open(audioFormat);
        System.out.println("Audio Thread - System audio buffer granted is " + res.available() + " bytes.");
        return res;
    }
    
    
    
    
   
    
    
    public void playSong(){
        
        try {
            //File file = new File(Constant.pathToAnMp3);
            
            //Get encoded input stream.
            in= AudioSystem.getAudioInputStream(new ByteArrayInputStream(cacheManager.getSegment(mediaId, 1)));
                        
            AudioFormat baseFormat = in.getFormat();
            AudioFormat decodedFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                    baseFormat.getSampleRate(),
                    16,
                    baseFormat.getChannels(),
                    baseFormat.getChannels() * 2,
                    baseFormat.getSampleRate(),
                    false);
            
            //Get decoded input stream
            din = null;
            din = AudioSystem.getAudioInputStream(decodedFormat, in);
            
            // Start Playing Song.
            rawplay(decodedFormat, din);
           
            //blocks until all audio has been played, then cleans up resources.
            line.drain();
            line.close();
            in.close();
            System.out.println("Audio Thread - Closing Input stream and stopping song.");
             
        } catch (Exception e) {
            //Handle exception.
        }
        
    }
    
    
    
    /**
     * Converts byte array into input stream.
     */
    private AudioInputStream reloadInputStream(byte[] binArray){
        try{
            
            //File file = new File(Constant.pathToAnMp3);
            //return AudioSystem.getAudioInputStream( file );
            return AudioSystem.getAudioInputStream( new ByteArrayInputStream( binArray ) );
        } catch(Exception e){
            e.printStackTrace();
        }
        
        return null;
    }
    
    
    
    
    private void rawplay(AudioFormat targetFormat, AudioInputStream din) {
        try{
            
            byte[] data = new byte[Constant.SEGMENT_SIZE];
            SourceDataLine line = getLine(targetFormat);
            int nextSegment = 1;
            
            if (line != null) {
            
                // Start
                line.start();
                int totalRead = 0, totalWritten = 0;
                int nBytesRead = 0, nBytesWritten = 0;
                int nBytesLeft = Constant.SEGMENT_SIZE;
                                
                int copySize = 1024 * 4; //4K
                
                
                //Write All segments into the system audio buffer.
                while (nextSegment == 1) {
                    //in = AudioSystem.getAudioInputStream(new ByteArrayInputStream(cacheManager.getSegment(mediaId, nextSegment)));
                    //din = AudioSystem.getAudioInputStream(targetFormat, in);
                    
                    
                    System.out.println("----------- Loading Segment " + nextSegment + " -----------");
                    
                    int reqNumBytes = 0;
                    while(nBytesLeft > 0){
                        
                        
                        //Read From buffer
                        if(nBytesLeft <= line.available())
                            reqNumBytes = nBytesLeft;
                        else
                            reqNumBytes = line.available();
                        
                        nBytesRead = din.read(data, 0, reqNumBytes);
                        totalRead += nBytesRead;
                        
                        //how much data left for this segment in buffer.
                        nBytesLeft = nBytesLeft - nBytesRead;
                        
                        //Wait for room in buffer
                        while( nBytesRead > line.available() ){
                            System.out.println("Audio Thread - Waiting for system audio buffer room.");
                            thread.sleep(250);
                        }
                        
                        
                        //Write to System Audio Buffer
                        nBytesWritten = line.write(data, 0, nBytesRead);
                        totalWritten += nBytesWritten;
                    }
                    
                    
                    System.out.println("Read " + totalRead);
                    System.out.println("Wrote " + totalWritten);
                    
                    //Update trackging variables
                    nextSegment++;
                    totalRead = 0;
                    totalWritten = 0;
                    nBytesRead = 0;
                    nBytesWritten = 0;
                    nBytesLeft = Constant.SEGMENT_SIZE;
                    
                    //Exit if last segment in streaming data
                    if(nBytesLeft == 0  ){
                        System.out.println("Audio Thread - Full song loaded into system audio buffer.");
                        break;
                    }
                    
                    if (nBytesRead == -1) {
                        System.out.println("***** Error - Audio thread couldn't read from decoded input stream.");
                        break;
                    }
                    
                    
                /*
                if(cacheManager.isThisLastSegment(mediaId, nextSegment))
                    break;
                else
                    nextSegment++;
                 */
                    
                }
                
//            // Stop
                line.drain();
                line.stop();
                line.close();
                din.close();
            }
        } catch(Exception e){
            e.printStackTrace();
        }
    }
    
    
    
    /**
     * STATUS FUNCTIONS
     */
    public boolean isSongPlaying(){
        return songIsPlaying;
    }
    
    
    public boolean isSongPaused(){
        return isSongPaused;
    }
    
    
    
    /**
     * CONTROL FUNCTIONS
     */
    
    /**
     * Stops playing audio, but doesn't empty line buffer so that audio can be resumed. 
     */
    public void pauseSong(){
        isSongPaused = true;      
    }
    
    
    /**
     * Starts playing a song, IF AND ONLY IF it's been paused.
     */
    public void playPausedSong(){
        thread.interrupt();
    }
    
    
    public void stopSong(){    
        songIsPlaying = false; //reset tracking data
        isSongPaused = false; //  "      "
        
    }
    
    
  /**
   * TODO
   */
    public void setVolume(float value){
        //volume.setValue(value);
        //System.out.printf("Volume to %f\n", value);
    }
    
    
    /**
     * This signals the tread to return from the run loop.
     */
    public void killAudioThread(){
        timeToExitThread = true;
    }
    
    
    
    
  
    
    
    
}







/*
 *
 *  private void rawplay(AudioFormat targetFormat, AudioInputStream dinRef) throws IOException, LineUnavailableException {
        din  = dinRef;
        data = new byte[4096];
        line = getLine(targetFormat);
 
 
        if (line != null) {
            // Start
            line.start();
            songIsPlaying = true;
            int nBytesRead = 0, nBytesWritten = 0;
            while (nBytesRead != -1) {
                nBytesRead = din.read(data, 0, data.length);
                if (nBytesRead != -1) nBytesWritten = line.write(data, 0, nBytesRead);
 
                //check for user clicking pause button, if true put thread to sleep.
                if(isSongPaused) {
                    try{
                        songIsPlaying = false;
                        line.stop();
                        thread.sleep(9999999); //sleep while paused.
                    } catch(InterruptedException iex){
                        line.start();
                        isSongPaused = false;
                    }
                }
                if(timeToExitThread){
                    line.stop();
                    stopSong();
                    songIsPlaying = false;
                    return;
                }
 
 
            } //end while
            stopSong();
        }//end if
 
 
    }
 
 
  public void configureAudioInputStream(int segNum) throws SegmentNotLoadedException {
        

        //Bitrate, channels, sample rate etc.
        
        try{
            if(line != null){
                line.drain();
                line.close();
                
            }
            
            //get first segment just to configure sound settings. Don't copy it's buffer into line yet.
            bis = new ByteArrayInputStream(cacheManager.getSegment(mediaId, 1));
            in = AudioSystem.getAudioInputStream(new File(Constant.pathToAnMp3));
            baseFormat = in.getFormat();
            decodedFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                    baseFormat.getSampleRate(),
                    16,
                    baseFormat.getChannels(),
                    baseFormat.getChannels() * 2,
                    baseFormat.getSampleRate(),
                    false);
            
            
            line = getLine(decodedFormat);
            line.start();
            
            
        } catch(Exception e){
            e.printStackTrace();
        }
        
    }
 
 
 
    private SourceDataLine getLine(AudioFormat audioFormat) throws LineUnavailableException {
        SourceDataLine res = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
        res = (SourceDataLine) AudioSystem.getLine(info);
        res.open(audioFormat);
        return res;
    }
 
 
 
    public void playSong(URL songURL){
        //Start playing the song
        try{
            System.out.println(songURL);
            AudioInputStream in= AudioSystem.getAudioInputStream(songURL);
            AudioInputStream din = null;
            AudioFormat baseFormat = in.getFormat();
 
            AudioFormat decodedFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                    baseFormat.getSampleRate(),
                    16,
                    baseFormat.getChannels(),
                    baseFormat.getChannels() * 2,
                    baseFormat.getSampleRate(),
                    false);
            din = AudioSystem.getAudioInputStream(decodedFormat, in);
            // Play now.
            rawplay(decodedFormat, din);
            in.close();
        } catch(Exception e){
            System.out.println("Exception thrown while starting new player: " + e.getMessage() + "\n" );
            e.printStackTrace();
        }
 
 
    }
 */