/*
 *  The Syncro Soft SRL License
 *
 *  Copyright (c) 1998-2005 Syncro Soft SRL, Romania.  All rights
 *  reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistribution of source or in binary form is allowed only with
 *  the prior written permission of Syncro Soft SRL.
 *
 *  2. Redistributions of source code must retain the above copyright
 *  notice, this list of conditions and the following disclaimer.
 *
 *  3. Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in
 *  the documentation and/or other materials provided with the
 *  distribution.
 *
 *  4. The end-user documentation included with the redistribution,
 *  if any, must include the following acknowledgment:
 *  "This product includes software developed by the
 *  Syncro Soft SRL (http://www.sync.ro/)."
 *  Alternately, this acknowledgment may appear in the software itself,
 *  if and wherever such third-party acknowledgments normally appear.
 *
 *  5. The names "Oxygen" and "Syncro Soft SRL" must
 *  not be used to endorse or promote products derived from this
 *  software without prior written permission. For written
 *  permission, please contact contact@sync.ro.
 *
 *  6. Products derived from this software may not be called "Oxygen",
 *  nor may "Oxygen" appear in their name, without prior written
 *  permission of the Syncro Soft SRL.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 *  ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 *  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 *  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 *  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 */
import java.io.BufferedReader;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.Reader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Converts a classed DITA CSS to a simplified CSS that aplies directly on the elements.
 */
public class DitaCSSGenerator {

  /**
   * Main method.
   * @param args Arguments. First the input directory, then the output directory. If the output directory does
   * not exist then it creates it.
   */
  public static void main(String[] args) {
    try {
      if(args.length != 2) {
        System.out.println("Arguments:\n " +
            "inDir Input directory containing the classed CSS files\n " +
            "outDir Output directory where to place the unclassed CSS filles.");
        
      } else {
        File inDir = new File(args[0]);      
        File outDir = new File(args[1]);
        
        if(!outDir.exists()) {
          System.out.println("Creating the output directory: " + outDir);
          outDir.mkdirs();          
        } else {
          System.out.println("Output to an existing directory:"  + outDir);          
        }
        
        // Get all the CSS files.
        File[] inCssFiles = inDir.listFiles(new FileFilter() {      
          public boolean accept(File file) {
             return file.isFile() && file.getName().endsWith(".css");
          }      
        });
        

        // Regexp.
        // Converting *[class="dita/element"] to element        
        String regexp =  "\\*\\[class~=\"(.*?)/(.*?)\"]";
        Pattern pattern = Pattern.compile(regexp);

        // Process each one.
        for (int i = 0; i < inCssFiles.length; i++) {
          File in = inCssFiles[i];
          
          System.out.println("Processing file: " + in);
          
          // Read the content.
          String content = read(in);
          Matcher matcher = pattern.matcher(content);          
          while (matcher.find()) {
              System.out.println("Found " + matcher.group(2));
              
              int st = matcher.start();
              int en = matcher.end();
              
              StringBuffer res = new StringBuffer();
              res.append(content.substring(0, st));
              res.append(matcher.group(2));
              res.append(content.substring(en, content.length()));

              content = res.toString();
              matcher = pattern.matcher(content);
          };
          
          File out = new File(outDir, in.getName());
          System.out.println("Writing file: " + out);
          FileOutputStream fos = new FileOutputStream(out);
          fos.write(
              ("/* GENERATED FILE. DO NOT EDIT. */\n" + 
              "/* EDIT THE CLASSED FILE AND THEN REGENERATE USING THE CONVERT SCRIPT*/\n\n").getBytes("UTF-8"));
          fos.write(content.getBytes("UTF-8"));
          fos.close();
        }
        System.out.println("Done");
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  /**
   * Reads a file assumming UTF-8 encoding.
   * 
   * @param in The file to be read.
   * @return The text content.
   * @throws IOException 
   */
  private static String read(File in) throws IOException {
    Reader reader = new BufferedReader(new java.io.InputStreamReader(new FileInputStream(in), "UTF-8"));    
    int ch;
    StringBuffer buf = new StringBuffer();
    while((ch = reader.read()) != -1) {
      buf.append((char)ch);      
    }
    reader.close();
    return buf.toString();
  }

}

