/*
    * Copyright 2011-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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.
   */
  package de.smartics.maven.recode;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import org.apache.maven.plugin.logging.Log;
  
  import org.apache.commons.io.IOUtils;
  import org.codehaus.plexus.util.DirectoryScanner;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * Utility class to recode files in a folder.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  class Recoder
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The logger to use. May be <code>null</code> if no logging is requested.
     */
    private final Log log;
  
    /**
     * The descriptor of the resources to be recoded.
     */
    private final Resources resource;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param log the logger to use. May be <code>null</code> if no logging is
     *          requested.
     * @param resource the descriptor of the resources to be recoded.
     */
    Recoder(final Log log, final Resources resource)
    {
      this.log = log;
      this.resource = resource;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Starts recoding the resources of this recoder.
     *
     * @throws IOException if any resource recoding fails.
     */
    void recode() throws IOException
    {
      final File baseDir = resource.getDir();
      if (baseDir != null && baseDir.exists())
      {
        final DirectoryScanner scanner = createScanner(resource);
        for (final String includedFilePath : scanner.getIncludedFiles())
        {
          final File file = new File(baseDir, includedFilePath);
          recode(file);
        }
      }
     else
     {
       log.info("Skipping recode for folder '" + baseDir.getAbsolutePath()
                + "', since it does not exist.");
     }
   }
 
   /**
    * Creates the scanner with the calculated includes and excludes.
    *
    * @return the scanner with the calculated includes and excludes.
    */
   DirectoryScanner createScanner(final Resources resource)
   {
     final DirectoryScanner scanner = new DirectoryScanner();
 
     scanner.setBasedir(resource.getDir());
     scanner.setCaseSensitive(true);
     scanner.setIncludes(resource.getIncludes());
     scanner.setExcludes(resource.getExcludes());
 
     scanner.scan();
 
     return scanner;
   }
 
   void recode(final File file) throws IOException
   {
     if (log != null)
     {
       log.info(" Recoding file " + resource.getSourceEncoding() + "->"
                + resource.getTargetEncoding() + ": " + file.getAbsolutePath());
     }
     String fileContent = readContent(file);
     fileContent = translate(fileContent);
     writeContent(file, fileContent);
     if (log != null)
     {
       log.info(" File recoded: " + file.getAbsolutePath());
     }
   }
 
   private String readContent(final File file) throws FileNotFoundException,
     IOException
   {
     InputStream inputStream = null;
 
     try
     {
       inputStream = new FileInputStream(file);
       final String fileContent =
           IOUtils.toString(inputStream, resource.getSourceEncoding());
       return fileContent;
     }
     finally
     {
       IOUtils.closeQuietly(inputStream);
     }
   }
 
   private String translate(final String fileContent)
   {
     if (resource.isFromDos())
     {
       return StringUtils.replace(fileContent, "\r\n", "\n");
     }
     return fileContent;
   }
 
   private void writeContent(final File file, final String fileContent)
     throws IOException
   {
     Writer writer = null;
 
     try
     {
       writer =
           new OutputStreamWriter(new FileOutputStream(file),
               resource.getTargetEncoding());
       IOUtils.write(fileContent, writer);
     }
     finally
     {
       IOUtils.closeQuietly(writer);
     }
   }
 
   // --- object basics --------------------------------------------------------
 
 }