/*

  * Copyright 2002 - 2008 JEuclid, http://jeuclid.sf.net

  * 

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 /* $Id: MathMLConverter.java,v ee8eb070689f 2008/06/25 14:51:09 maxberger $ */

 package net.sourceforge.jeuclid.ant;

 import java.io.File;

 import java.io.IOException;

 import java.util.Arrays;

 import java.util.List;

 import net.sourceforge.jeuclid.MutableLayoutContext;

 import net.sourceforge.jeuclid.context.LayoutContextImpl;

 import net.sourceforge.jeuclid.context.Parameter;

 import net.sourceforge.jeuclid.converter.Converter;

 import net.sourceforge.jeuclid.converter.ConverterRegistry;

 import org.apache.tools.ant.BuildException;

 import org.apache.tools.ant.DirectoryScanner;

 import org.apache.tools.ant.Project;

 import org.apache.tools.ant.taskdefs.MatchingTask;

 import org.apache.tools.ant.util.FileUtils;

 /**

  * This task converts MathML files to images.

  * 

  * @version $Revision: ee8eb070689f $

  */

 public class MathMLConverter extends MatchingTask {

     private static final String CURRENT_DIR = "./";

     private static final char EXTENSION_SEP = '.';

     /**

      * 

      */

     private File mdestDir;

     private File mbaseDir;

     private File minFile;

     private File moutFile;

     private String moutType = "image/png";

     private boolean mforce;

     private final MutableLayoutContext context;

     private final FileUtils fileUtils;

     /**

      * Creates a new MathMLConverter Task.

      */

     public MathMLConverter() {

         this.context = new LayoutContextImpl(LayoutContextImpl

                 .getDefaultLayoutContext());

         this.fileUtils = FileUtils.getFileUtils();

     }

     /**

      * Executes the task.

      * 

      */

     @Override

     public void execute() {

         DirectoryScanner scanner;

         String[] list;

         String[] dirs;

         if (this.mbaseDir == null) {

             this.mbaseDir = this.getProject().resolveFile(

                     MathMLConverter.CURRENT_DIR);

             this.log("Base is not sets, sets to " + this.mbaseDir,

                     Project.MSG_WARN);

         }

         // if we have an in file and out then process them

         if ((this.minFile != null) && (this.moutFile != null)) {

             this.log("Transforming file: " + this.minFile + " --> "

                     + this.moutFile, Project.MSG_VERBOSE);

             try {

                 Converter.getInstance().convert(this.minFile, this.moutFile,

                         this.moutType, this.context);

             } catch (final IOException io) {

                 throw new BuildException(io);

             }

             return;

         }

         /*

          * if we get here, in and out have not been specified, we are in batch

          * processing mode.

          */

         // -- make sure Source directory exists...

         if (this.mdestDir == null) {

             throw new BuildException("m_destDir attributes must be set!");

         }

         scanner = this.getDirectoryScanner(this.mbaseDir);

         this.log("Transforming into " + this.mdestDir, Project.MSG_INFO);

         // Process all the files marked for styling

         list = scanner.getIncludedFiles();

         this.log("Included files: " + Arrays.toString(list),

                 Project.MSG_VERBOSE);

         this.process(this.mbaseDir, Arrays.asList(list), this.mdestDir);

         // Process all the directories marked for styling

         dirs = scanner.getIncludedDirectories();

         this.log("Included directories: " + Arrays.toString(dirs),

                 Project.MSG_VERBOSE);

         for (final String dir : dirs) {

             list = this.fileUtils.resolveFile(this.mbaseDir, dir).list();

             this.process(this.mbaseDir, Arrays.asList(list), this.mdestDir);

         }

     }

     /**

      * Sets support for anti alias (default is <i>true</i>).

      * 

      * @param antiAlias

      *            Flag for support anti alias.

      */

     public void setAntiAlias(final boolean antiAlias) {

         this.setOption(Parameter.ANTIALIAS, antiAlias);

     }

     /**

      * Sets minimal size for turn on anti alias (default is <i>10.0</i>).

      * 

      * @param antiAliasMinSize

      *            Minimal size in float number.

      */

     public void setAntiAliasMinSize(final float antiAliasMinSize) {

         this.setOption(Parameter.ANTIALIAS_MINSIZE, antiAliasMinSize);

     }

     /**

      * Sets background color.

      * 

      * @param color

      *            String representation of color.

      */

     public void setBackgroundColor(final String color) {

         if (this.isNullOrEmpty(color)) {

             this.log("Attribute \"backgroundcolor\" is empty, not used",

                     Project.MSG_WARN);

         } else {

             this.setOption(Parameter.MATHBACKGROUND, color);

         }

     }

     /**

      * Sets support for debug (default is <i>false</i>).

      * 

      * @param debug

      *            Flag for support debug.

      */

     public void setDebug(final boolean debug) {

         this.setOption(Parameter.DEBUG, debug);

     }

     /**

      * Sets display style (default is <i>BLOCK</i>.

      * 

      * @param display

      *            String value of display style.

      * 

      * @see net.sourceforge.jeuclid.context.Display

      */

     public void setDisplay(final String display) {

         this.setOption(Parameter.DISPLAY, display);

     }

     /**

      * Sets list of supported font families for <i>Double-Struck</i>.

      * 

      * @param fonts

      *            List separated by comma.

      */

     public void setFontsDoublestruck(final String fonts) {

         this.setOption(Parameter.FONTS_DOUBLESTRUCK, fonts);

     }

     /**

      * Sets list of supported font families for <i>Fraktur</i>.

      * 

      * @param fonts

      *            List separated by comma.

      */

     public void setFontsFraktur(final String fonts) {

         this.setOption(Parameter.FONTS_FRAKTUR, fonts);

     }

     /**

      * Sets font size of text.

      * 

      * @param fontSize

      *            Font size as float value.

      */

     public void setFontSize(final float fontSize) {

         this.setOption(Parameter.MATHSIZE, fontSize);

     }

     /**

      * Sets list of supported font families for <i>Monospaced</i>.

      * 

      * @param fonts

      *            List separated by comma.

      */

     public void setFontsMonospaced(final String fonts) {

         this.setOption(Parameter.FONTS_MONOSPACED, fonts);

     }

     /**

      * Sets list of supported font families for <i>Sans-Serif</i>.

      * 

      * @param fonts

      *            List separated by comma.

      */

     public void setFontsSansSerif(final String fonts) {

         this.setOption(Parameter.FONTS_SANSSERIF, fonts);

     }

     /**

      * Sets list of supported font families for <i>Script</i>.

      * 

      * @param fonts

      *            List separated by comma.

      */

     public void setFontsScript(final String fonts) {

         this.setOption(Parameter.FONTS_SCRIPT, fonts);

     }

     /**

      * Sets list of supported font families for <i>Serif</i>.

      * 

      * @param fonts

      *            List separated by comma.

      */

     public void setFontsSerif(final String fonts) {

         this.setOption(Parameter.FONTS_SERIF, fonts);

     }

     /**

      * Sets foreground color.

      * 

      * @param color

      *            String representation of color.

      */

     public void setForegroundColor(final String color) {

         if (this.isNullOrEmpty(color)) {

             this

                     .log(

                             "Attribute \"foregroundcolor\" is empty, use default color",

                             Project.MSG_WARN);

         } else {

             this.setOption(Parameter.MATHCOLOR, color);

         }

     }

     /**

      * Sets <mfrac> keep scriptlevel.

      * 

      * @param keepScriptLevel

      *            if true, element will NEVER increase children's scriptlevel

      *            (in violation of the spec).

      */

     public void setMfracKeepScriptLevel(final boolean keepScriptLevel) {

         this.setOption(Parameter.MFRAC_KEEP_SCRIPTLEVEL, keepScriptLevel);

     }

     /**

      * Sets scripts level (default is <i>0</i>).

      * 

      * @param level

      *            Script level.

      */

     public void setScriptLevel(final int level) {

         this.setOption(Parameter.SCRIPTLEVEL, level);

     }

     /**

      * Sets minimal size of smallest font size (default is <i>8.0</i>).

      * 

      * @param minSize

      *            Size of font.

      */

     public void setScriptMinSize(final float minSize) {

         this.setOption(Parameter.SCRIPTMINSIZE, minSize);

     }

     /**

      * Sets size of multiplier (default is <i>0.71</i>).

      * 

      * @param multSize

      *            Size of multiplier.

      */

     public void setScriptSizeMult(final float multSize) {

         this.setOption(Parameter.SCRIPTSIZEMULTIPLIER, multSize);

     }

     /**

      * Set whether to check dependencies, or always generate.

      * 

      * @param force

      *            True, if the task should always generate the images.

      */

     public void setForce(final boolean force) {

         this.logProperty("force", force);

         this.mforce = force;

     }

     /**

      * Set the base directory.

      * 

      * @param dir

      *            Base directory

      */

     public void setBasedir(final File dir) {

         this.logProperty("basedir", dir);

         this.mbaseDir = dir;

     }

     /**

      * Set the destination directory into which the result files should be

      * copied to.

      * 

      * @param dir

      *            Destination directory

      */

     public void setDestdir(final File dir) {

         this.logProperty("destdir", dir);

         this.mdestDir = dir;

     }

     /**

      * Sets an out file.

      * 

      * @param outFile

      *            Output file

      */

     public void setOut(final File outFile) {

         this.logProperty("out", outFile);

         this.moutFile = outFile;

     }

     /**

      * Sets an input xml file to be converted.

      * 

      * @param inFile

      *            Input file

      */

     public void setIn(final File inFile) {

         this.logProperty("in", inFile);

         this.minFile = inFile;

     }

     /**

      * Sets output file mimetype.

      * 

      * @param mimetype

      *            mimetype for output file.

      */

     public void setType(final String mimetype) {

         this.logProperty("type", mimetype);

         this.moutType = mimetype;

     }

     /**

      * Processes the given input XML file and stores the result in the given

      * resultFile.

      * 

      * @param baseDir

      *            Base directory

      * @param xmlFiles

      *            Source file

      * @param destDir

      *            Destination directory

      */

     private void process(final File baseDir, final List<String> xmlFiles,

             final File destDir) {

         for (final String xmlFile : xmlFiles) {

             File outFile = null;

             File inFile = null;

             final String suffix = MathMLConverter.EXTENSION_SEP

                     + ConverterRegistry.getInstance().getSuffixForMimeType(

                             this.moutType);

             this.log("Found extension: " + suffix, Project.MSG_DEBUG);

             try {

                 inFile = this.fileUtils.resolveFile(baseDir, xmlFile);

                 final int dotPos = xmlFile

                         .lastIndexOf(MathMLConverter.EXTENSION_SEP);

                 if (dotPos > 0) {

                     outFile = this.fileUtils.resolveFile(destDir, xmlFile

                             .substring(0, dotPos)

                             + suffix);

                 } else {

                     outFile = this.fileUtils.resolveFile(destDir, xmlFile

                             + suffix);

                 }

                 this.log("Input file: " + inFile, Project.MSG_DEBUG);

                 this.log("Output file: " + outFile, Project.MSG_DEBUG);

                 if (this.mforce

                         || !this.fileUtils.isUpToDate(inFile, outFile)) {

                     this.fileUtils.createNewFile(outFile, true);

                     Converter.getInstance().convert(inFile, outFile,

                             this.moutType, this.context);

                 }

             } catch (final IOException ex) {

                 // If failed to process document, must delete target document,

                 // or it will not attempt to process it the second time

                 this.log("Failed to process " + inFile, Project.MSG_ERR);

                 FileUtils.delete(outFile);

                 throw new BuildException(ex);

             }

         }

     }

     /**

      * Convert string value of parameter and sets to current context.

      * 

      * @param param

      *            Type of parameter.

      * @param value

      *            String value of parameter.

      */

     private void setOption(final Parameter param, final String value) {

         this.setOption(param, param.fromString(value));

     }

     /**

      * Sets parameter for current context.

      * 

      * @param param

      *            Type of parameter.

      * @param value

      *            Object with value of parameter.

      */

     private void setOption(final Parameter param, final Object value) {

         this.logProperty(param.getOptionName(), value);

         this.context.setParameter(param, value);

     }

     /**

      * Tests if string is null or is empty.

      * 

      * @param s

      *            Tested string.

      * 

      * @return <code>true</code> if string is null or empty else

      *         <code>false</code>.

      */

     private boolean isNullOrEmpty(final String s) {

         // TODO: use .isEmpty() when JEuclid moves to 1.6

         return s == null || s.length() == 0;

     }

     /**

      * Logs property, which is sets.

      * 

      * @param param

      *            Parameter name.

      * @param value

      *            Parameter value.

      */

     private void logProperty(final String param, final Object value) {

         this.log("Sets property \"" + param + "\" with value: " + value,

                 Project.MSG_DEBUG);

     }

 }