package org.andromda.maven.plugin.cartridge;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collection;
import junit.framework.AssertionFailedError;
import junit.framework.Test;
import junit.framework.TestListener;
import org.apache.commons.io.FileUtils;

/**
 * Formats the cartridge test results into the correct format.
 *
 * @author Chad Brandon
 * @author Bob Fields
 */
public class CartridgeTestFormatter
    implements TestListener
{
    /**
     * Stores the report file location.
     */
    private File reportFile;

    /**
     * Stores the contents of the report.
     */
    private StringWriter report;

    /**
     * The print writer for the report.
     */
    private PrintWriter reportWriter;

    /**
     * Ignore test failures, just show failure messages
     */
    private boolean testFailureIgnore = false;

    /**
     *
     */
    public CartridgeTestFormatter()
    {
        this.report = new StringWriter();
        this.reportWriter = new PrintWriter(this.report);
    }

    /**
     * Sets the file that will contain the report results (i.e.
     * the results of the cartridge test run).
     *
     * @param reportFile the file to which the report output will be written.
     */
    public void setReportFile(final File reportFile)
    {
        this.reportFile = reportFile;
    }

    /**
     * Keeps track of the number of errors.
     */
    private int numberOfErrors = 0;

    /**
     * @see junit.framework.TestListener#addError(junit.framework.Test, Throwable)
     */
    public void addError(
        Test test,
        Throwable throwable)
    {
        this.numberOfErrors++;
        this.collectFailure(
            test,
            throwable);
    }

    /**
     * Keeps track of the number of failures.
     */
    private int numberOfFailures = 0;

    /**
     * @see junit.framework.TestListener#addFailure(junit.framework.Test, junit.framework.AssertionFailedError)
     */
    public void addFailure(
        Test test,
        AssertionFailedError failure)
    {
        this.numberOfFailures++;
        this.collectFailure(
            test,
            failure);
    }

    /**
     * @see junit.framework.TestListener#endTest(junit.framework.Test)
     */
    public void endTest(Test test)
    {
    }

    /**
     * Keeps track of the number of tests run.
     */
    private int numberOfTests = 0;

    /**
     * @see junit.framework.TestListener#startTest(junit.framework.Test)
     */
    public void startTest(Test test)
    {
        this.numberOfTests++;
    }

    /**
     * Stores the start time of the test suite
     */
    private long startTime = 0;

    /**
     * Stores the new line separator.
     */
    private static final String newLine = System.getProperty("line.separator");

    /**
     * The testsuite started.
     * @param name
     */
    public void startTestSuite(final String name)
    {
        startTime = System.currentTimeMillis();
        this.reportWriter.println("-------------------------------------------------------------------------------");
        this.reportWriter.println(name + " Test Suite");
        this.reportWriter.println("-------------------------------------------------------------------------------");
    }

    /**
     * Adds a failure to the current <code>failures</code>
     * collection (these are rendered at the end of test suite
     * execution).
     *
     * @param test the actual test.
     * @param throwable the failure information.
     */
    private void collectFailure(
        Test test,
        Throwable throwable)
    {
        this.failures.add(new Failure(
                test,
                throwable));
    }

    private Collection<Failure> failures = new ArrayList<Failure>();

    /**
     * Signifies the test suite ended and returns the summary of the
     * test.
     *
     * @param test the test suite being run.
     * @return the test summary.
     */
    String endTestSuite(Test test)
    {
        final double elapsed = ((System.currentTimeMillis() - this.startTime) / 1000.0);
        final StringBuilder summary = new StringBuilder("Tests: " + String.valueOf(this.numberOfTests) + ", ");
        summary.append("Failures: ").append(String.valueOf(this.numberOfFailures)).append(", ");
        summary.append("Errors: ").append(String.valueOf(this.numberOfErrors)).append(", ");
        summary.append("Time elapsed: ").append(elapsed).append(" sec");
        summary.append(newLine);
        this.reportWriter.print(summary);
        if (this.numberOfFailures > 0)
        {
            this.reportWriter.println("Failures: " + this.numberOfFailures);
            this.reportWriter.println("-------------------------------------------------------------------------------");
            int ctr = 1;
            for (final Failure failure : this.failures)
            {
                final Throwable information = failure.information;
                if (information instanceof AssertionFailedError)
                {
                    FileComparator comparator = (FileComparator)failure.test;
                    this.reportWriter.println(ctr + ") " + comparator.getActualFile());
                }
            }
            this.reportWriter.println("-------------------------------------------------------------------------------");
            this.reportWriter.println();
        }

        for (final Failure failure : this.failures)
        {
            FileComparator comparator = (FileComparator) failure.test;
            final Throwable information = failure.information;
            if (information instanceof AssertionFailedError)
            {
                this.reportWriter.println("FAILURE: " + comparator.getActualFile());
                this.reportWriter.println(failure.information.getMessage());
            }
            else
            {
                this.reportWriter.println("ERROR:");
                information.printStackTrace(this.reportWriter);
            }
            this.reportWriter.println();
        }

        if (this.reportFile != null)
        {
            try
            {
                FileUtils.writeStringToFile(this.reportFile, report.toString());
            }
            catch (IOException exception)
            {
                if (isTestFailureIgnore())
                {
                    this.reportWriter.println(exception);
                }
                else
                {
                    throw new RuntimeException(exception);
                }
            }
        }
        return summary.toString();
    }

    /**
     * Stores the information about a test failure.
     */
    private static final class Failure
    {
        Test test;
        Throwable information;

        Failure(
            final Test test,
            final Throwable information)
        {
            this.test = test;
            this.information = information;
        }
    }

    /**
     * @return the testFailureIgnore
     */
    public boolean isTestFailureIgnore()
    {
        return this.testFailureIgnore;
    }

    /**
     * @param testFailureIgnore the testFailureIgnore to set
     */
    public void setTestFailureIgnore(boolean testFailureIgnore)
    {
        this.testFailureIgnore = testFailureIgnore;
    }
}