package com.melloware.jukes.file;
   
   import java.io.File;
   import java.text.MessageFormat;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.Date;
   import java.util.Iterator;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.lang.StringEscapeUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.jgoodies.uif.util.ResourceUtils;
  import com.jgoodies.validation.Severity;
  import com.melloware.jukes.db.HibernateDao;
  import com.melloware.jukes.db.HibernateUtil;
  import com.melloware.jukes.db.orm.Artist;
  import com.melloware.jukes.db.orm.Disc;
  import com.melloware.jukes.db.orm.Track;
  import com.melloware.jukes.exception.InfrastructureException;
  import com.melloware.jukes.exception.MusicTagException;
  import com.melloware.jukes.file.filter.FilterFactory;
  import com.melloware.jukes.file.tag.MusicTag;
  import com.melloware.jukes.file.tag.TagFactory;
  import com.melloware.jukes.util.JukesValidationMessage;
  import com.melloware.jukes.util.TimeSpan;
  
  /**
   * This class is used for working with music file directories. Functions said as
   * loading a directory into the database, updating ID3 tags, etc.
   * <p>
   * Copyright (c) 2006 Melloware, Inc. <http://www.melloware.com>
   * @author Emil A. Lefkof III <info@melloware.com>
   * @version 4.0
   * @see MusicTag
   */
  public final class MusicDirectory {
  
     private static final Log LOG = LogFactory.getLog(MusicDirectory.class);
  
     /**
      * Private constructor for no instantiation.
      */
     private MusicDirectory() {
        super();
     }
  
     /**
      * Creates a new disc in the catalog and optionally updates its ID3 tags.
      * <p>
      * @param aTags the array of MusicTag objects
      * @param aCoverImage the cover image
      * @param aDirectory the directory where these files are located
      * @param aUpdateTags true to update tags, false to not modify them
      * @return a validation message containing the result
      */
     @SuppressWarnings("unused")
     public static JukesValidationMessage createNewDisc(final Object[] aTags, final File aCoverImage,
              final File aDirectory, final JukesValidationMessage aMessage, final boolean aUpdateTags) {
        JukesValidationMessage result = null;
        if (aMessage == null) {
           result = new JukesValidationMessage("Disc created successfully", Severity.OK);
        } else {
           result = aMessage;
        }
        String message = null;
        try {
           HibernateUtil.beginTransaction();
           Artist artist = null;
           Disc disc = null;
           long totalDuration = 0;
           final int padding = ((aTags.length >= 100) ? 3 : 2);
           MUSIC_LOOP: for (int i = 0; i < aTags.length; i++) {
              final MusicTag musicFile = (MusicTag) aTags[i];
  
              // find or create the artist
              if (artist == null) {
                 final String artistName = musicFile.getArtist();
                 final String resource = ResourceUtils.getString("hql.artist.find");
                 final String hql = MessageFormat.format(resource,
                          new Object[] { StringEscapeUtils.escapeSql(artistName) });
                 artist = (Artist) HibernateDao.findUniqueByQuery(hql);
                 if (artist == null) {
                    artist = new Artist();
                    artist.setName(artistName);
                 }
                 musicFile.setArtist(artistName);
              } else {
                 musicFile.setArtist(artist.getName());
              }
  
              // find or create the disc
              if (disc == null) {
                 final String discName = musicFile.getDisc();
                 final String resource = ResourceUtils.getString("hql.disc.find");
                 final String hql = MessageFormat.format(resource, new Object[] {
                         StringEscapeUtils.escapeSql(artist.getName()), StringEscapeUtils.escapeSql(discName) });
                disc = (Disc) HibernateDao.findUniqueByQuery(hql);
                if (disc == null) {
                   disc = new Disc();
                   disc.setArtist(artist);
                   disc.setName(discName);
                   artist.addDisc(disc);
                }
                musicFile.setDisc(discName);
                disc.setGenre(musicFile.getGenre());
                disc.setYear(musicFile.getYear());
                disc.setBitrate(musicFile.getBitRate());
                if (aCoverImage != null) {
                   disc.setCoverUrl(aCoverImage.getAbsolutePath());
                   disc.setCoverSize(aCoverImage.length());
                }
                disc.setCreatedDate(new Date(aDirectory.lastModified()));
                disc.setLocation(aDirectory.getAbsolutePath());
                // clear out the old tracks
                HibernateDao.deleteAll(disc.getTracks());
             } else {
                musicFile.setDisc(disc.getName());
             }
 
             // now create the track
             final Track track = new Track();
             disc.addTrack(track);
             track.setBitrate(musicFile.getBitRate());
             track.setDuration(musicFile.getTrackLength());
             track.setDurationTime(musicFile.getTrackLengthAsString());
             track.setName(musicFile.getTitle());
             track.setComment(musicFile.getComment());
             track.setTrackUrl(musicFile.getAbsolutePath());
             track.setTrackSize(musicFile.getFile().length());
             musicFile.setTrack(Integer.toString(i + 1), padding);
             track.setTrackNumber(musicFile.getTrack());
             track.setCreatedDate(new Date(musicFile.getFile().lastModified()));
             totalDuration = totalDuration + musicFile.getTrackLength();
 
             // save the tag back out if the flag is set
             if (aUpdateTags) {
                musicFile.save();
             }
          } // MUSIC_LOOP_LOOP
 
          // update the discs total duration and time
          disc.setDuration(totalDuration);
          final TimeSpan timespan = new TimeSpan(totalDuration * 1000);
          disc.setDurationTime(timespan.getMusicDuration());
 
          // commit changes
          HibernateDao.saveOrUpdate(artist);
          HibernateUtil.commitTransaction();
       } catch (MusicTagException ex) {
          message = "Error writing music tag: " + ex.getMessage();
          result.setMessage(message);
          result.setSeverity(Severity.ERROR);
          result.setToolTip(message);
          LOG.error(message, ex);
          HibernateUtil.rollbackTransaction();
       } catch (InfrastructureException ex) {
          message = "Error persisting to the database: " + ex.getMessage();
          result.setMessage(message);
          result.setSeverity(Severity.ERROR);
          result.setToolTip(message);
          LOG.error(message, ex);
          HibernateUtil.rollbackTransaction();
       } catch (Throwable ex) {
          message = "Unexpected Error: " + ex.getMessage();
          result.setMessage(message);
          result.setSeverity(Severity.ERROR);
          result.setToolTip(message);
          LOG.error(message, ex);
          HibernateUtil.rollbackTransaction();
       }
 
       return result;
    }
 
    /**
     * Loops through an array of files and determines the largest one in bytes.
     * <p>
     * @param aDirectory the directory to look for the largest file in.
     * @return the file found to be the largest
     */
    public static File findLargestImageFile(final File aDirectory) {
       return findLargestImageFile(aDirectory, null);
    }
 
    /**
     * For a directory gets all of its music type files into a collection. If
     * none are found return null, and set the validation message.
     * <p>
     * @param aDirectory the directory to scan
     * @return a collection of files or NULL if not found
     */
    public static Collection findMusicFiles(final File aDirectory) {
       if (LOG.isDebugEnabled()) {
          LOG.debug("Finding music files in directory:" + aDirectory);
       }
       return findMusicFiles(aDirectory, null);
    }
 
    /**
     * Silently loads all tracks and one image file from the aDirectory. It must
     * be a directory and if any exception is thrown all we do is return false to
     * silently report the error.
     * <p>
     * @param aDirectory the directory to add
     * @param aUpdateTags boolean whether to overwrite new tags or not
     * @return true if successful, false if any error
     */
    @SuppressWarnings( { "unused", "unchecked" })
    public static JukesValidationMessage loadDiscFromDirectory(final File aDirectory, final boolean aUpdateTags) {
       if (aDirectory == null) {
          throw new IllegalArgumentException("A directory must be selected");
       }
 
       JukesValidationMessage result = new JukesValidationMessage(aDirectory.getAbsolutePath(), Severity.OK);
       String message = null;
       final File directory = aDirectory;
 
       // make sure it is a directory
       if ((!directory.isDirectory()) || (!directory.exists())) {
          throw new IllegalArgumentException("A directory must be selected");
       }
 
       try {
          if (LOG.isDebugEnabled()) {
             LOG.debug("Loading music directory: " + directory);
          }
 
          // first get all the music files in this dir
          final Collection musicFiles = findMusicFiles(directory, result);
          if ((musicFiles == null) || (musicFiles.isEmpty())) {
             return result;
          }
 
          // now get a list of all the image files for disc cover
          final File imageFile = findLargestImageFile(aDirectory, result);
 
          if (LOG.isDebugEnabled()) {
             LOG.debug("Files found = " + musicFiles.size());
             LOG.debug("Image selected = " + imageFile);
          }
 
          final ArrayList tagList = new ArrayList();
          MUSIC_LOOP: for (final Iterator iter = musicFiles.iterator(); iter.hasNext();) {
             final File musicFile = (File) iter.next();
             if (LOG.isDebugEnabled()) {
                LOG.debug("Music File: " + musicFile);
             }
             // load the tag
             final MusicTag tag = TagFactory.getTag(musicFile);
             tagList.add(tag);
          } // MUSIC_LOOP
          
          // sort the tags by track number
          Collections.sort(tagList);
 
          result = createNewDisc(tagList.toArray(), imageFile, aDirectory, result, aUpdateTags);
 
       } catch (MusicTagException ex) {
          message = "Error opening music file: " + ex.getMessage();
          result.setSeverity(Severity.ERROR);
          result.setToolTip(message);
          LOG.error(message, ex);
       } catch (Throwable ex) {
          message = "Unexpected Error: " + ex.getMessage();
          result.setSeverity(Severity.ERROR);
          result.setToolTip(message);
          LOG.error(message, ex);
       }
 
       return result;
    }
 
    /**
     * Checks for the disc at the location on the hard drive. If that location no
     * longer exists on the hard drive then this disc is removed from the
     * database. This is useful for when using the Jukes with portable storage
     * devices like Archos Jukebox. Thanks to Bill Farkas for suggesting this
     * feature.
     * @param aDisc the disc to check the hard drive for
     * @return true if the disc was OK, false if the disc was removed
     */
    public static boolean removeDiscIfNoLongerExists(final Disc aDisc) {
       boolean result = false;
 
       if (aDisc == null) {
          throw new IllegalArgumentException("Disc may not be null");
       }
 
       if (LOG.isDebugEnabled()) {
          LOG.debug("Checking disc for validity: " + aDisc.getName());
       }
 
       // get the file location for this disc
       final File discDirectory = new File(aDisc.getLocation());
 
       // return true if the directory still exists
       result = discDirectory.exists();
 
       // remove the directory if it no longer exists
       try {
          if (!result) {
             // try to delete from database
             HibernateUtil.beginTransaction();
             final Artist artist = aDisc.getArtist();
             artist.getDiscs().remove(aDisc);
             HibernateDao.delete(aDisc);
             HibernateUtil.commitTransaction();
          }
       } catch (InfrastructureException ex) {
          LOG.error("Error deleting disc from database.", ex);
          HibernateUtil.rollbackTransaction();
          result = false;
       }
 
       return result;
    }
 
    /**
     * Loops through an array of files and determines the largest one in bytes.
     * <p>
     * @param aDirectory the directory to look for the largest file in.
     * @param aMessage a JukesValidationMessage to contain any errors, may be
     *           null
     * @return the file found to be the largest
     */
    private static File findLargestImageFile(final File aDirectory, final JukesValidationMessage aMessage) {
       if (LOG.isDebugEnabled()) {
          LOG.debug("Finding largest image in directory: " + aDirectory);
       }
 
       File result = null;
       final Collection imageFiles = FileUtils.listFiles(aDirectory, FilterFactory.IMAGE_FILTER, null);
 
       // get the largest of the images if there are more than one
       if ((imageFiles != null) && (!imageFiles.isEmpty())) {
          LOG.debug("Images found in directory");
          final Object[] files = (Object[]) imageFiles.toArray();
 
          // if only one image then just return that image
          if (imageFiles.size() == 1) {
             result = (File) files[0];
          } else {
             if (aMessage != null) {
                LOG.info("More than one image found.");
                aMessage.setSeverity(Severity.WARNING);
                aMessage.setToolTip("Directory contained more than one image so largest was selected. ");
             }
 
             // need to pick the largest file for the biggest resolution cover
             long filesize = 0;
             for (int i = 0; i < files.length; i++) {
                final File file = (File) files[i];
                final long size = file.length();
                if (size > filesize) {
                   filesize = size;
                   result = file;
                }
             }
          }
       }
       return result;
    }
 
    /**
     * For a directory gets all of its music type files into a collection. If
     * none are found return null, and set the validation message.
     * <p>
     * @param aDirectory the directory to scan
     * @param aMessage the validation message to fill
     * @return a collection of files or NULL if not found
     */
    private static Collection findMusicFiles(final File aDirectory, final JukesValidationMessage aMessage) {
       // first get all the music files in this dir
       final Collection results = FileUtils.listFiles(aDirectory, FilterFactory.MUSIC_FILTER, null);
 
       // if collection is null just return true
       if (((results == null) || (results.isEmpty())) && (aMessage != null)) {
          final String message = "Directory contained no music files. " + aDirectory;
          LOG.warn(message);
          aMessage.setSeverity(Severity.WARNING);
          aMessage.setToolTip(message);
       }
 
       return results;
    }
 }