/*
 *
 *  $Revision: 1314 $
 *  $Date: 2020-03-19 09:11:27 -0700 (Thu, 19 Mar 2020) $
 *  $URL: svn://fred.webarts.bc.ca/open/trunk/projects/WebARTS/ca/bc/webarts/widgets/tunes/Album.java $
 *
 *  Written by Tom Gutwin - WebARTS Design.
 *  http://www.webarts.bc.ca
 *  Copyright (C) 2016-2019 WebARTS Design, North Vancouver Canada
 *  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; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package ca.bc.webarts.widgets.tunes;

import ca.bc.webarts.widgets.Quick;
import ca.bc.webarts.widgets.Util;
import ca.bc.webarts.tools.musicbrainz.*;

import java.io.File;
import java.util.Vector;

import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonArrayBuilder;
import javax.json.JsonObject;
import javax.json.JsonWriter;
import javax.json.JsonWriterFactory;
import javax.json.stream.JsonParser;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;

/** Class to hold an album as a java object. **/
  public class Album implements java.lang.Comparable<Album>
  {
    private String name_ = "";
    private String artistName_ = "";
    private String albumArtistName_ = "";
    private String artistDir_ = "";
    private File albumDirFile_ = null;
    Vector <Song> songs = new Vector <Song>();
    private String downloadLink_ = "";
    private de.umass.lastfm.Album lastFmAlbum_ = null;
    private java.util.Date releaseDate_ = null;
    int releaseYear_ = 1900;
    private String mbid_ = "";
    private MusicbrainzRestRequester mbRR_ = null;
    private MusicbrainzRelease mb_ = null;
    /** Flag to control if this class should use Musibrainz lookups to augment the information about this Artist. **/
    private boolean useMusicBrainz_ = Artist.useMusicBrainz_;

     /** The 2 digit HEX char/byte Reference KEY for this Albub .
      * Example 0a. <br>
      * Each artist should have a unique key based on the parsing of the tunes root directory. It is created each time the roor directory is parsed.
      * It is based on an alpha nemeric sorted list of Artist Full (non hashed) spaceRemoved DirNames. (ie. VelvetRevolver )
      **/
    private char[] refKEY_ = {'0','0'};
    private char[] artistRefKEY_ = {'0','0','0','0'};



  /**  A holder for this clients System File Separator.  */
  public final static String SYSTEM_FILE_SEPERATOR = java.io.File.separator;

  /**  A holder for this clients System line termination separator.  */
  public final static String SYSTEM_LINE_SEPERATOR =
                                           System.getProperty("line.separator");


    /**
      * Constructor for Album.
      *
      * @throws Exception if the artist file dir does not exist of can't read as a dir.
    **/
    public Album(String albumFileDirPath, boolean useMusicbrainz, int albumRefKey, char[] artistRefKEY) throws Exception
    {
      if( ! ( albumRefKey < (16*16) && albumRefKey >-1) ) throw new Exception("invalid refKey");
      if(artistRefKEY!=null && artistRefKEY_.length==4) artistRefKEY_ = artistRefKEY;

      refKEY_ = Util.toHEXChars(albumRefKey, refKEY_.length);
      File albumDirFile = new File(albumFileDirPath);
      useMusicBrainz_ = useMusicbrainz;
      if(albumDirFile!=null && albumDirFile.isDirectory() && albumDirFile.canRead())
        this.albumDirFile_ = albumDirFile;
      else
        throw new java.lang.Exception("Error with Album dirFilePath: "+albumFileDirPath);

      String artistDirName = albumDirFile_.getAbsolutePath().substring(0, albumDirFile_.getAbsolutePath().lastIndexOf("/"));
      albumArtistName_ = Song.removeExplicit(artistDirName.substring(artistDirName.lastIndexOf("/")+1).trim());
      if(
          !"VariousArtists".equalsIgnoreCase(albumArtistName_) &&
          !"randyBachman&BurtonCummings".equalsIgnoreCase(albumArtistName_)
        ) artistName_ = Util.capsToSpacesInString(albumArtistName_).trim();
      else artistName_ = "";
      readSongs();
      //retrieveLastFmAlbum
      if(useMusicBrainz_)
      {
        try
        {
          mb_ = new MusicbrainzRelease(artistName_, albumTitle(false), albumFileDirPath, true);
          releaseYear_ = mb_.getYear();
          setReleaseDate(new java.util.Date(releaseYear_,1,1));
        }
        catch(Exception ex)
        {
          /* ignore error dirs */
          System.out.println("Can't Read Musicbrainz: "+artistName_ +" for dir="+albumFileDirPath);
          setReleaseDate(new java.util.Date(1900,1,1));
        }
      }
      else
        setReleaseDate(new java.util.Date(1900,1,1));

    } // -- Constructor


    /** Reads the song files in the dir and loads the songs vector. It is called from the constructor.**/
    private void readSongs()
    {
      File[] songDirFiles = albumDirFile_.listFiles();
      String currFilePath = "";
      int songCount = 0;
      Song currSong = null;
      if(songDirFiles!=null)
        for(File currFile : songDirFiles)
        {
          try
          {
            currFilePath = currFile.getAbsolutePath();
            if(!currFile.isDirectory() && currFile.canRead()&&
               (currFilePath.endsWith(".ogg") || currFilePath.endsWith(".oga") ||
                currFilePath.endsWith(".mp3") || currFilePath.endsWith(".flac")))
            {
              songCount++;
              currSong = new Song(currFile.getAbsolutePath(),
                                  "<a class=\"Song"+songCount+"\" id=\"Song"+songCount+"\" name=\"Song"+songCount+"\" href=\"#\" >",
                                  "</a>",
                                  refKEY_);
              currSong.setLibraryIndex(songCount);
              currSong.setArtistRefKEY(getArtistRefKEY());
              this.songs.add(currSong);
              if(artistDir_==null || "".equals(artistDir_)) setArtistDir(currSong.artistDir());
            }
          }
          catch(Exception ex) { /* ignore error dirs */System.out.println("Can't Read Song: "+currFilePath);ex.printStackTrace(); }
        }

    }


  /**
    * Set Method for class field 'artistDir_'.
    *
    * @param artistDir is the value to set this class field to.
    *
    **/
  public  void setArtistDir(String artistDir)
  {
    this.artistDir_ = artistDir;
  }  // setArtistDir Method


  /**
    * Get Method for class field 'artistDir_'.
    *
    * @return String - The value the class field 'artistDir_'.
    *
    **/
  public String getArtistDir()
  {
    String retVal = ""; name(true);
    if(artistDir_!=null && !artistDir_.equals("")) retVal =  artistDir_;
    return retVal;
  }  // getArtistDir Method


  public void setDownloadLink(String linkStr)
  {
    downloadLink_ = linkStr;
  }


  public String getDownloadLink()
  {
    return downloadLink_;
  }


  /** gets the refKey_ as a HEX String (ie.  0b ) . **/
  public String getRefKeyString()
  {
    String retVal = "";

    //System.out.println("getRefKeyString() refKEY_="+java.util.Arrays.toString(refKEY_));
    try
    {
      //System.out.println("getRefKeyString() Hex.decodeHex(refKEY_)="+Hex.decodeHex(refKEY_));
      //System.out.println("getRefKeyString() Hex.encodeHexString(refKEY_)="+Hex.encodeHexString(Hex.decodeHex(refKEY_)));
      retVal =  Hex.encodeHexString(Hex.decodeHex(refKEY_));  //only takes EVENnumber of chars
    }
    catch (DecoderException dEx)
    {
      //send back an empty String
      System.out.println("getRefKeyString() Crapped Out: "+dEx.getMessage());
    }
    return retVal;
  }


  /**
    * Set Method for class field 'refKEY_' for this Album.
    *
    * @param refKEY is the value to set this class field to.
    *
    **/
  public  void setRefKEY(char[] refKEY)
  {
    this.refKEY_ = refKEY;
  }  // setRefKEY_ Method


  /**
    * Set Method for class field 'artistRefKEY_'  for this Album.
    *
    * @param artistRefKEY is the value to set this class field to.
    *
    **/
  public  void setArtistRefKEY(char[] artistRefKEY)
  {
    this.artistRefKEY_ = artistRefKEY;
  }  // setartistRefKEY_ Method


  /**
    * Get Method for class field 'refKEY_' for this Album.
    *
    * @return char[] - The value the class field 'refKEY_'.
    *
    **/
  public char[] getRefKEY()
  {
    return refKEY_;
  }  // getrefKEY Method


  /**
    * Get Method for class field 'artistRefKEY_' for this Album.
    *
    * @return char[] - The value the class field 'artistRefKEY_'.
    *
    **/
  public char[] getArtistRefKEY()
  {
    return artistRefKEY_;
  }  // getartistRefKEY Method


  public String getArtistRefKeyString()
  {
    String retVal = "";
    try
    {
      retVal =  Hex.encodeHexString(Hex.decodeHex(artistRefKEY_));  //only takes EVENnumber of chars
    }
    catch (DecoderException dEx)
    {
      //send back an empty String
      System.out.println("getArtistRefKeyString() Crapped Out: "+dEx.getMessage());
    }
    return retVal;
  }


  public boolean isArtistRefKEYEmpty()
  {
    return (artistRefKEY_[0]=='0' && artistRefKEY_[1]=='0' && artistRefKEY_[2]=='0' && artistRefKEY_[3]=='0' ) ;
  }  // getartistRefKEY Method



  public char[] retrieveArtistRefKey()
  {
    String artistDirName = albumDirFile_.getAbsolutePath().substring(0, albumDirFile_.getAbsolutePath().lastIndexOf("/"));
    String jsonStr = Util.readFileToString(artistDirName+SYSTEM_FILE_SEPERATOR+"MetaData.json");
    int indx = jsonStr.indexOf("refKey")+10;
    System.out.println("DEBUG: retrieveArtistRefKey : artist.refKey.json.indx="+indx);
    if(indx>10)
    {
      artistRefKEY_[0] = jsonStr.charAt(indx);
      artistRefKEY_[1] = jsonStr.charAt(indx+1);
      artistRefKEY_[2] = jsonStr.charAt(indx+2);
      artistRefKEY_[3] = jsonStr.charAt(indx+3);
      System.out.println("DEBUG: retrieveArtistRefKey : artistRefKEY_ " +artistRefKEY_[0]+artistRefKEY_[1]+artistRefKEY_[2]+artistRefKEY_[3]);
    }

    return artistRefKEY_;
  }  // retrieveArtistRefKey Method


  /** Cobbles together the meta-data information about this Artist Directory in a JSON string. **/
  public String toMetaJson()
  {
    String retVal = "";

    retVal =  MusicMakerTunesHelper.prettyPrint(toMetaJsonObject());

    return retVal;
  }


  /** Cobbles together the meta-data information about this Artist Directory in a JSON Object. **/
  public JsonObject toMetaJsonObject()
  {

    int songNum = 0;
    JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
    String songRefKey = "";
    //songNamesSortByTrackNum(true).trim();
    String currSongStr = "null";
    for(Song currSong : getSongArraySortedByTrackNum2())
    {
      currSongStr = "null";
      if(currSong!=null && !"".equals(currSongStr))
      currSongStr = currSong.name(true);
      //Song currSong = new Song(albumDirFile_.getAbsolutePath()+SYSTEM_FILE_SEPERATOR+
      try
      {
        //songRefKey = ""+ currSong.getNumber();
        songRefKey = Hex.encodeHexString(Hex.decodeHex(Util.toHEXChars(currSong.getNumber(),2)));
        songNum++;
        JsonObject jsonObject = Json.createObjectBuilder()
                              .add("dirFile", currSong.getSongFilePath().substring(currSong.getSongFilePath().lastIndexOf(SYSTEM_FILE_SEPERATOR)+1))
                              .add("dirType", DirFileRef.DirType.RELEASE.typeStr)
                              .add("dirState", DirFileRef.DirState.LONG.stateStr)
                              .add("title", currSong.songTitle())
                              .add("trackNum", currSong.getNumber())
                              .add("musicBrainzID", "???")
                              .add("refKey", songRefKey)
                              .add("albumRefKey", currSong.getAlbumRefKeyString())
                              .add("artistRefKey", currSong.getArtistRefKeyString())
                            .build();
        arrayBuilder.add( jsonObject);
      }
      catch (DecoderException dEx)
      {
        //send back an empty String
        System.out.println(albumTitle(true)+" toMetaJsonObject() Crapped Out: "+dEx.getMessage());
        System.out.println(" SKIPPING Song["+songNum+"] "+currSongStr);
      }
      catch (Exception ex)
      {
        //send back an empty String
        System.out.println(albumTitle(true)+" toMetaJsonObject() Crapped Out: ");
        System.out.println(" songRefKey = "+songRefKey);
        System.out.println("   currSong = "+currSongStr);
        ex.printStackTrace();
      }
    }
    JsonArray songArray = arrayBuilder.build();

    JsonObject json = Json.createObjectBuilder()
        .add("dirFile", albumDirFile_.getAbsolutePath() )
        .add("dirType", DirFileRef.DirType.ALBUM.typeStr )
        .add("dirState", DirFileRef.DirState.LONG.stateStr)
        .add("refKey", getRefKeyString() )
        .add("albumName", albumTitle(false) )
        .add("shortAlbumName", albumTitle(true) )
        .add("artistRefKey", getArtistRefKeyString())
        .add("musicBrainzID", getMbid())
        .add("numSongs", getNumberOfSongs() )
        .add("songs", songArray )
      .build();

    return json;
  }


    public void writeMetaJsonFile()
    {
      String metaStr = toMetaJson();
      System.out.println("\nWriting ALBUM MetaJson\n"+albumDirFile_.getAbsolutePath()+SYSTEM_FILE_SEPERATOR+"MetaData.json");
      Util.writeStringToFile(metaStr, albumDirFile_.getAbsolutePath()+SYSTEM_FILE_SEPERATOR+"MetaData.json");
    }


    public void writeHtmlDivFile()
    {
      String htmlStr = toMusicMakerHtmlDivString();
      System.out.println("\nWriting ALBUM HTML Div\n"+albumDirFile_.getAbsolutePath()+SYSTEM_FILE_SEPERATOR+"Album.html");
      Util.writeStringToFile(htmlStr, albumDirFile_.getAbsolutePath()+SYSTEM_FILE_SEPERATOR+"Album.html");
    }


  public String toMusicMakerHtmlDivString()
  {
    String albDirName = Util.tokenReplace(name(true),"%2f","%252f");

    String retVal = "<div id="+albumArtistName_+" class=musicmakeralbum >";
          String lastFmAlbumUrl = retrieveLastFmAlbumUrl(albumArtistName_, albumTitle()).replace("#","%23");
          lastFmAlbumUrl = Util.tokenReplace(lastFmAlbumUrl,"#","%23");
          retVal+= "  <ol>";
          retVal+= SYSTEM_LINE_SEPERATOR;
          retVal+= "  <img id=\""+albumArtistName_.trim()+" " +albumTitle(true)+"\" alt=\""+albumTitle()+" Album Cover Thumbnail\" src=\""+
                           getArtistDir()+"/"+albDirName+
                           "/cover.jpg"+"\" class=\"\" style=\"margin:0px;\" height=\"32px\" width=\"32px\"/>";
          retVal+= " <b><u> ";
          if(!"".equals(lastFmAlbumUrl))retVal+= " <a href=\""+lastFmAlbumUrl+"\"  target=\"_blank\"> ";
          retVal+= albumTitle();
          if(!"".equals(lastFmAlbumUrl))retVal+= " </a> ";
          retVal+= "</u></b>";
          retVal+= " <span style=\"font-size: 0.7em;\">";
          retVal+= " ("+ getReleaseYear() + ")</span>";
          retVal+= SYSTEM_LINE_SEPERATOR;
          String [] sNames =  songNames(true,true,("VariousArtists".equalsIgnoreCase(artistDir_)?1:0)); // songNames(true,true,1); the last sortType=1 sorts by trackNum,  sortType=0 sorts by name

          int songNum = 0;
          String songRefKey = "";
          //songNamesSortByTrackNum(true).trim();
          String currSongStr = "null";
          String artistDirName = albumDirFile_.getAbsolutePath().substring(0, albumDirFile_.getAbsolutePath().lastIndexOf("/"));
          // work with the sorted list
          for (String currSongName : sNames)
            for (Song currSong : songs)
              if (currSong.name(true).equals(currSongName) )
              {
                String url = albumDirFile_.getAbsolutePath();
                url += Util.tokenReplace(name(true),"?","%3F");
                url = Util.tokenReplace(url,"&","%26");
                url = Util.tokenReplace(url,"!","%21");
                url = Util.tokenReplace(url,"%2f","%252f");
                url = Util.tokenReplace(url,"%2F","%252F");

                retVal+= "    <li><a href=\"";
                retVal+= currSong.getSongFilePath();
                retVal+= "\">"+currSong.songTitle(false);
                retVal+= "</li>\n";
                //retVal+= currSong.toString(html);
              }
          retVal+= "  </ol>";
          retVal+= SYSTEM_LINE_SEPERATOR;
    retVal += "</div>";
    return retVal;
  }


    /**
    * Set Method for class field 'mbid_'.
    *
    * @param mbid is the value to set this class field to.
    *
    **/
  public  void setMbid(String mbid)
  {
    this.mbid_ = mbid;
  }  // setMbid Method


  /**
    * Get Method for class field 'mbid_'.
    *
    * @return String - The value the class field 'mbid_'.
    *
    **/
  public String getMbid()
  {
    return mbid_;
  }  // getMbid_ Method


  public boolean contains(String SongNameNoSpaces)
  {
    boolean retVal = false;
    for(Song currSong : this.songs) if(currSong.name(false).equals(SongNameNoSpaces)) retVal = true;
    return retVal;
  }


  /**
    * Sorted song file Names alphabetically with spaces in names .
    * @return an array of song names
    **/
  public String [] songNames(){return songNames(false,true);}


  /**
    * Sorted song file Names alphabetically with spaces in names .
    *
    * @param removeSpaces flags to remove Spaces from the songName or return CamelCase
    * @return an array of song names
    **/
  public String [] songNames(boolean removeSpaces){return songNames(removeSpaces,true);}


  /**
    * song file Names allowing you to contol sorting and spacing.
    *
    * @param removeSpaces flags to remove Spaces from the songName or return CamelCase
    * @param sorted flags to sort or not sort using default sortByNumbers
    * @return an array of song names
    **/
  public String [] songNames(boolean removeSpaces, boolean sorted){return songNames(removeSpaces, sorted, 1);}


  /**
    * song file Names allowing you to contol sorting and spacing.
    *
    * @param removeSpaces flags to remove Spaces from the songName ie. CamelCase
    * @param sorted flags to sort or not sort
    * @param sortBy signals what to sortby - 0=alphabetical Name or by 1=trackNumber
    * @return an array of song names
    **/
  public String [] songNames(boolean removeSpaces, boolean sorted, int sortBy)
  {
    /* sortBy signals what to sortby - 0=name or by 1=trackNumber */
    String[] songNames = new String[songs.size()];
    for(int i=0; i< songNames.length; i++) songNames[i]=songs.get(i).name(removeSpaces); // name returns the songs filename with no path
    if (sorted)
      if(sortBy==1) songNames =  songNamesSortedByTrackNum(removeSpaces);
      else Quick.sort(songNames);
    String[] retVal = songNames;
    if(!removeSpaces) for(int i=0; i< songNames.length; i++) retVal[i] = Util.capsToSpacesInString(songNames[i]);
    return retVal;
  }


  /** Sorted songTitles with spaces in names . **/
  public String [] songTitles(){return songTitles(false,true);}
  public String [] songTitles(boolean removeSpaces){return songTitles(removeSpaces,true);}
  public String [] songTitles(boolean removeSpaces, boolean sorted)
  {
    String[] songTitles = new String[songs.size()];
    for(int i=0; i< songTitles.length; i++) songTitles[i]=songs.get(i).songTitle(removeSpaces);
    if (sorted) Quick.sort(songTitles);
    String[] retVal = songTitles;
    if(!removeSpaces) for(int i=0; i< songTitles.length; i++) retVal[i] = Util.capsToSpacesInString(songTitles[i]);
    return retVal;
  }


  /**
    * Sorts the Passed in songNames by their track number on this album.
    * SongName part of the filename including extension with or without thw spaces in name .
    * @deprecated
    **/
  @Deprecated
  public String [] songNamesSortByTrackNum(boolean removeSpaces)
  {
    //System.out.println("  }} Album.songNamesSortByTrackNum("+(removeSpaces?"removeSpaces)":"NOT removeSpaces)"));
    String[] songNames = new String[songs.size()];
    int [] songNums = new int[songs.size()];
    int [] songCDNums = new int[songs.size()];
    Song sn = null;
    int maxCDNum = 1;
    int i=0;
    for(i=0; i< songNames.length; i++)
    {
      sn = songs.get(i);
      songNames[i]=sn.name(removeSpaces); // name returns the songs filename with no path
      songNums[i]=sn.getNumber();
      songCDNums[i]=sn.getCdNumber();
      if(songCDNums[i]>maxCDNum) maxCDNum = songCDNums[i];
    }
    String[] retVal = new String[maxCDNum*songs.size()];
    int j=0;
    int numMissing = 0;
    boolean validNums = true;
    boolean done = false;
    boolean busted = false;
    int cdNum=1;
    int lastCD = 1;
    //if(maxCDNum>1) System.out.print("  }} cdNum/maxCDNum ="+cdNum+"/"+maxCDNum);
      for(i=0; i< songNames.length && validNums && cdNum<=maxCDNum; i++)
      {
        while(cdNum<=maxCDNum && !done && !busted)
        {
          retVal[i]="";
          if(maxCDNum>1) System.out.print("  cdNum="+cdNum+"/"+maxCDNum);
          if(maxCDNum>1) System.out.println("  ."+songCDNums[i]+" "+numMissing);
          if(cdNum==songCDNums[i])
          {
            done = false;
            while(!done && !busted)
            {
              for(j=0; j< songNames.length && !done; j++)
              {
                if(maxCDNum>1) System.out.print(":"+songCDNums[j]+"."+songNums[j]);
                if(cdNum==songCDNums[j] && songNums[j]==i+1+numMissing)
                {
                  retVal[i+((cdNum-1)*songNames.length)]=songNames[j];
                  done = true;
                  if(maxCDNum>1) System.out.println("!!");
                }
              }
              if(!done) //"".equals(retVal[i]))
              {
                numMissing++;
                if(numMissing>=100)
                {
                  validNums = false;
                  busted=true;
                  cdNum++;
                  System.out.println("\n  }}}"+name()+" cdNum/maxCDNum ="+cdNum+"/"+maxCDNum);
                  System.out.println("\n    BUSTED }}} looking for CD "+songCDNums[i]+":songNum["+i+"]="+songNums[i]+": choked on ["+j+"-1] of "+songNames.length);
                  System.out.println("\n    BUSTED }}} too many missing songs: "+numMissing);
                }
              }
            }
            //cdNum++;
          }
          else cdNum++;
        }
      }
    if(!validNums)
    {
      System.out.println("  }}     : "+name() );
      System.out.println("  }}   CD: "+java.util.Arrays.toString(songCDNums));
      System.out.println("  }} NUMS: "+java.util.Arrays.toString(songNums));
      System.out.println("  }} IN: "+java.util.Arrays.toString(songNames));
      System.out.println("  }} --> missing songs: "+numMissing);
      System.out.println("  }} OUT: "+java.util.Arrays.toString(retVal)+"\n");
    }

    return (validNums?retVal:songNames(removeSpaces, true,0));
  }


  /**
    Sorts the Passed in songNames by their track number on this album.
      SongName part of the filename including extension with or without thw spaces in name .
   **/
  public String [] songNamesSortedByTrackNum(boolean removeSpaces)
  {
    //System.out.println("  }} Album.songNamesSortByTrackNum("+(removeSpaces?"removeSpaces)":"NOT removeSpaces)"));
    String[] songNames = new String[songs.size()];
    int [] songNums = new int[songs.size()];
    int [] songCDNums = new int[songs.size()];
    Song sn = null;
    int maxCDNum = 1;
    int i=0;
    for(i=0; i< songNames.length; i++)
    {
      sn = songs.get(i);
      songNames[i]=sn.name(removeSpaces); // name returns the songs filename with no path
      songNums[i]=sn.getNumber();
      songCDNums[i]=sn.getCdNumber();
      if(songCDNums[i]>maxCDNum) maxCDNum = songCDNums[i];
    }
    String[] retVal = new String[maxCDNum*songs.size()];
    int j=0;
    int nextIndex = 0;
    int nextSongNum = 0;
    boolean validNums = true;
    boolean done = false;
    int cdNum=1;

    for(int currCD=1; currCD<=maxCDNum; currCD++)
    {
      for(nextSongNum=1; nextSongNum< 150 && nextIndex<songNames.length; nextSongNum++)
      {
        done = false;
        for(j=0; j< songNames.length && !done; j++)
          if(currCD==songCDNums[j] && songNums[j]==nextSongNum)
          {
            retVal[nextIndex++]=songNames[j];
            done = true;
          }
      }
    }

    validNums = (nextIndex==songNames.length);
    return (validNums?retVal:songNames(removeSpaces, true,0));
  }


  public Song[] getSongArray(){ return  songs.toArray(new Song[songs.size()]);}
  public Song[] getSongArraySortedByTrackNum()
  {
    String[] songNames = new String[songs.size()];
    int [] songNums = new int[songs.size()];
    int [] songCDNums = new int[4];
    Song sng = null;
    int maxCDNum = 1;
    int i=0;
    for(i=0; i< songs.size(); i++)
    {
      sng = songs.get(i);
      songNames[i]=sng.name(true); // name returns the songs filename with no path
      songNums[i]=sng.getNumber();
      songCDNums[i]=sng.getCdNumber();
      if(songCDNums[i]>maxCDNum) maxCDNum = songCDNums[i];
    }
    Song[] retVal = new Song[maxCDNum*songs.size()];
    int j=0;
    int nextIndex = 0;
    int nextSongNum = 0;
    boolean validNums = true;
    boolean done = false;
    int cdNum=1;

    for(int currCD=1; currCD<=maxCDNum; currCD++)
    {
      for(nextSongNum=1; nextSongNum< 150 && nextIndex<songNames.length; nextSongNum++)
      {
        done = false;
        for(j=0; j< songNames.length && !done; j++)
          if(currCD==songCDNums[j] && songNums[j]==nextSongNum)
          {
            retVal[nextIndex++]=songs.get(j);
            done = true;
          }
      }
    }

    validNums = (nextIndex==songNames.length);

    return (validNums?retVal:getSongArray());
  }


  public Song[] getSongArraySortedByTrackNum2()
  {
    Song[] retVal = getSongArray();
    ca.bc.webarts.widgets.Quick.sort(retVal);
    //java.util.Arrays.sort(retVal);
    return retVal;
  }

  public Vector<Song> getSongs(){ return  songs;}
  public int getNumberOfSongs() {return songs.size();  }
  /** A single string listing one songname per line ( with spaces in names) . **/
  public String listSongs(){return listSongs(false);}
  public String listSongs(boolean removeSpaces)
  {
    StringBuilder retVal = new StringBuilder();
    for(String currSongTitle : songTitles(removeSpaces)) retVal.append(currSongTitle+SYSTEM_LINE_SEPERATOR);
    return retVal.toString();
  }


  /** AlbumName part of the filename <b>with</b> spaces in name . **/
  public String name(){return name(false);}
  /** AlbumName part of the filename with or without spaces in name . **/
  public String name(boolean removeSpaces)
  {
    String retVal = albumDirFile_.getAbsolutePath().substring(albumDirFile_.getAbsolutePath().lastIndexOf("/")+1);
    if (!removeSpaces) retVal = Util.capsToSpacesInString(retVal);
    return retVal.trim();
  }


  /** The actual fully expanded, cleaned of underscores and explicits / usable Album Title. **/
  public String albumTitle()
  {
    return albumTitle(false);
  }


  /** The actual cleaned of underscores and explicits / usable Album Title. **/
  public String albumTitle(boolean removeSpaces)
  {
    String title = name();
    title = Song.removeExplicit(title);
    title = Util.tokenReplace(title," <","<");
    title = Util.tokenReplace(title,"  "," ");
    title = Util.tokenReplace(title,"+"," +");
    title = Util.tokenReplace(title,"++","+");
    title = Util.tokenReplace(title,"x &y","x&y");
    title = Util.tokenReplace(title,"x & y","x&y");
    title = Util.tokenReplace(title,"X &Y","X&Y");
    title = Util.tokenReplace(title,"X & Y","X&Y");
    title = Util.tokenReplace(title,"_"," ");
    title = Util.tokenReplace(title,"%23","#");
    title = Util.tokenReplace(title,"%2f","/");
    title = Util.tokenReplace(title,"%2F","/");
    title = Util.tokenReplace(title,"A & M","A&M");
    title = Util.tokenReplace(title,"A & M","A&M");
    title = Util.tokenReplace(title,"A& M","A&M");
    title = Util.tokenReplace(title,"A &M","A&M");
    if (removeSpaces) title=Util.spacesToCapsInString(title);
    return title.trim();
  }


  /** loops thropugh all Album Songs and test and marks them as Last.fm loved if they are. **/
  public void markLovedSongs(Vector<String> lovedTrackNames)
  {
    //System.out.println(" >> Album.lastFmLovedTrackNames_=\n"+ lovedTrackNames+"\n");
    String currSongTitle = "";
    boolean currLoved = false;
    try
    {
      for(Song currSong : getSongs() )
      {
        currLoved = false;
        currSongTitle = currSong.songTitle();
        for(int i=0; i<lovedTrackNames.size(); i++)
          if(lovedTrackNames.get(i).equalsIgnoreCase(currSongTitle)){currLoved=true;currSong.setLastFmLoved();i=lovedTrackNames.size();}
        //if(albumTitle().equalsIgnoreCase("Greatest Hits - The Real Thing"))
        //  System.out.println(" >> Album.markLovedSongs: "+currSongTitle +" : "+(currLoved?"YES":"no"));
      }
    }
    catch ( Exception ex)
    {
      System.out.println(" *! Album Fudge markLovedSongs ("+name()+", "+currSongTitle+") : "+ex.getMessage());
      //ex.printStackTrace();
    }

  }


  /** Returns a wrapper for this Album's LastFM Album or null if not valid name. It also loads the releaseDate.**/
  public de.umass.lastfm.Album retrieveLastFmAlbum(){ return retrieveLastFmAlbum(false);}
  public de.umass.lastfm.Album retrieveLastFmAlbum(boolean reRetrieve)
  {
    if(lastFmAlbum_==null || reRetrieve)
    {
      de.umass.lastfm.Album lastFmAlbum_  = retrieveLastFmAlbum(Util.capsToSpacesInString(albumArtistName_).trim(), albumTitle());
      if(lastFmAlbum_!=null)
      {
        //setReleaseDate(lastFmAlbum_.getReleaseDate());  // Last.fm release date is always non-existant
        setMbid(lastFmAlbum_.getMbid());
      }
      //System.out.println("\n          >> ReleaseDate: " + getReleaseDate());
    }
    return lastFmAlbum_;
  }


  /** Returns a wrapper for the LastFM Album or null if not valid name. Use the Album.getUrl() if needed. **/
  public static de.umass.lastfm.Album retrieveLastFmAlbum(String art, String albumName)
  {
      // this call is not reliable
      //System.out.println("\n  >> retrieveLastFmAlbum: " + art +" / " + albumName);
      // http://ws.audioscrobbler.com/2.0/?method=album.getInfo&artist=Pearl+Jam&api_key=93df6c849563eef04d7d48db5950d0c7&album=Ten
      de.umass.lastfm.Album lastFmAlbum_ = de.umass.lastfm.Album.getInfo(art, albumName , TunesHelper.LASTFM_API_KEY);
    return lastFmAlbum_;
  }

  public int retrieveMusicBrainzReleaseYear() { return retrieveMusicBrainzReleaseYear(artistName_, albumTitle());}
  public int retrieveMusicBrainzReleaseYear(String artistName, String albumTitle)
  {
    //System.out.println("\n --> retrieveMusicBrainzReleaseYear: " + artistName +" : " + albumTitle);
    int retVal = 1900;

    String searchResults = mbRR_.searchRelease(artistName, albumTitle ).toString();
    nu.xom.Document releaseDoc = mbRR_.parseXMLResponse(searchResults);
    retVal = mbRR_.parseSearchResultsForReleaseYear(releaseDoc);
    System.out.println("  -->  " + retVal);

    return retVal;
  }


  /** Returns a wrapper for the LastFM Album or null if not valid name. Use the Album.getUrl() if needed. **/
  public static String retrieveLastFmAlbumUrl(String art, String albumName)
  {
    String retVal = "";
    if(false)
    {
      de.umass.lastfm.Album al = retrieveLastFmAlbum( art,  albumName);
      if(al!=null)
      {
        //System.out.println("\n    >>>> retrieveLastFmAlbumUrl: " + art +"_" +albumName);
        retVal = al.getUrl() ;
      }
    }
    else
    {
      //if(albumName.contains("+") || albumName.contains("<") ) System.out.println("\n    >>>>>> albumName: " + albumName.trim());
      retVal = "https://www.last.fm/music/"+Util.capsToSpacesInString(art).trim().replace("+","%252B").replace("_"," ").replace(" ","+").replace("++","+")+
               "/"+albumName.trim().replace("+"," %252B").replace("_"," ").replace(" ","+").replace("++","+").replace("/","%2f").replace("'","%27").replace("#","%23") ;
    }
    return retVal;
  }


  /**
    * Set Method for class field 'releaseDate_'.
    *
    * @param releaseDate is the value to set this class field to.
    *
    **/
  public  void setReleaseDate(java.util.Date releaseDate)
  {
    this.releaseDate_ = releaseDate;
  }  // setReleaseDate Method


  /**
    * Get Method for class field 'releaseDate_'.
    *
    * @return java.util.Date - The value the class field 'releaseDate_'.
    *
    **/
  public java.util.Date getReleaseDate()
  {
    return releaseDate_;
  }  // getReleaseDate Method


  /**
    * Get releaseDate as a String.
    *
    * @return String - The value the class field 'releaseDate_' as a String.
    *
    **/
  public String getReleaseDateStr()
  {
    return releaseDate_.toString();
  }  // getReleaseDate Method


  /**
    * Get releaseDate YEAR as an int.
    *
    * @return int - The value the class field 'releaseDate_' YEAR as an int.
    *
    **/
  public int getReleaseYear()
  {
    return releaseYear_;
    /*
    int retVal = releaseYear_;

    if(mb_!=null) retVal = mb_.getYear();
    else if(getReleaseDate()!=null)
    {
      java.util.Calendar cal = java.util.Calendar.getInstance();
      cal.setTime(getReleaseDate());
      retVal=cal.get(java.util.Calendar.YEAR);
    }
    return retVal;
    */
  }  // getReleaseYear Method


  public int compareTo(Album a2)
  {
    return compareToReleaseDate( a2);
  }


  /** Implements the Comparator and sorts by Date of album. **/
  public int compareToReleaseDate(Album a2)
  {
    int retVal = 0;
    java.util.Date a1R = this.getReleaseDate();
    java.util.Date a2R = a2.getReleaseDate();
    if(a1R!=null && a2R!=null)
      if(a1R.after(a2R)) retVal = 1;
      else if(a2R.after(a1R)) retVal = -1;
    return retVal;
  }


  /** Compares the Album Titles. **/
  public int compareToAlbumTitle(Album o)
  {
    return this.albumTitle().compareTo(o.albumTitle());
  }


  /** The Song Title. **/
  public String toString()
  {
    return this.albumTitle();
  }


  /** lists all songs in a JSON string. **/
  public String toJsonString(int songIndex)
  {
    StringBuilder retVal = new StringBuilder("");
    String artDirName = Util.tokenReplace(getArtistDir(),"%2f","%252f");
    artDirName = Util.tokenReplace(artDirName,"%2F","%252F");
    artDirName = Util.tokenReplace(artDirName,"'","%27");

    int songCount = 0; int tot = songs.size();boolean matched = false;

    // setup a SORTED list
    String [] sNames =  songNames(true,true,("VariousArtists".equalsIgnoreCase(artDirName)?1:0)); // songNames(true,true,1); the last sortType=1 sorts by trackNum,  sortType=0 sorts by name
    for (String currSongName : sNames)
    {
      matched = false;
      // Cycle through and pick them in SORTED order
      for (Song currSong : songs)
      {
        if ( !matched && currSong.name(true).equals(currSongName) )
        {
          retVal.append(currSong.toJsonString(songIndex+songCount));
          if(songCount++<tot-1)
            retVal.append(",");  // //"+ songCount+" / "+tot);
          //else
          //  retVal.append("// "+ songCount+" / "+tot +"  End Of Album='"+albumTitle()+"'");
          retVal.append(SYSTEM_LINE_SEPERATOR);
          matched = true;
        }
      }
      if(!matched)
        retVal.append("// Strange: No Match for currSongName='"+currSongName+"'\n");
    }
    return retVal.toString();
  }


  public String toString(boolean html)
  {
    String lastFmAlbumUrl = retrieveLastFmAlbumUrl(albumArtistName_, albumTitle()).replace("#","%23");
    lastFmAlbumUrl = Util.tokenReplace(lastFmAlbumUrl,"#","%23");
    String retVal = "";
    if(html)retVal+= "  <ol>";
    if(html)retVal+= SYSTEM_LINE_SEPERATOR;
    String albDirName = Util.tokenReplace(name(true),"%2f","%252f");
    albDirName = Util.tokenReplace(albDirName,"%2F","%252F");
    albDirName = Util.tokenReplace(albDirName,"'","%27");
    albDirName = Util.tokenReplace(albDirName,"#","%23");
    String artDirName = Util.tokenReplace(getArtistDir(),"%2f","%252f");
    artDirName = Util.tokenReplace(artDirName,"%2F","%252F");
    artDirName = Util.tokenReplace(artDirName,"'","%27");
    artDirName = Util.tokenReplace(artDirName,":","%3a");
    if(albumTitle(true).contains("Wembley"))System.out.println(" DEBUG: Album.toString  artDirName="+artDirName);

    String songsHtml = "";
    int firstSongLibraryIndex = -1;

    String [] sNames =  songNames(true,true,("VariousArtists".equalsIgnoreCase(artDirName)?1:0)); // songNames(true,true,1); the last sortType=1 sorts by trackNum,  sortType=0 sorts by name
    // work with the sorted list
    for (String currSongName : sNames)
      for (Song currSong : songs)
        if (currSong.name(true).equals(currSongName) )
        {
          songsHtml+= currSong.toString(html);
          if(firstSongLibraryIndex==-1)
            firstSongLibraryIndex = currSong.getLibraryIndex();
        }

    // This makes a call to a function in jplayer.js
    String playAlbumOnPiURL = "javascript:playPirateArtistAlbum('"+artDirName+"/"+albDirName+"', 'album', "+firstSongLibraryIndex+")";

    if(html && !"".equals(lastFmAlbumUrl))retVal+= " <a href=\""+lastFmAlbumUrl+"\"  target=\"_blank\"> ";
    if(html)retVal+= "  <img id=\""+albumArtistName_.trim()+" " +albumTitle(true)+"\" alt=\""+albumTitle()+" Album Cover Thumbnail\" src=\""+
                     TunesHelper.getTunesSubPath()+"/"+artDirName+"/"+albDirName+
                     "/cover.jpg"+"\" class=\"\" style=\"margin:0px;\" height=\"32px\" width=\"32px\"/>";
    if(html && !"".equals(lastFmAlbumUrl))retVal+= " </a> ";

    if(html)retVal+= " <b><u> ";
    if(html)retVal+= " <a href=\""+playAlbumOnPiURL+"\"  > ";
    retVal+= albumTitle();
    if(html )retVal+= " </a> ";
    //if(name().contains("+")) System.out.println("\n    >>>>>> Album.albumName: " + name() +" - "+albumTitle());
    if(html)retVal+= "</u></b>";
    if(html)retVal+= " <span style=\"font-size: 0.7em;\">";
    if(html)retVal+= " ("+ getReleaseYear() + ")";
    if(html)retVal+= " [<a  href=\""+downloadLink_+"\">zip</a>]</span>";
    retVal+= SYSTEM_LINE_SEPERATOR;
    if(html)retVal+= songsHtml;
    if(html)retVal+= "  </ol>";
    retVal+= SYSTEM_LINE_SEPERATOR;

    return retVal;
  }
}