/*
$Source: f:/cvsroot2/open/projects/WebARTS/ca/bc/webarts/widgets/DirReadBean.java,v $
$Name:  $

$Revision: 567 $
$Date: 2012-11-03 20:36:02 -0700 (Sat, 03 Nov 2012) $
$Locker:  $
*/

/* DirReadBean -- A Widget Class to do some cool formating of Directory info.
 *
 * Copyright (C) 2001 WebARTS Design, North Vancouver Canada
 * http://www..webarts.bc.ca
 *
 * 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;

import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.FileWriter;
import java.util.Hashtable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.TreeSet;
import java.util.Vector;
import java.lang.System;


/**
 * A Widget that does some directory reading, filtering and presents some
 * useful HTML displayed information about the files.
 **/
public class DirReadBean {


/** holds a String message of the last error that occured **/
private static String lastErrorMsg="";


static final private String defaultDirString = File.separator ;


/** The directory being worked on as a <code>String</code>. **/
private  static String dirString = defaultDirString + "testDir" ;


/** the directory being worked on as a <code>File</code>. **/
private        File            dirFile = null;


/**
 * This String holds the results of any parsing and filtering that is
 * performed. It will hold an html presentation of the directory.
 **/
private        String          outText_;


/** A list of filenames in the current dir. **/
private         static String []         fileName = null;

/** A list of filenames path from the current dir. **/
private         static String []         fileNamePath = null;


/** A index refernce to the current file we are dealing with. **/
private         static short           fileIndex =0;


/** the number of files in the current <code>dirFile</code> directory. **/
private         static short           numFiles = 0;

private  HashMap magMap = new HashMap();

/** Holds the Long size info for each file in <code>fileName[]</code>.**/
private         Hashtable fileSizeHash = new Hashtable();

private static long totalFileSize= 0L;

private String winampFilename = "DirectoryWinAmpList.m3u";


/** Sets the String holding the directory this class is working on. **/
public static void setDirString(String s){dirString = s;}


/** Sets the String holding the current HTML output string. **/
protected void setOutText(String s){outText_ = s;}


/** Gets the String holding the current HTML output string. **/
public String getOutText(){return outText_;}


/**
 * Directly sets the dirFile we are working on.
 * <P>The preferred way of setting this is with the <code>initDirFile</code>
 * method.
 *
 * @param f the File to set dirFile to.
 * @see #initDirFile(String)
 **/
protected void setDirFile(File f){dirFile = f;}


/** Gets the dirFile we are working on. **/
public File getDirFile(){return dirFile;}


/**
 * Initisalizes the dirFile field with a new File represented by the passed in
 * String
 **/private boolean initDirFile(String s)
{
  boolean retVal = false;
  dirFile = new File(s);
  if(dirFile.isDirectory() && dirFile.canRead())
    retVal = true;
  return retVal;
}


public int getNumFiles(){return numFiles;}


/**
 * Reads the Dir and Inits all required class data.
 *
 * @param s is the dir to init.
 **/
public boolean initDir(String s)
{
  initFileIndex();
  return initDir(s, false);
}


/**
 * Reads the Dir and Inits all required class data.
 *
 * @param s is the dir to init.
 * @param recurse specifies if it should recurse for files.
 **/
public boolean initDir(String s, boolean recurse)
{
  initFileIndex();
  return initDir(s,"",recurse);
}


/**
 * Reads the Dir and Inits all required class data.
 *
 * @param s is the dir to init.
 * @param subPath is the dir path to prepend to the filenames.
* @param recurse specifies if it should recurse for files.
 **/
public boolean initDir(String s, String subPath, boolean recurse)
{
  boolean retVal = initDirFile(s);
  if (retVal)
  {
    initFileIndex();
    File tempFile;
    System.out.println("Initing a dir - dirString = "+dirString+".  s="+s+". ");
    numFiles = 0;
    initFileIndex();
    if (!dirString.equals(s))
    {
      setDirString(s);
    }
    String[] currentDirfiles = dirFile.list();

    // count how many files and init our array
    if (numFiles == 0)
      for (int i=0; i< currentDirfiles.length; i++)
      {
        tempFile = new File(dirString+File.separator+currentDirfiles[i]);
        if(!tempFile.isDirectory())
        {
          //System.out.println("Counting File "+
          //                   dirString+File.separator+currentDirfiles[i]);
          numFiles++;
        }
        else if (recurse)
          numFiles +=
            Util.countFilesInDir(dirString+File.separator+currentDirfiles[i],
                                 true);
      }
    //if (fileName == null)
    //{
      System.out.println("numFiles = "+numFiles);
      fileName  = new String[numFiles]; //dirFile.list();
      fileNamePath  = new String[numFiles];
    //}

    for (int i=0; i< currentDirfiles.length; i++)
    {
      if (i==0)
        System.out.println("Start Of Processing: "+currentDirfiles.length+
                           "/"+fileIndex+"/"+numFiles);
      tempFile = new File(dirString+File.separator+currentDirfiles[i]);
      if(!tempFile.isDirectory())
      {
        fileName[fileIndex] = currentDirfiles[i];
        fileNamePath[fileIndex] = subPath;

        fileSizeHash.put(fileName[fileIndex++] ,
                         new Long( (long) tempFile.length()));
        totalFileSize += (long) tempFile.length();
      }
      else if (recurse)
      {
        String recursedSubpath = currentDirfiles[i];
        if (subPath != null && subPath.length()>0)
          recursedSubpath = subPath+"/"+currentDirfiles[i];
        //System.out.println("Recurse on = "+tempFile.toString());
        initDir(tempFile.toString(), recursedSubpath,true);
        //System.out.println(fileIndex);
        initDirFile(s);
        setDirString(s);
        currentDirfiles = dirFile.list();
        //System.out.println(fileIndex);
      }
    }
    System.out.println("End   Of Processing: "+currentDirfiles.length+
                       "/"+fileIndex+"/"+numFiles);

    //initFileIndex();
  }
  return retVal;
}


public void initOutText(){outText_ = "<html><body>\n"; }
public static void initFileName(){fileName=null;}
public static void initFileIndex(){fileIndex=0;}
public void appendOutText(String s) {outText_ += s;}
public void finalizeOutText(){outText_ += "\n</body></html>";  }
public String getDirString(){return dirString;}
public static String getLastErrorMessage(){ return lastErrorMsg;}
public Long getTotalFileSize(){return new Long(totalFileSize);}

/**
 * Gets the file size for the file name passed in form the passed in
 *dirString directory.
 *
 * @param dirString the string representation of the directory.
 * @param s the string representation of the filename to lookup.
 * @return the Long representing the requested file size.
 **/
public Long getFileSize(String dirString, String s)
{
  initDir(dirString);
  return ((Long)fileSizeHash.get(s));
}


/**
 * Gets the file size for the file name passed in.<P> It looks up the values in
 * this classes Hash of the filenames... soi the readDir method or the
 * initDir methodMUST be called before this method to ensure that the hash is
 * initialized with the current directory info.
 * <P>See also the getFileSize(String, String) method that takes
 * the dir as well so you don't have to call readDir first
 *
 * @param s the string representation of the filename to lookup.
 * @return the Long representing the requested file size.
 **/
public Long getFileSize(String s)
{
  return ((Long)fileSizeHash.get(s));
}


/**
 * A helper method to abstract the work to find out if a file exists.
 *
 * @param s the string representing the file name to look for.
 *
 * @return true if the file exists, false if it doesn't.  duh.
 **/
public boolean doesFileExist(String s)
{
  boolean retVal = false;
  try
  {
    FileReader testFile = new FileReader(getDirString()+File.separator+s);
    retVal = true;
    lastErrorMsg = "doesFileExist: NoError: filename="+s;
  }
  catch (java.io.FileNotFoundException  nfEx)
  {
    retVal = false;
    lastErrorMsg = "doesFileExist: filename=" + s +
                   " File NOT Found Exception";
  }
  catch (SecurityException   secEx)
  {
    retVal = false;
    lastErrorMsg = "doesFileExist: SecurityException: filename=" + s;
  }
  return retVal;
}


/**
 * Looks up the next file in the indexed list of files being kept by this class.
 *
 * @return a string representin the name of the next file in the file list.
 **/
public String getNextFileName()
{
  String retVal = null;
  if (fileIndex<numFiles)
    retVal = fileName[fileIndex++] ;
  return retVal;
}


/**
 * Looks up the next file path in the indexed list of files being kept by this class.
 *
 * @return a string representin the name of the next file in the file list.
 **/
public String getNextFilePath()
{
  String retVal = null;
  if (fileIndex<numFiles)
    retVal = fileNamePath[fileIndex] ;
  return retVal;
}


/**
 * Looks up the next file in the indexed list of files and returns its size.
 *
 * @return a Long representing the filesaize of the next file in the file list.
 **/
public Long getNextFileSize()
{
  Long retVal = new Long(-1L);
  if (fileIndex<numFiles)
    retVal = getFileSize(fileName[fileIndex]) ;
  return retVal;
}


public String getFileContents(String s){
  String retVal = "";
  try{
        StringBuffer sBuf = new StringBuffer();
       int numChars=0;
        FileReader fileReader = new FileReader(getDirString()+File.separator+s);
        byte tempChar = (byte) fileReader.read();
        while (tempChar != -1) {
              sBuf.append( (char) tempChar);
              tempChar =(byte)  fileReader.read();
        }
      retVal = sBuf.toString();
   }
   catch (FileNotFoundException fnfEx){
              retVal = "File" +s + " NOT Found.";
   }
   catch (SecurityException secEx){
              retVal = "Unable To Read File " +s +": Security.";
   }
   catch (IOException ioEx){
              retVal = "Unable To Read File " +s +": IO Error.";
   }
    return retVal;
}


/**
 * Removes any space chars ' ' from a filename and Capitalizes the next char.
 * <P><B>NOTE:</B> The file is expected to be in
 * the current working directorydirectory
 *
 * @param dirString the directory to look in for the file name (no trailing /).
 * @param fName a string representing the file to perform the action.
 * @return the new filename representation
 **/
public String spacesToCapsInFileName(String dirString, String fName)
{
  setDirString(dirString);
  return spacesToCapsInFileName(fName);
}


/**
 * Removes any space chars ' ' from a filename and Capitalizes the next char.
 * <P><B>NOTE:</B> The file is expected to be in
 * the current working directorydirectory
 *
 * @param fName a string representing the file to perform the action
 * @return the new filename representation
 **/
public String spacesToCapsInFileName(String fName)
{
  String newName = "";
  File tempFile;
  if (fileName != null){
    tempFile = new File(dirString+File.separator+fName);
    if(!tempFile.isDirectory())
    {
      boolean space = false;
      for (int j=0; j< fName.length(); j++)
      {
        char newChar = fName.charAt(j);
        if (newChar == ' ')
        {
          // set the space flag so the next char can be cap'd
          space = true;
        }
        else
        {
          if (space) // was the last char a space???
          {
            newName += String.valueOf(Character.toUpperCase(newChar));
          }
          else
          {
            newName += String.valueOf(newChar);
          }
          space = false;
        }
      }
    }
  }
  return newName;
}


/**
 * Renames files to a more URL friendly format.
 * <P>It goes through each file in the current working directory and renames it
 * using the spacesToCapsInFileName method of renaming.
 *
 * @see #spacesToCapsInFileName(String)
 * @see #dirFile
 **/
public void autoFormatFileNames()
{
  System.out.println("Formatting dir="+dirFile.toString());
  if (dirFile != null &&
      dirFile.isDirectory() &&
      dirFile.canRead() &&
      fileName  != null )
  {
    File tempFile;
    boolean succeeded = false;
    for (int i=0;i< fileName.length;i++)
    {
      tempFile = new File(dirString+File.separator+fileName[i]);
      String newName = spacesToCapsInFileName(fileName[i]);
      try
      {
        if (newName !="" && fileName[i].length() != newName.length())
        {
          System.out.println(i+".1) "+tempFile.toString());
          System.out.print(i+".2) "+dirString+File.separator+newName);
          succeeded = tempFile.renameTo(
            new File(dirString+File.separator+newName));
          if (succeeded)
            System.out.print("  succeeded.");
          else
            System.out.println("");
          File tempFile2 = new File(dirString+File.separator+fileName[i]);
          if (tempFile2.exists() &&
              tempFile.exists() &&
              !newName.toUpperCase().equals(fileName[i].toUpperCase()))
          {
            tempFile2.delete();
          }
        }
      }
      catch (SecurityException ex)
      {
        System.err.println("SecurityException " + ex);
      }
      catch (NullPointerException ex)
      {
        System.err.println("NullPointerException " + ex);
      }
    } //loop
  }
}


/**
 * Formats the files in the directory specified by the passed in String.
 * <P>This method takes a string representing the directory to use as the basis
 * for all formatting and then performs the formatting as specified by the
 * autoFormatFileNames() method.<P><B><U>WARNING:</U></B> This method WRITES to
 * the directory.  It actually changes the names of the files.
 *
 * @param arg a string representation of thre directory to parse.
 * @see #autoFormatFileNames()
 **/
public void autoFormatFileNames(String arg)
{
  // parse the input parms to switch the dir we want
  if(arg!=null) dirString = arg;

  initOutText();
  initDirFile(dirString);
  if(dirFile.isDirectory())
  {
    if(dirFile.canRead())
    {
      fileName  = dirFile.list();
    }
  }
  autoFormatFileNames();
}

public  String[] getArtistsNames()
{
  TreeSet magSet = new TreeSet(magMap.keySet());
  String [] retVal = new String[magMap.size()];
  int ii = 0;
  for (Iterator i=magSet.iterator(); i.hasNext() ;)
  {
    retVal[ii++] = ((String) i.next()).trim();
  }
  return retVal;
}

public String getWinampFilename() { return winampFilename;}
public void setWinampFilename(String s) { winampFilename = s;}



/**
 * Parse the current directory for files with the spec'd extension and create a
 * sorted and titled list of Authored entries (mp3 files, pdf magazines etc).
 * <P>The filenames must be in the format "Author_Title.extension" for this
 * method to create a decent list. It groups all files withthe same author into
 * a titled group.
 *
 * @param fileExtension the file extension to use as the filter for this list
 *                      (without the leading period...
 *                       example: for tbg_doc.pdf pass in pdf)
 * @param filesToIgnore the filenames (without the extension) to not process
 * @return a string holding the html unordered list
 **/
public String getTitledAuthorList(String fileExtension,
                                  String pathPrefix,
                                  Vector filesToIgnore)
{
  String retVal = "<!-- - - - - - - - - - - - - - - - - - - - - - - - - -->\n";
  retVal       += "<!-- Java Servlet Created List - - - - - - - - - - - -->\n";
  retVal       += "<!-- - - - - - - - - - - - - - - - - - - - - - - - - -->\n";
  String name1, name, artist, title;
  String tempArtist="",expandedTitle,expandedArtist="";
  int startPosition, endPosition;
  Long fileSize, zeroL = new Long(0L);
  Vector currentMagTitles = null;
  String [] magTitleInfo = new String[4];

  initFileIndex();

  fileSize = zeroL;
  fileSize = getNextFileSize();
  String nextPath = getNextFilePath();
  name = getNextFileName();

  while( name != null )
  {
    if( name.endsWith("."+fileExtension) &&
        (filesToIgnore == null ||
         !filesToIgnore.contains(
           name.substring(0,name.lastIndexOf("."+fileExtension)))))
    {
      expandedTitle="";
      startPosition = name.indexOf("_");
      if (startPosition < 0 )
      {
        startPosition = 0;
        artist = "No Title";
      }
      else
        artist = name.substring(0,startPosition).trim();

      endPosition = name.lastIndexOf("."+fileExtension);
      title = name.substring(startPosition+1,endPosition);
      int len = title.length();
      boolean capital = true;
      boolean letter = true;
      boolean digit = false;
      boolean lastDigit = false;
      char c;
      for (int i=0;i<len;i++)
      {
         c = title.charAt(i);
         letter = Character.isLetter(c);
         capital= letter & Character.isUpperCase(c);
         digit =  Character.isDigit(c);

         if (capital || (digit && !lastDigit) || (!digit && !letter))
           expandedTitle += " ";

         expandedTitle += c;
         lastDigit = digit;
      }
      if (!(tempArtist.toUpperCase().equals(artist.toUpperCase())) )
      {
          expandedArtist="";
          tempArtist = artist;
          capital = true;
          letter = true;
          digit = false;
          lastDigit = false;
          for (int i=0;i<startPosition;i++)
          {
            c = tempArtist.charAt(i);
            letter = Character.isLetter(c);
            capital= letter & Character.isUpperCase(c);
            digit =  Character.isDigit(c);

            if (capital || (digit && !lastDigit) || (!digit && !letter))
              expandedArtist += " ";

            expandedArtist += c;
            lastDigit = digit;
          }
      }
      if (magMap.containsKey(expandedArtist.trim()))
      {
          currentMagTitles = (Vector) magMap.get(expandedArtist.trim());
      }
      else
      {
          currentMagTitles = new Vector();
      }
      magTitleInfo[0] = name;
      magTitleInfo[1] = expandedTitle;
      magTitleInfo[2] = String.valueOf(fileSize);
      magTitleInfo[3] = nextPath;
      currentMagTitles.add(magTitleInfo.clone());
      magMap.put(expandedArtist.trim(),currentMagTitles);
    }

    fileSize = getNextFileSize();
    nextPath = getNextFilePath();
    name = getNextFileName();
  }

  retVal +="<ul>\n";
  // get a set of the keys (expanded artists)
  // sorted by TreeSet
  TreeSet magSet = new TreeSet(magMap.keySet());
  for (Iterator i=magSet.iterator(); i.hasNext() ;)
  {
    expandedArtist = ((String) i.next()).trim();
    retVal +="<br /><br /><a name=\"" + expandedArtist + "\">";
    retVal +="<b><u>" + expandedArtist + "</u></b></a>";

    // now get the titles for the mag & sort them
    currentMagTitles = (Vector)magMap.get(expandedArtist);
    HashMap sortedTitleMap = new HashMap();
    for (int j=0; j<currentMagTitles.size(); j++)
    {
        String [] currTitles= (String[]) currentMagTitles.get(j);
        expandedTitle = currTitles[1];
        sortedTitleMap.put(expandedTitle, currTitles);
    }
    TreeSet tileSet = new TreeSet(sortedTitleMap.keySet());
    String fileSizeStr = "";
    String filePathStr = pathPrefix;
    for (Iterator j=tileSet.iterator(); j.hasNext() ;)
    {
        String key = (String) j.next();
        String [] currTitles= (String[]) sortedTitleMap.get(key);
        name = currTitles[0];
        expandedTitle = currTitles[1];
        fileSizeStr = currTitles[2];
        if (currTitles[3] == null || currTitles[3].equals(""))
          filePathStr =pathPrefix;
        else
          filePathStr = currTitles[3];
        if (filePathStr == null)
          filePathStr = "";

        if (filePathStr != null &&
            filePathStr.length()>0 &&
            !filePathStr.endsWith("/"))
          filePathStr += "/";
        retVal +="<li><a href="+ filePathStr+name + ">" + expandedTitle +"</a>" +
                 "&nbsp;<font size=-1>(<i>" + fileSizeStr +
                 "</i></font> bytes)\n";
    }
  }
  retVal +="</ul>\n";

  return retVal;
}


/**
 * Parse the current directory for files with the spec'd extension and create a
 * sorted and titled list of Authored entries (mp3 files, pdf magazines etc).
 * <P>The filenames must be in the format "Author_Title.extension" for this
 * method to create a decent list. It groups all files withthe same author into
 * a titled group.
 *
 * @param fileExtension the file extension to use as the filter for this list
 *                      (without the leading period...
 *                       example: for tbg_doc.pdf pass in pdf)
 * @return a string holding the html unordered list
 **/
public String getTitledAuthorList(String fileExtension)
{
  return getTitledAuthorList(fileExtension, "", null);
}


/**
 * Parse the current directory for files with the spec'd extension and create a
 * sorted and titled list of Authored entries (mp3 files, pdf magazines etc).
 * <P>The filenames must be in the format "Author_Title.extension" for this
 * method to create a decent list. It groups all files withthe same author into
 * a titled group.
 *
 * @param fileExtension the file extension to use as the filter for this list
 *                      (without the leading period...
 *                       example: for tbg_doc.pdf pass in pdf)
 * @param pathPrefix is the path to prefix each href with
 * @return a string holding the html unordered list
 **/
public String getTitledAuthorList(String fileExtension, String pathPrefix)
{
  return getTitledAuthorList(fileExtension, pathPrefix, null);
}


/**
 * Reads the passed in directory and produces HTML representing the directory.
 * <P>It initializes all the current directory variables for this class so other
 * helper methods that work on a current directory have valid variables. It
 * prepares the HTML represerntation of the directory and returns it and also
 * places it in the outText_ variable.
 *
 * @param arg the String representation of the directory to read.
 * @return the HTML representation of the directory.
 **/
public String readDir(String arg)
{
  // parse the input parms to switch the dir we want
  if(arg!=null) setDirString(arg);

  initOutText();
  initDirFile(dirString);
  if(dirFile.isDirectory())
  {
    if(dirFile.canRead())
    {
      String[] files = dirFile.list();
      fileName  = dirFile.list();
      File tempFile;
      for (int i=0;i< fileName.length;i++)
      {
        outText_ += "<UL>\n";
        tempFile = new File(dirString+File.separator+files[i]);
        if(tempFile.isDirectory())
        outText_ += "<LI> [DIR] <A HREF=\""+files[i]+"\">" +
                     files[i] + "</A> <FONT size=\"-1\">(<I>" + tempFile.length() +
                     " bytes</I>)</font>";
        else
        {
          outText_ += "<LI>      <A HREF=\""+files[i]+"\">" +
                     files[i] + "</A> <FONT size=\"-1\">(<I>" + tempFile.length() +
                     " bytes</I>)</font>";
          fileName[fileIndex] = files[i];
          fileSizeHash.put(fileName[fileIndex++] ,
                           new Long( (long) tempFile.length()));

        }
        outText_+="</UL>\n";
      }
      numFiles = fileIndex;
      //initFileIndex();
    }
    else {
      outText_ += "\n<P><B><I>Error Encountered:</I></B>";
      outText_ += "\n<P>Unable to read Directory ->" + dirString;
      outText_ += "\n<HR>";
    }
  }
  else {
    outText_ += "\n<P><B><I>Error Encountered:</I></B>";
    outText_ += "\n<P>Not A Directory ->" + dirString;
    outText_ += "\n<HR>";
  }

  finalizeOutText();

  return(outText_);
}


public static synchronized String[] parseAuthorAndTitleFromFilename(String filename)
{
  String[] retVal = new String[2];

  String author = "";
  // Get the Author Name
  int startPosition = filename.indexOf("_");
  if (startPosition < 0 )
  {
    startPosition = 0;
    author = "Not Available";
  }
  else
    author = filename.substring(0,startPosition).trim();

  int endPosition = filename.lastIndexOf(".");

  // get the Title
  String title = filename.substring(startPosition+1,endPosition);


  // now expand the tile and author
  String tempAuthor="";
  String expandedTitle="";
  String expandedAuthor=author;
  int len = title.length();
  boolean capital = true;
  boolean letter = true;
  boolean digit = false;
  boolean lastDigit = false;
  char c;
  for (int i=0; i<len; i++)
  {
     c = title.charAt(i);
     letter = Character.isLetter(c);
     capital= letter & Character.isUpperCase(c);
     digit =  Character.isDigit(c);

     if (capital || (digit && !lastDigit) || (!digit && !letter))
       expandedTitle += " ";

     expandedTitle += c;
     lastDigit = digit;
  }
  if (!(tempAuthor.toUpperCase().equals(author.toUpperCase())) )
  {
      expandedAuthor="";
      tempAuthor = author;
      capital = true;
      letter = true;
      digit = false;
      lastDigit = false;
      for (int i=0;i<startPosition;i++)
      {
        c = tempAuthor.charAt(i);
        letter = Character.isLetter(c);
        capital= letter & Character.isUpperCase(c);
        digit =  Character.isDigit(c);

        if (capital || (digit && !lastDigit) || (!digit && !letter))
          expandedAuthor += " ";

        expandedAuthor += c;
        lastDigit = digit;
      }
  }

  retVal[0] = expandedAuthor;
  retVal[1] = expandedTitle;

  return retVal;
}

/**
 * Reads the passed in directory and produces a winamp playlist for all
 * mp3 and ogg files in the dir.  It returns a playlist string.
 *
 * @param urlRoot the String representation of url to prepend to all the
                  files found. If an empty or null is sent it creates a
                  file:// url.
 * @param dirToRead the String representation of the directory to read.
 * @param recurse flags if the dir should be recursed
 * @param the name of the file to save.
 * @return the winamp playlist filename to save,
 *         (null to NOT save, empty string to use default)
 **/
public static synchronized String createWinampList(String urlRoot,
                               String dirToRead,
                               boolean recurse,
                               String filename)
{
  String retVal = "";
  String EOL = "\r\n";
  String winampHeader = "#EXTM3U" + EOL;
  int winampHeaderLen = winampHeader.length();
  String winampFilename = "WinAmpList.m3u";
  boolean savingTheFile = true;
  if (urlRoot == null) urlRoot = "";
  if (filename != null &&
     !filename.equals(""))
    winampFilename = filename;
  else if (filename == null)
    savingTheFile = false;
  File dirFileToRead = null;

  if ( dirToRead !=null &&
      !dirToRead.equals(""))
  {
    dirFileToRead = new File(dirToRead);

    //Check if dir is available
    if(dirFileToRead.isDirectory() && dirFileToRead.canRead())
    {
      // read files
      retVal = "";
      String[] filesInDir = dirFileToRead.list();
      File tempFile;
      String[] authorTitle = new String[2];

      // loop through all files
      for (int i=0; i< filesInDir.length; i++)
      {
        tempFile = new File(dirToRead+File.separator+filesInDir[i]);
        if(!tempFile.isDirectory())
        // files get added
        {
          if (filesInDir[i].trim().toLowerCase().endsWith(".mp3") ||
              filesInDir[i].trim().toLowerCase().endsWith(".ogg"))
          {
            authorTitle = parseAuthorAndTitleFromFilename(filesInDir[i].trim());
            retVal += "#EXTM3U:-1," + authorTitle[0] + " - " +
                      authorTitle[1] + EOL;
            retVal += urlRoot + "/" + filesInDir[i] + EOL;
          }
          else
          {
            // ignore ... it's not a song file
          }
        }
        else
        // dirs get recursed
        {
          String recursedList = createWinampList(urlRoot+"/"+filesInDir[i],
                                     tempFile.toString(),
                                     recurse,
                                     null); //never save the file on a recurse
          if (recursedList != null && !recursedList.equals(""))
            retVal += EOL + recursedList.substring(winampHeaderLen);
        }
      }

      //clean up the retVal
      retVal = retVal.trim();
      if (retVal != null && !retVal.equals("") && !retVal.startsWith(winampHeader))
        retVal = winampHeader + retVal;


      // Save the file
      if (savingTheFile)
      {
        try
        {
          if(filesInDir.length > 0 && retVal.length()>0)
          {
            FileWriter fileWriter = new FileWriter(dirToRead + File.separator +
                                                   winampFilename);
            fileWriter.write(retVal,0,retVal.length());
            fileWriter.flush();
            fileWriter.close();
          }
          else
          {
            // No Files return empty string
            lastErrorMsg = "\n<P><B><I>Error Encountered:</I></B>";
            lastErrorMsg += "\n<P>NO files in " + dirToRead;
            lastErrorMsg += "\n<HR>";
            retVal = "";
          }
        }
        catch (IOException ex)
        {
          lastErrorMsg = "\n<P><B><I>Error Encountered:</I></B>";
          lastErrorMsg += "\n<P>Unable to create WinAmp Playlist file" +
                          "for Directory ->\n" + dirToRead;
          lastErrorMsg += "\n<HR>";
        }
      }
    }
    else
    {
      // error return empty string
      lastErrorMsg = "\n<P><B><I>Error Encountered:</I></B>";
      lastErrorMsg += "\n<P>NOT a dir or Unable to initialize Directory for "+
                      "reading->" + dirString;
      lastErrorMsg += "\n<HR>";
      retVal = "";
    }
  }
  else
  {
    // error return empty string
    lastErrorMsg = "\n<P><B><I>Error Encountered:</I></B>";
    lastErrorMsg += "\n<P>Unable to initialize Directory for reading->" +
                    dirString;
    lastErrorMsg += "\n<HR>";
    retVal = "";
  }

  return retVal;
}


/**
 * Reads the passed in directory and produces a winamp playlist for all
 * mp3 files in the dir.It returns an empty string "" if the file cannot be
 * created and fills the lastErrorMsg field.
 *
 * @param urlRoot the String representation of url to prepend to all the
                  files found. If an empty or null is sent it creates a
                  file:// url.
 * @param arg the String representation of the directory to read.
 * @param recurse flags if the dir should be recursed
 * @return the name of the winamp playlist file.
 **/
public String createWinampList(String urlRoot, String arg, boolean recurse)
{
  String retVal = "#EXTM3U\n";
/*
 #EXTINF:239,Bryan Adams - Hey honey-I'm packin'you in!
 D:\tbg\stuff\mp3\BryanAdams_HeyHoney-ImPackinYouIn.mp3
*/
  // parse the input parms to switch the dir we want

  if (urlRoot == null)
    urlRoot = "";

  if(true )//initDir(arg, true))
  {
    //autoFormatFileNames();
    String[] files = dirFile.list();
    fileName  = dirFile.list();
    File tempFile;
    String artistName = "";
    String songTitle = "";
    System.out.println("Creating Playlist with "+fileName.length+" Songs");
    for (int i=0;i< fileName.length;i++)
    {
      tempFile = new File(dirString+File.separator+fileNamePath[i]+
                                    fileName[i]);
      /*if(tempFile.isDirectory() && recurse)
      {
        retVal += createWinampList(urlRoot,
                                   dirString+File.separator+fileName[i],
                                   true);
      }
      else */
      System.out.println("Filename="+tempFile.toString());
      if (fileName[i].trim().toLowerCase().endsWith(".mp3") ||
               fileName[i].trim().toLowerCase().endsWith(".ogg"))
      {
        retVal += "#EXTM3U:-1," + artistName + " - " + songTitle + "\n";
        retVal += urlRoot + fileNamePath[i] + fileName[i] + "\n";
      }
    }
    try
    {
      FileWriter fileWriter = new FileWriter(dirString + File.separator +
                                             winampFilename);
      fileWriter.write(retVal,0,retVal.length());
      fileWriter.flush();
      fileWriter.close();
    }
    catch (IOException ex)
    {
      lastErrorMsg = "\n<P><B><I>Error Encountered:</I></B>";
      lastErrorMsg += "\n<P>Unable to create WinAmp Playlist file for Directory ->" + dirString;
      lastErrorMsg += "\n<HR>";
     }
  }
  else
  {
    lastErrorMsg = "\n<P><B><I>Error Encountered:</I></B>";
    lastErrorMsg += "\n<P>Unable to initialize Directory for reading->" + dirString;
    lastErrorMsg += "\n<HR>";
  }


  return(retVal);
}


/** For Testing Purposes **/
public static void main (String [] args)
  {
    DirReadBean dirlist1 = new DirReadBean();
    dirlist1.initFileIndex();
    dirlist1.initFileName();
    dirlist1.setDirString("");
    String dir1 = "g:\\snd\\ogg\\";
    dirlist1.initDir(dir1, "/ogg", true); // true to recurse
    String aList = dirlist1.getTitledAuthorList("ogg");
    //System.out.println(aList);

    String [] magNames = dirlist1.getArtistsNames();
    String currName = "";
    for (int i=0; i< magNames.length; i++)
    {
      currName = magNames[i];
      System.out.println(currName);
    }

    //dirlist1 = new DirReadBean();
    //dirlist1.initFileIndex();
    //dirlist1.initFileName();
    //dirlist1.setDirString("");
    String playlist =
       createWinampList("http://warp2/ogg", dir1, true,"");

    if (!playlist.equals(""))
      System.out.println("Playlist written to file.");
    else
      System.out.println(getLastErrorMessage());
  }


/*
Here is the revision log
------------------------
$Log: DirReadBean.java,v $
Revision 1.8  2002/05/02 22:32:45  tgutwin
Fixed Winamp list problems
Added recursive options

Revision 1.7  2002/04/15 04:40:04  anonymous

Added fields and methods to allow the getTitledAuthorList to ignore certain
files when parsing and preparing output.

Revision 1.6  2002/03/27 20:08:18  anonymous
Trim the Artist Name Strings and added a A Name to each Artist Title

Revision 1.5  2001/11/17 04:39:25  tgutwin

Added a couple of get methods.

Revision 1.4  2001/09/02 03:24:14  tgutwin

Initial Rev of my custom DropDown Boxes.

Revision 1.3  2001/08/08 23:36:21  tgutwin

Added CVS Keywords.


*/
}