C:/Projekte/I2BPro/src/i2bpro/playlist/PlayList.java

package i2bpro.playlist;

import i2bpro.layer.Dialogs.AlbumAuswahlDlg;
import i2bpro.Exceptions.PlayListException;
import i2bpro.layer.Dialogs.Utils;
import i2bpro.layer.InfoMsg;
import i2bpro.layer.Layer;
import java.awt.Cursor;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.Proxy;
import java.net.SocketAddress;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.media.ControllerEvent;
import javax.media.Manager;
import javax.media.NoPlayerException;
import javax.media.PrefetchCompleteEvent;
import javax.swing.table.AbstractTableModel;
import org.jaudiotagger.audio.AudioFile;
import org.jaudiotagger.audio.AudioFileIO;
import org.jaudiotagger.audio.exceptions.CannotReadException;
import org.jaudiotagger.audio.exceptions.CannotWriteException;
import org.jaudiotagger.audio.exceptions.InvalidAudioFrameException;
import org.jaudiotagger.audio.exceptions.ReadOnlyFileException;
import org.jaudiotagger.tag.TagException;



public final class PlayList extends AbstractTableModel
{
    // einzigste Instanz der Klasse PlayList
    private static final PlayList instance = new PlayList();

    //  Wiedergabetyp (m3u_1 - einfache M3U, m3u_2 - erweiterte M3U,
    //  cue - cuesheet)
    private String playlisttype = null;   //  Type der Playlist

    //  playlist enthält die Wiedergabeliste
    private HashMap<Integer, HashMap<String, String>> playlist
            = new HashMap<Integer, HashMap<String, String>>();
    
    private  M3U m3u = null;    //  M3U-Object
    private  CUE cue = null;    //  CUE-Object

    // nach Initialisierung einer Wiedergabeliste enthält filename
    //  den Pfad zur Wiedergabeliste
    private String filename = null;

    //  speichert Schlüsselwerte der Metadaten
    private HashMap<Integer, String> keys = new HashMap<Integer, String>();

    //  Anzahl der Spalten
    private final int columns = 7;

    //  Adresse zur Datenbank von freedb.org
    private final String adress = "http://freedb.freedb.org/~cddb/cddb.cgi";
    
    //  merkt sich den Zustand darüber ob der Player Prefetched ist oder nicht
    private boolean notPrefetched = true;

    // speichert welche Zeile gerade selektriert ist.
    private int rowSelected = -1;



    private PlayList()
    {
        keys.put(0, null);
        keys.put(1, null);
        keys.put(2, "title");
        keys.put(3, "artist");
        keys.put(4, "album");
        keys.put(5, "genre");
        keys.put(6, "year");
    }



    public static PlayList getInstance() { return instance; }



    public int getRowCount() { return playlist.size(); }



    public int getColumnCount() { return columns; }



    public Object getValueAt(int rowIndex, int columnIndex)
    {
        if (columnIndex == 0)
            return null;
        else if (columnIndex == 1)
            return String.valueOf(rowIndex);
        return playlist.get(rowIndex).get(keys.get(columnIndex));
    }



    @Override
    public String getColumnName(int columnIndex)
    {
        String columnName = null;
        switch(columnIndex)
        {
            case 0: columnName = ""; break;
            case 1: columnName = "Lfd.Nr."; break;
            case 2: columnName = "Titel"; break;
            case 3: columnName = "Artist"; break;
            case 4: columnName = "Album"; break;
            case 5: columnName = "Genre"; break;
            case 6: columnName = "Jahr"; break;
        }
        return columnName;
    }



    @Override
    public Class getColumnClass(int columnIndex)
    {
        return String.class;
    }



    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex)
    {
        //  Es sind alle Zellen editierbar, welche Metadaten des Audiotitels
        //  beinhalten.
        if (columnIndex > 1) return true;
        return false;
    }



    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex)
    {
        if (columnIndex == 0)
        {
            // Wurde die Spalte 1 der Tabelle angegeben so ist zu
            //  prüfen ob der Wert der Zelle null ist. Ist er es so ist
            //  die selektrierte Zeile mit -1 (keine Selektrierun) zu vermerken,
            //  Ansonsten ist der Zeilenindex als selektrierte Zeile zu merken.
            rowSelected = (aValue == null) ? -1 : rowIndex;
        } else if (columnIndex > 1)
        {
            // Ist die Spalte eine mit MEtadaten, so sind die Weerte in der
            //  Tabelle und Wiedergabeliste entsprechend zu ändern.
            playlist.get(rowIndex).put(keys.get(columnIndex), (String) aValue);
            Layer.getInstance().setSave(true);
        }
    }

    public void setPlayList(String file) throws PlayListException, 
            FileNotFoundException, IOException, CannotReadException,
            TagException, ReadOnlyFileException, InvalidAudioFrameException
    {
        //  Prüfung, um welche Art von Wiedergabeliste es sich handelt.
        //  Handelt es sich nicht um eine m3u-Wiedergabeliste, so ist
        //  eine Exception auszulösen.
        String extension = Utils.getExtension(new File(file));
        if (extension.equals(Utils.m3u))
        {
            //  Cursor auf den Warte-Cursor setzen
            Cursor old_cursor = Layer.getInstance().getCursor();
            Layer.getInstance().setCursor(new Cursor(Cursor.WAIT_CURSOR));

            // Mithilfe des M3U-Objektes die Wiedergabeliste auslesen und der
            //  playlist übergeben
            m3u = new M3U(file);
            playlist = m3u.getPlayList();

            //  wiedergabetyp merken
            playlisttype = m3u.getPlayListType();

            //  Alten Cursor wiederherstellen
            Layer.getInstance().setCursor(old_cursor);
        } else if (extension.equals(Utils.cue))
        {
            //  Cursor auf den Warte-Cursor setzen
            Cursor old_cursor = Layer.getInstance().getCursor();
            Layer.getInstance().setCursor(new Cursor(Cursor.WAIT_CURSOR));

            // Mithilfe des CUE-Objektes die Wiedergabeliste auslesen und der
            //  playlist übergeben
            cue = new CUE(file);
            playlist = cue.getPlayList();

            //  wiedergabetyp merken
            playlisttype = cue.getPlayListType();

            //  Alten Cursor wiederherstellen
            Layer.getInstance().setCursor(old_cursor);
        }
        //  Pfadangabe zur Wiedergabeliste merken
        filename = file;

    }



    public HashMap<Integer, HashMap<String, String>> getPlayList()
    {
        return playlist;
    }



    public String getMeta(int id, String key)
    {
        String val = null;
        try { val = (String) playlist.get(id).get(key); }
        catch (NullPointerException ex) {}
        return val;
    }



    public String getType() {return playlisttype;}



    public String getFileName() {return filename;}



    public void PlayListSave(String filename)
            throws PlayListException, IOException
    {
        if ((playlisttype.equals("m3u_1")) || (playlisttype.equals("m3u_2")))
        {
            //  Wenn der Typ der Wiedergabeliste eine m3u ist, ist das
            //  M3U-Object zur Speicherung der Wiedergabeliste zu verwenden.
            m3u.SavePlayList(filename, playlisttype, playlist);
            Layer.getInstance().setSave(false);
        } else if (playlisttype.equals("cue"))
        {
            cue.savePlayList(playlist, filename);
            Layer.getInstance().setSave(false);
        } else {
            //  Handelt es sich nicht um eine M3U- oder CUE Wiedergabeliste, so ist
            //  eine Exception auszulösen.
            throw new PlayListException(201);
        }
    }



    public void InsertMedia(File[] selectedFiles) throws CannotReadException, 
            IOException, TagException, ReadOnlyFileException,
            InvalidAudioFrameException
    {
        if (playlisttype.equals("m3u_1") || playlisttype.equals("m3u_2"))
        {
            //  Ist die Wiedergabeliste vom Typ m3u, so wird die Liste der
            //  Audiodateien dem m3u-Object übergeben
            m3u.InsertMedia(selectedFiles);

            //  Rücklesen der im m3u-Object gebildeten Wiedergabeliste
            playlist = m3u.getPlayList();

            //  Audioplayer aktualisieren
            Layer.getInstance().PlayListChange();

            //  Den Save Modus des Audioplayers setzen, da sich die
            //  Wiedergabeliste geändert hat.
            Layer.getInstance().setSave(true);
        }
    }



    public void DeleteMedia(int del_id)
    {
        if (playlisttype.equals("m3u_1") || playlisttype.equals("m3u_2"))
        {
            //  Ist die Wiedergabeliste vom Typ m3u, so ist das
            //  löschen über das m3u-Object vorzunehmen
            m3u.DeleteMedia(del_id);

            //  Rücklesen der im m3u-Object gebildeten Wiedergabeliste
            playlist = m3u.getPlayList();

            //  Audioplayer aktualisieren
            Layer.getInstance().PlayListChange();

            //  Den Save Modus des Audioplayers setzen, da sich die 
            //  Wiedergabeliste geändert hat.
            Layer.getInstance().setSave(true);
        }
    }



    public void getAlbumInfo() throws CannotReadException, IOException, 
            TagException, ReadOnlyFileException, InvalidAudioFrameException,
            PlayListException, NoPlayerException, InterruptedException
    {
        // Deklaration und initialisieren der Variablen
        HashMap<Integer, Integer> times = new HashMap<Integer, Integer>();
        int duration = 2;
        int TrackLength = 0;
        int TrackBegin = 0;
        int Tracks = playlist.size();
        int i = 0;

        //  Einzelzeiten der Audiotitel feststellen und Gesamtzeit des Albums
        //  berechnen.
        for(i=0; i<Tracks; i++)
        {
            File file = new File((String) playlist.get(i).get("media"));
            try
            {
                AudioFile audiofile = AudioFileIO.read(file);
                TrackLength = audiofile.getAudioHeader().getTrackLength();
            }
            catch (CannotReadException ex)
            {
                notPrefetched = true;
                int counter = 30;
                javax.media.Player player;
                player = Manager.createPlayer(file.toURI().toURL());
                player.prefetch();
                while(notPrefetched && (counter > 0))
                {
                    counter--;
                    Thread.sleep(100);
                }
                TrackLength = (int)player.getDuration().getSeconds();
            }
            TrackBegin = 75 * (TrackLength + duration);
            times.put(i, TrackBegin);
            duration += TrackLength;
        }

        //  Zusammenstellen der Abfrage
        String query = "?cmd=discid+" + Tracks + "+150";
        for (i=0; i<Tracks-1; i++) query += "+" + times.get(i);
        query += "+" + duration + "&hello=test+abc+blah+1.0&proto=6";
        String result = null;
        try
        {
            //  Abfrage an freedb.org stellen
            result = new Scanner(new URL(adress+query).openStream()).useDelimiter("\\Z").next();
        }
        catch (UnknownHostException ex) 
        {
            System.err.println(ex);
            throw new PlayListException(202);
        }
        catch (Exception ex) {ex.printStackTrace();}
        System.out.println(result);

        //  Liste der möglichen Alben zusammenstellen
        int code = Integer.parseInt(result.substring(0, result.indexOf(" ")), 10);
        if (code != 200) InfoMsg.show(3); else
        {
            String discid = result.substring(result.lastIndexOf(" ")+1, result.length());
            query = "?cmd=cddb+query+" + discid + query.substring(11, query.length());
            result = new Scanner(new URL(adress+query).openStream()).useDelimiter("\\Z").next();
            System.out.println(result);
            code = Integer.parseInt(result.substring(0, result.indexOf(" ")), 10);
            if ((code > 199) && (code < 300))
            {
                //  Bei gefundenen Alben, diese mittels des AlbumAuswahlDialogs
                //  dem Anwender zur Auswwahl vorlegen
                AlbumAuswahlDlg dlg = new AlbumAuswahlDlg(result);
                dlg.run();
            } else {
                //  Wurden keine Alben gefunden, dann den Anwender darüber
                //  informieren
                InfoMsg.show(4);
            }
        }
    }



    public void setAlbumInfos(String album) throws MalformedURLException,
            IOException, CannotReadException, TagException,
            ReadOnlyFileException, InvalidAudioFrameException,
            CannotWriteException, PlayListException
    {
        //  Abfrage-String zusammenstellen
        String query = "?cmd=cddb+read+" + album +
                "&hello=test+abc+blah+1.0&proto=6";

        //  Es wird versucht von freedb.org die Daten zum Album auszulesen
        String result = new Scanner(
                new URL(adress+query).openStream()).useDelimiter("\\Z").next();

        // HasMap zum speichern der Albuminformationen initialisieren
        HashMap<String, String> daten = new HashMap<String, String>();
        daten.put("AlbumTitel", "");
        daten.put("AlbumArtist", "");
        daten.put("AlbumJahr", "");
        daten.put("Genre", "");

        //  Albumtitel ermitteln
        Pattern pattern = Pattern.compile("DTITLE=");
        Matcher matcher = pattern.matcher(result);
        int pos = 0;
        if (matcher.find()) 
        {
            pos = matcher.end();
            String[] dtitle = result.substring(
                    pos, result.indexOf("\n", pos)).split(" / ");
            daten.put("AlbumTitel", dtitle[1]);
            daten.put("AlbumArtist", dtitle[0]);
        }

        // Jahr in dem das Album herausgegeben wurde ermitteln
        pattern = Pattern.compile("DYEAR=");
        matcher = pattern.matcher(result);
        if (matcher.find())
        {
            pos = matcher.end();
            daten.put("AlbumJahr", result.substring(
                    pos, result.indexOf("\n", pos)));
        }

        // Genre des Albums ermitteln
        pattern = Pattern.compile("DGENRE=");
        matcher = pattern.matcher(result);
        if (matcher.find())
        {
            pos = matcher.end();
            daten.put("Genre", result.substring(pos, result.indexOf("\n", pos)));
        }

        //  Für die einzelnen Audiotitel die Titel ermitteln und Daten
        //  in die Wiedergabeliste übernhemen
        for (int i=0; i<playlist.size(); i++)
        {
            pattern = Pattern.compile("TITLE" + i + "=");
            matcher = pattern.matcher(result);
            String title = "";
            if (matcher.find())
            {
                pos = matcher.end();
                title = result.substring(pos, result.indexOf("\n", pos));
                if (title == null) title = "";
            }
            setValueAt(title, i, 2);
            setValueAt(daten.get("AlbumTitel"), i, 4);
            setValueAt(daten.get("Genre"), i, 5);
            setValueAt(daten.get("AlbumJahr"),i, 6);
        }
        // grafische Oberfläche mitteilen, dass sich die Wiedergabeliste
        // geändert hat
        Layer.getInstance().PlayListChange();
    }



    public void controllerUpdate(ControllerEvent ce)
    {
        if (ce instanceof PrefetchCompleteEvent) notPrefetched = false;
    }



    public void changeSequence(int old_id, int new_id)
    {
        HashMap<Integer, HashMap<String, String>> tmpplaylist =
                new HashMap<Integer, HashMap<String, String>>();
        tmpplaylist.put(new_id, playlist.get(old_id));
        tmpplaylist.put(old_id, playlist.get(new_id));
        playlist.put(new_id, tmpplaylist.get(new_id));
        playlist.put(old_id, tmpplaylist.get(old_id));
    }



    public void changePlayList(HashMap<Integer, HashMap<String, String>> playlist)
    {
        this.playlist = playlist;
    }
}