/*
    * DaCapo Benchmark Maven Plugin
    * Copyright (C) 2010 Technische Universität Darmstadt
    * info@scalabench.org
    *
    * 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 org.scalabench.plugins.dacapo;
  
  import java.io.Closeable;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import java.util.Deque;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.scalabench.plugins.dacapo.config.BenchmarkConfiguration;
  import org.scalabench.plugins.dacapo.config.Description;
  import org.scalabench.plugins.dacapo.config.OutputFile;
  import org.scalabench.plugins.dacapo.config.Size;
  
  public class ConfigrationWriter {
      
      private final String name;
      
      private final BenchmarkConfiguration configuration;
      
      private final List<String> libraryJars;
      
      private final Deque<String> entrySeparators = new LinkedList<String>();
      
      private final Deque<Integer> entryCounts = new LinkedList<Integer>();
      
      private Writer out;
      
      public ConfigrationWriter(String name, BenchmarkConfiguration configuration, List<String> libraryJars) {
          this.name = name;
          this.configuration = configuration;
          this.libraryJars = libraryJars;
      }
      
      public synchronized void writeConfiguration(File file) throws IOException {
          FileOutputStream fos = null;
          out = null;
          
          try {
              fos = new FileOutputStream(file);
              out = new OutputStreamWriter(fos, "US-ASCII");
              
              writeContent();
          } finally {
              close(out);
              close(fos);
          }
      }
      
      private void writeContent() throws IOException {
          startSection(";\n");
          writeHeader();
          for (Size size : configuration.getSizes())
              writeSize(size);
          writeDescription();
          endSection(";\n");
      }
      
      private void writeHeader() throws IOException {
          writeEntry("benchmark", name);
          startSection();
          writeEntryIfPresent("class", configuration.getHarnessClass());
          writeEntryIfPresent("thread-model", configuration.getThreadModel());
          writeLibsSection();
          endSection();
      }
      
      private void writeLibsSection() throws IOException {
          if (libraryJars.isEmpty())
              return;
          
          writeEntry("libs");
          startSection(",");
          for (String libraryJar : libraryJars)
              writeQuotedEntry(libraryJar);
          endSection();
      }
      
      private void writeSize(Size size) throws IOException {
         writeEntry("size", size.getName());
         startSection();
         writeArgs(size.getArgs());
         writeEntryIfNotDefault("threads", size.getThreads(), 1);
         writeEntryIfNotDefault("thread-limit", size.getThreadLimit(), 0);
         writeOutputFiles(size.getOutputs());
         writeQuotedEntryIfPresent("description", size.getDescription());
         endSection();
     }
     
     private void writeArgs(List<String> args) throws IOException {
         writeEntry("args");
         startSection(",");
         for (String arg : args)
             writeQuotedEntry(arg);
         endSection();
     }
     
     private void writeOutputFiles(List<OutputFile> outputs) throws IOException {
         if (outputs.isEmpty())
             return;
         
         writeEntry("output");
         startSection(",");
         for (OutputFile output : outputs)
             writeOutputFile(output);
         endSection();
     }
     
     private void writeOutputFile(OutputFile output) throws IOException {
         final String textOption = output.isText() ? "text" : "binary";
         final String filterOption = output.isFilter() ? "filter" : "raw";
         
         writeQuotedEntry(output.getName());
         startSection();
         writeEntryIfPresent("digest", output.getChecksum(), textOption, filterOption);
         writeEntryIfNotDefault("lines", output.getLines(), -1);
         writeEntryIfNotDefault("bytes", output.getBytes(), -1);
         if (output.isExists()) writeEntry("exists");
         if (output.isKeep()) writeEntry("keep");
         endSection();
     }
     
     private void writeDescription() throws IOException {
         final Description description = configuration.getDescription();
         
         writeEntry("description");
         startSection(",");
         writeQuotedEntryIfPresent("short", description.getShort());
         writeQuotedEntryIfPresent("long", description.getLong());
         writeQuotedEntryIfPresent("author", description.getAuthor());
         writeQuotedEntryIfPresent("copyright", description.getCopyright());
         writeQuotedEntryIfPresent("license", description.getLicense());
         writeQuotedEntryIfPresent("url", description.getUrl());
         writeQuotedEntryIfPresent("version", description.getVersion());
         writeQuotedEntryIfPresent("threads", description.getThreads());
         writeQuotedEntryIfPresent("repeats", description.getRepeats());
         endSection();
     }
     
     private void startSection() throws IOException {
         startSection("");
     }
     
     private void startSection(String entrySeparator) throws IOException {
         if (entryCounts.size() != 0)
             out.append("\n");
         entrySeparators.push(entrySeparator);
         entryCounts.push(0);
     }
     
     private void endSection() throws IOException {
         endSection("");
     }
     
     private void endSection(String sectionTerminator) throws IOException {
         out.append(sectionTerminator);
         entrySeparators.pop();
         entryCounts.pop();
     }
     
     private void writeEntry(String value) throws IOException {
         separate();
         out.append(value);
         incrementEntryCount();
     }
     
     private void writeQuotedEntry(String value) throws IOException {
         separate();
         out.append('"').append(value).append('"');
         incrementEntryCount();
     }
     
     private void writeEntry(String name, String value, String... options) throws IOException {
         separate();
         out.append(name);
         if (options.length != 0) {
             out.append('(').append(options[0]);
             for (int i = 1; i < options.length; i++)
                 out.append(',').append(' ').append(options[i]);
             out.append(')');
         }
         out.append(' ').append(value);
         incrementEntryCount();
     }
     
     private void writeQuotedEntry(String name, String value) throws IOException {
         separate();
         out.append(name).append(' ').append('"').append(value).append('"');
         incrementEntryCount();
     }
     
     private void writeEntryIfPresent(String name, String value, String... options) throws IOException {
         if (value != null) writeEntry(name, value, options);
     }
     
     private void writeQuotedEntryIfPresent(String name, String value) throws IOException {
         if (value != null) writeQuotedEntry(name, value);
     }
     
     private void writeEntryIfNotDefault(String name, int value, int defaultValue) throws IOException {
         if (value != defaultValue) writeEntry(name, Integer.toString(value));
     }
     
     private void separate() throws IOException {
         if (entryCounts.peek() > 0)
             out.append(entrySeparators.peek()).append('\n');
         indent();
     }
     
     private void indent() throws IOException {
         for (int i = 0; i < entryCounts.size() - 1; i++)
             out.append("    ");
     }
     
     private void incrementEntryCount() {
         entryCounts.push(entryCounts.pop() + 1);
     }
     
     private static void close(Closeable closeable) throws IOException {
         if (closeable != null)
             closeable.close();
     }
 }