/* ========================================================================
    * JFiglet, a free open source java implementation of figlet and the
    * figfont specification (see http://www.figlet.org)
    * Copyright (C) 2004 Sebastien Brunot
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
   *
   * This library 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
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
   * ========================================================================
   */
  package org.gnu.jfiglet.core;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.net.URL;
  import java.util.NoSuchElementException;
  import java.util.StringTokenizer;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipException;
  import java.util.zip.ZipInputStream;
  
  /***
   * A FIGfont, which file format is specified by
   * <A HREF="doc-files/figfont.txt">this document</A>.
   *
   * @TODO : READ THE EXTRA NON ASCII CHARACTERS IN FIGFONT FILES
   *
   * @version $Id: FIGFont.java,v 1.3 2004/04/27 20:09:28 sbrunot Exp $
   *
   * @author <a href="mailto:sebastien.brunot@club-internet.fr">
   *         Sebastien Brunot</a>
   */
  public class FIGFont
  {
      /////////////////////////////////////
      // Constants
      /////////////////////////////////////
  
      /***
       * The maximum valid code for a character of the FIGFont
       * 8-bit characterset
       */
      public static final int MAX_8BIT_CHARSET_CHAR_CODE = 255;
  
      /***
       * The separator between tokens in a FIGFont file header
       */
      private static final String FIG_FONT_HEADER_TOKEN_SEPARATOR = " ";
  
      /***
       * The signature of a FIGFont file (the 5 first characters of the
       * (unziped) file)
       */
      private static final String FIGFONT_FILE_SIGNATURE = "flf2a";
  
      /***
       * The extension of a FIGFont file (which name is FIGFontName.extension)
       */
      private static final String FIGFONT_EXTENSION = "flf";
  
      /***
       * The name of the fonts directory in the classpath
       */
      private static final String FONT_DIRECTORY_NAME = "fonts";
  
      /////////////////////////////////////
      // Attributes
      /////////////////////////////////////
  
      /***
       * Informations about the FIGFont
       */
      private FIGFontInfo info = null;
  
      /***
       * An array that holds the FIGCharacters of the font. The index
       * of a FIGCharacter in this array is the code of the
       * subcharacter it stands for in its characterset.
       */
      private FIGCharacter[] eightBitCharacterSet =
          new FIGCharacter[MAX_8BIT_CHARSET_CHAR_CODE + 1];
  
      /////////////////////////////////////
      // Constructor
      /////////////////////////////////////
  
      /***
      * Create an empty FIGFont whith a provided name.
      * @param theName the name of the font
      */
     public FIGFont(String theName)
     {
         this.info = new FIGFontInfo();
         this.info.setName(theName);
     }
 
     /////////////////////////////////////
     // Public methods
     /////////////////////////////////////
 
     /***
      * Load the content of the FIGFont from the <em>fontname</em>.flf file
      * provided in the fonts directory in the classpath.
      * @throws IOException if such an exception occured while accessing the
      * <em>fontname</em>.flf file.
      * @throws ZipException if the <em>fontname</em>.flf file is a zip file
      * and such an exception occurs reading its content.
      * @throws IllegalFIGFontFileException if the <em>fontname</em>.flf file
      * provided in the classpath is not a valid FIGFont file or if there is
      * no <em>fontname</em>.flf file provided in the fonts directory in the
      * classpath.
      */
     public void loadFromFile()
         throws IOException, ZipException, IllegalFIGFontFileException
     {
         // the path of the file that should holds the FIGFont data
         String fontFilePath =
             FONT_DIRECTORY_NAME
                 + "/"
                 + this.info.getName()
                 + "."
                 + FIGFONT_EXTENSION;
         // get an URL to this file using system classloader
         URL fontFileURL = ClassLoader.getSystemResource(fontFilePath);
         if (fontFileURL == null)
         {
             // No such file has been found
             throw new IllegalFIGFontFileException(
                 "Cannot find " + fontFilePath + " in the classpath.");
         }
         // Open an input stream to the font file
         InputStream fontFileInputStream = fontFileURL.openStream();
         // the font file can either be a zip file or a "normal" file
         // Create a zip input stream from the fontFileInputStream
         ZipInputStream fontFileZipInputStream =
             new ZipInputStream(fontFileInputStream);
         // Move the input stream cursor to the beginning of the
         // first zip file entry.
         ZipEntry entry = fontFileZipInputStream.getNextEntry();
         if (entry == null)
         {
             // the font file is not a zip file !
             // As the getNextEntry move the input stream cursor
             // to the next line, we have to "hard reset" the input
             // stream
             fontFileZipInputStream.close();
             fontFileInputStream.close();
             fontFileInputStream = fontFileURL.openStream();
         }
         else
         {
             // The font file is a zip : fontFileZipInputStream
             // is an input stream to the unziped font file
             fontFileInputStream = fontFileZipInputStream;
         }
         readFontFile(fontFileInputStream);
         fontFileInputStream.close();
     }
 
     /***
      * Get one of the FIGFont FIGCharacters.
      * @param theCharacterCode the code of the FIGCharacter in
      * the FIGFont characterset. An IllegalArgumentException is thrown if
      * this code is lower than 0 or greater than MAX_8BIT_CHARSET_CHAR_CODE
      * @return the FIGCharacter which code is theCharacterCode in
      * the FIGFont characterset. If no FIGCharacter is defined for this code
      * in the FIGFont, the FIGCharacter which code is 0 is returned.
      */
     public FIGCharacter getFIGCharacter(int theCharacterCode)
     {
         if (theCharacterCode < 0
             || theCharacterCode > MAX_8BIT_CHARSET_CHAR_CODE)
         {
             throw new IllegalArgumentException(
                 "The character code is an integer between 0 and "
                     + MAX_8BIT_CHARSET_CHAR_CODE
                     + " included");
         }
         FIGCharacter returnValue = this.eightBitCharacterSet[theCharacterCode];
         if (returnValue == null)
         {
             returnValue = this.eightBitCharacterSet[0];
         }
         return this.eightBitCharacterSet[theCharacterCode];
     }
 
     /***
      * Get informations about the FIGFont.
      * @return informations about the FIGFont.
      */
     public FIGFontInfo getInfo()
     {
         return this.info;
     }
 
     /////////////////////////////////////
     // Private methods
     /////////////////////////////////////
 
     /***
      * Read the content of a .flf file and initialize the FIGFont
      * with it.
      * @param theFontFile an input stream to the content of the
      * .flf file (or to the content of it first (unziped) entry
      * if the .flf file is a zip file).
      * @throws IOException if such an exception occurs reading
      * theFontFile.
      * @throws IllegalFIGFontFileException if  theFontFile does
      * not provide the content of a correct .flf file (see
      * <A HREF="http://www.figlet.org">http://www.figlet.org</A>
      * for .flf file specification.
      */
     private void readFontFile(InputStream theFontFile)
         throws IOException, IllegalFIGFontFileException
     {
         // Creates a Buffered reader to theFontFile
         BufferedReader fontFileReader =
             new BufferedReader(new InputStreamReader(theFontFile));
         // Read the font file header line
         String fontFileHeaderLine = fontFileReader.readLine();
         try
         {
             // Get font informations from the header line
             FIGFontInfo infosFromTheHeader =
                 populateFIGFontInfoFromFIGFontFileHeader(fontFileHeaderLine);
             // Add the font name to those informations
             infosFromTheHeader.setName(this.info.getName());
             // Set those informations as the current informations
             this.info = infosFromTheHeader;
         }
         catch (IllegalArgumentException e)
         {
             // This exception is caused by an uncorrect header line
             throw new IllegalFIGFontFileException(e.getMessage());
         }
         // Read the comments about the font and add them to the
         // FIGFontInfo
         for (int i = 0; i < this.info.getCommentLinesNumber(); i++)
         {
             this.info.addCommentLine(fontFileReader.readLine());
         }
         // Read FIGcharacters 32 through 126
         for (int currentCharCode = 32;
             currentCharCode < 127;
             currentCharCode++)
         {
             String[] characterLines = new String[this.info.getHeight()];
             for (int i = 0; i < this.info.getHeight(); i++)
             {
                 characterLines[i] = fontFileReader.readLine();
             }
             this.eightBitCharacterSet[currentCharCode] =
                 new FIGCharacter(characterLines);
         }
         // Read required Deutsch characters
         int[] deutchCharactersCodes = {196, 214, 220, 228, 246, 252, 223};
         for (int i = 0; i < deutchCharactersCodes.length; i++)
         {
             String[] characterLines = new String[this.info.getHeight()];
             for (int j = 0; j < this.info.getHeight(); j++)
             {
                 characterLines[j] = fontFileReader.readLine();
             }
             this.eightBitCharacterSet[deutchCharactersCodes[i]] =
                 new FIGCharacter(characterLines);
         }
         // READ EXTRA CHARACTERS...
         boolean readNextCharacterDefinition = true;
         while (readNextCharacterDefinition)
         {
             // Read the next line if there is one
             String characterHeader = fontFileReader.readLine();
             if (characterHeader == null)
             {
                 // No more lines to read in the figfont file
                 readNextCharacterDefinition = false;
                 break;
             }
             else
             {
                 StringTokenizer tokenizer =
                     new StringTokenizer(characterHeader);
                 // Get the first token before the white space, which is the
                 // character number
                 String characterCodeAsString = tokenizer.nextToken(" ");
                 try
                 {
                     int characterCode =
                         decodeCharacterCode(characterCodeAsString);
                     // read the character in the FIGFont file
                     String[] characterLines = new String[this.info.getHeight()];
                     for (int i = 0; i < this.info.getHeight(); i++)
                     {
                         characterLines[i] = fontFileReader.readLine();
                         if (characterLines[i] == null)
                         {
                             throw new IllegalFIGFontFileException(
                                 "Character which code is "
                                     + characterCode
                                     + " is not entirely defined");
                         }
                     }
                     if ((characterCode > 0)
                         && (characterCode < MAX_8BIT_CHARSET_CHAR_CODE))
                     {
                         // Store the extra character in the ascii characters
                         // table
                         this.eightBitCharacterSet[characterCode] =
                             new FIGCharacter(characterLines);
                     }
                     else
                     {
                         // @TODO : this is a non ascii extra character : store
                         // it somewhere !
                     }
                 }
                 catch (NumberFormatException e)
                 {
                     throw new IllegalFIGFontFileException(
                         "Line \"" + characterHeader + " is uncorrect");
                 }
             }
         }
     }
 
     /***
      * Returns a FIGFontInfo object populated with informations readen from
      * the header line of a .flf file.
      * @param theFIGFontFileHeader the header line to get font informations
      * from. An IllegalArgumentException is raised if this is not a legal
      * font header line, with a message describing the error.
      * @return a FIGFontInfo object populated with informations readen from
      * theFIGFontFileHeader.
      */
     private FIGFontInfo populateFIGFontInfoFromFIGFontFileHeader(
                                                 String theFIGFontFileHeader)
     {
         FIGFontInfo informations = new FIGFontInfo();
         // Verify that the header is not null
         if (theFIGFontFileHeader == null)
         {
             throw new IllegalArgumentException("The header is null");
         }
         // The old layout value that must be defined defined in the header,
         // initialized here with an illegal value
         int oldLayout = -10;
         // The full layout value that could be defined in the header
         Integer fullLayout = null;
         // Build a StrinTokenizer to read entries of the header
         StringTokenizer tokenizer =
             new StringTokenizer(
                 theFIGFontFileHeader,
                 FIG_FONT_HEADER_TOKEN_SEPARATOR);
         // the number of token the header is made of
         int numberOfTokens = tokenizer.countTokens();
         // According to the figfont spec, there must be at least 6 tokens,
         // at most 9 
         if (numberOfTokens < 6)
         {
             throw new IllegalArgumentException(
                         "Not enough tokens in the header");
         }
         else if (numberOfTokens > 9)
         {
             throw new IllegalArgumentException("Too many tokens in the header");
         }
         // First token must be the file signature plus the hardblank character
         String signatureAndHardblank = tokenizer.nextToken();
         if (!(FIGFONT_FILE_SIGNATURE
             .equals(
                 signatureAndHardblank.substring(
                     0,
                     FIGFONT_FILE_SIGNATURE.length()))))
         {
             throw new IllegalArgumentException("Uncorrect signature");
         }
         // Set the hardblank value in the FIGFontInfo
         informations.setHardblank(
             signatureAndHardblank.charAt(FIGFONT_FILE_SIGNATURE.length()));
         // Second token is the font height
         try
         {
             informations.setHeight(Integer.parseInt(tokenizer.nextToken()));
         }
         catch (NumberFormatException e)
         {
             throw new IllegalArgumentException(
                 "Font height must be an integer");
         }
         // Third token is the font baseline
         try
         {
             informations.setBaseline(Integer.parseInt(tokenizer.nextToken()));
         }
         catch (NumberFormatException e)
         {
             throw new IllegalArgumentException(
                 "Font baseline must be an integer");
         }
         // Fourth token is the font max length
         try
         {
             informations.setMaxLength(Integer.parseInt(tokenizer.nextToken()));
         }
         catch (NumberFormatException e)
         {
             throw new IllegalArgumentException(
                 "Font max length must be an integer");
         }
         // Fifth token is the old layout
         try
         {
             oldLayout = Integer.parseInt(tokenizer.nextToken());
         }
         catch (NumberFormatException e)
         {
             throw new IllegalArgumentException(
                 "Old layout must be an integer");
         }
         // Sixth token is the number of line of comments
         try
         {
             informations.setCommentLinesNumber(
                 Integer.parseInt(tokenizer.nextToken()));
         }
         catch (NumberFormatException e)
         {
             throw new IllegalArgumentException(
                 "The number of lines of comments must be an integer");
         }
         try
         {
             try
             {
                 // Seventh token, if it exists, is the print direction
                 Integer printDirection = new Integer(tokenizer.nextToken());
                 if (printDirection != null)
                 {
                     // Verify that the defined print direction has a legal value
                     if ((printDirection.intValue()
                         != FIGFontInfo.PRINT_DIRECTION_LEFT_TO_RIGHT)
                         && (printDirection.intValue()
                             != FIGFontInfo.PRINT_DIRECTION_RIGHT_TO_LEFT))
                     {
                         throw new IllegalArgumentException(
                             "Accepted values for printDirection are "
                                 + FIGFontInfo.PRINT_DIRECTION_LEFT_TO_RIGHT
                                 + " for LEFT_TO_RIGHT and "
                                 + FIGFontInfo.PRINT_DIRECTION_RIGHT_TO_LEFT
                                 + " for RIGHT_TO_LEFT");
                     }
                     // Add its value to the FIGFontInfo
                     informations.setPrintDirection(printDirection.intValue());
                 }
                 // Eighth token, if it exists, is the full layout
                 try
                 {
                     fullLayout = new Integer(tokenizer.nextToken());
                 }
                 catch (NumberFormatException e)
                 {
                     throw new IllegalArgumentException(
                         "The Full Layout must be an integer");
                 }
                 // Ninth token, if it exists, is the codetag count.
                 // IT IS NOT USED BY JFiglet.
             }
             catch (NumberFormatException e)
             {
                 throw new IllegalArgumentException(
                     "The print direction must be an integer");
             }
         }
         catch (NoSuchElementException e)
         {
             // There's no more token
         }
         // Create the layout specification
         informations.setLayout(new FIGFontLayout(oldLayout, fullLayout));
         // return the FIGFontInfo
         return informations;
     }
 
     /***
      * Decode the code of an extra character.
      * A character code may be expressed in decimal (as shown above, numbers
      * we're all familiar with), or in Octal (seldom used) or in hexadecimal.
      * Character codes expressed in octal must be preceded by "0" (zero), and if
      * negative, "-" (minus) must precede the "0".  There are eight octal
      * digits: 01234567.  You may recall octal numbers from school as "base 8
      * numbers".
      * Character codes expressed in hexadecimal must be preceded by "0x" or
      * "0X" (That's also a zero.)  If negative, the "-" must precede the "0x".
      * There are 16 hexadecimal digits: 01234567890ABCDEF.  (The "letter-digits"
      * may also be lowercase.)  Hexadecimal is "base 16".
      * @param theCharacterCodeAsString the code of the character as expressed in
      * the FIGFont file
      * @return the code of the character as an int.
      * @throws NumberFormatException if theCharacterCodeAsString is not
      * an integer in one of the recognized formats.
      */
     private int decodeCharacterCode(String theCharacterCodeAsString)
     {
         String codeAsString = new String(theCharacterCodeAsString);
         // The sign of the integer (1 for positive, -1 for negative)
         int sign = 1;
         // The base the character is expressed in
         int characterCodeRadix = 10;
         if (codeAsString.charAt(0) == '-')
         {
             // First char is '-' : the sign is negative
             sign = -1;
             codeAsString = codeAsString.substring(1);
         }
         if (codeAsString.charAt(0) == '0')
         {
             // First number is a zero : base is 8 or 16
             characterCodeRadix = 8;
             codeAsString = codeAsString.substring(1);
             if ((codeAsString.charAt(0) == 'X')
                 || (codeAsString.charAt(0) == 'x'))
             {
                 // 0 is followed by X : base is 16
                 characterCodeRadix = 16;
                 codeAsString = codeAsString.substring(1);
             }
         }
         return (sign * Integer.parseInt(codeAsString, characterCodeRadix));
     }
 
 }