/**

  * Copyright (c) 2012, University of Konstanz, Distributed Systems Group

  * All rights reserved.

  * 

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions are met:

  * * Redistributions of source code must retain the above copyright

  * notice, this list of conditions and the following disclaimer.

  * * 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.

  * * Neither the name of the University of Konstanz nor the

  * names of its contributors may be used to endorse or promote products

  * derived from this software without specific prior written permission.

  * 

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

  * ANY EXPRESS 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 <COPYRIGHT HOLDER> 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.

  */

 package org.perfidix.ouput;

 import java.io.File;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.PrintStream;

 import java.lang.reflect.Method;

 import java.util.Hashtable;

 import java.util.Map;

 import org.perfidix.exceptions.AbstractPerfidixMethodException;

 import org.perfidix.meter.AbstractMeter;

 import org.perfidix.result.BenchmarkResult;

 import org.perfidix.result.ClassResult;

 import org.perfidix.result.MethodResult;

 /**

  * Getting out the raw-data as csv.

  * 

  * @author Sebastian Graf, University of Konstanz

  */

 public final class CSVOutput extends AbstractOutput {

     /**

      * Separator to distinguish between class, meter and method.

      */

     private static final String SEPARATOR = "-";

     /** Print stream where the result should end. */

     private transient final File folder;

     /**

      * Flag for correct commata for results.

      */

     private transient boolean firstResult;

     /**

      * Flag for correct commata for exceptions.

      */

     private transient boolean firstException;

     /**

      * Set for deleting old files in the beginning.

      */

     private transient final Map<File, PrintStream> usedFiles;

     /**

      * Constructor for piping the result to elsewhere.

      * 

      * @param paramFolder

      *            an {@link File} object which has to be a folder to write to

      */

     public CSVOutput(final File paramFolder) {

         super();

         folder = paramFolder;

         if (folder != null && !folder.isDirectory()) {

             throw new IllegalStateException(new StringBuilder(paramFolder.toString()).append(

                 " has to be a folder!").toString());

         }

         firstResult = true;

         firstException = true;

         usedFiles = new Hashtable<File, PrintStream>();

     }

     /**

      * Constructor for output to {@link System#out}.

      */

     public CSVOutput() {

         this(null);

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public boolean listenToResultSet(final Method meth, final AbstractMeter meter, final double data) {

         final PrintStream stream =

             setUpNewPrintStream(false, meth.getDeclaringClass().getSimpleName(), meth.getName(), meter

                 .getName());

         if (!firstResult) {

             stream.append(",");

         }

         stream.append(Double.toString(data));

         stream.flush();

         firstResult = false;

         return true;

     }

     /** {@inheritDoc} */

     @Override

     public boolean listenToException(final AbstractPerfidixMethodException exec) {

         final PrintStream currentWriter = setUpNewPrintStream(false, "Exceptions");

         if (!firstException) {

             currentWriter.append("\n");

         }

         currentWriter.append(exec.getRelatedAnno().getSimpleName());

         currentWriter.append(",");

         if (exec.getMethod() != null) {

             currentWriter.append(exec.getMethod().getDeclaringClass().getSimpleName());

             currentWriter.append("#");

             currentWriter.append(exec.getMethod().getName());

             currentWriter.append(",");

         }

         exec.getExec().printStackTrace(currentWriter);

         currentWriter.flush();

         firstException = false;

         return true;

     }

     /** {@inheritDoc} */

     @Override

     public void visitBenchmark(final BenchmarkResult res) {

         // Printing the data

         for (final ClassResult classRes : res.getIncludedResults()) {

             for (final MethodResult methRes : classRes.getIncludedResults()) {

                 for (final AbstractMeter meter : methRes.getRegisteredMeters()) {

                     final PrintStream currentWriter =

                         setUpNewPrintStream(true, classRes.getElementName(), methRes.getElementName(), meter

                             .getName());

                     boolean first = true;

                     for (final Double d : methRes.getResultSet(meter)) {

                         if (first) {

                             currentWriter.append(d.toString());

                             first = false;

                         } else {

                             currentWriter.append(new StringBuilder(",").append(d.toString()).toString());

                         }

                     }

                     currentWriter.flush();

                 }

             }

         }

         // Printing the exceptions

         final PrintStream currentWriter = setUpNewPrintStream(true, "Exceptions");

         for (final AbstractPerfidixMethodException exec : res.getExceptions()) {

             currentWriter.append(exec.getRelatedAnno().getSimpleName());

             if (exec.getMethod() != null) {

                 currentWriter.append(":");

                 currentWriter.append(exec.getMethod().getDeclaringClass().getSimpleName());

                 currentWriter.append("#");

                 currentWriter.append(exec.getMethod().getName());

             }

             currentWriter.append("\n");

             exec.getExec().printStackTrace(currentWriter);

         }

         currentWriter.flush();

         tearDownAllStreams();

     }

     private void tearDownAllStreams() {

         for (final PrintStream stream : usedFiles.values()) {

             stream.close();

         }

     }

     /**

      * Setting up a new {@link PrintStream}.

      * 

      * @param visitorStream

      *            is the stream for the visitor? Because of line breaks after

      *            the results.

      * @param names

      *            the elements of the filename

      * @return a {@link PrintStream} instance

      * @throws FileNotFoundException

      *             if something goes wrong with the file

      */

     private PrintStream setUpNewPrintStream(final boolean visitorStream, final String... names) {

         PrintStream out = System.out;

         if (folder == null) {

             if (visitorStream) {

                 out.println();

             }

         } else {

             final File toWriteTo = new File(folder, buildFileName(names));

             try {

                 if (usedFiles.containsKey(toWriteTo)) {

                     out = usedFiles.get(toWriteTo);

                 } else {

                     toWriteTo.delete();

                     out = new PrintStream(new FileOutputStream(toWriteTo, !visitorStream));

                     usedFiles.put(toWriteTo, out);

                     firstResult = true;

                 }

             } catch (final FileNotFoundException e) {

                 throw new IllegalStateException(e);

             }

         }

         return out;

     }

     /**

      * Helper method to build suitable fileNames.

      * 

      * @param names

      *            different names to be combined

      * @return a String for a suitable file name

      */

     private String buildFileName(final String... names) {

         final StringBuilder builder = new StringBuilder();

         for (int i = 0; i < names.length; i++) {

             builder.append(names[i]);

             if (i < names.length - 1) {

                 builder.append(SEPARATOR);

             }

         }

         builder.append(".").append("csv");

         return builder.toString();

     }

 }