package org.andromda.core.common;

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.apache.log4j.Logger;

/**
 * <p>
 * ExceptionRecorder provides a function to record an exception to a file along with the trace data if active. </p>
 *
 * @author Martin West
 * @author Bob Fields
 */
public final class ExceptionRecorder
{
    private static final Logger logger = Logger.getLogger(ExceptionRecorder.class);

    /**
     * File header constant
     */
    static final String FILE_HEADER = "------- AndroMDA Exception Recording -------";

    /**
     * Run line system constant
     */
    static final String RUN_SYSTEM = "Run System .....: ";

    /**
     * Run line jdk constant
     */
    static final String RUN_JDK = "Run JDK ........: ";

    /**
     * Information not available constant
     */
    static final String INFORMATION_UNAVAILABLE = " unavailable";

    /**
     * The exceptions directory name:exceptions.
     */
    private static final String exceptionDirectoryName = ".";

    /**
     * The exceptions directory, initialized to exceptions.
     */
    private static File exceptionDirectory = null;
    private static final SimpleDateFormat cvDateFormat = new SimpleDateFormat("yyMMddHHmmss");
    private static final Random random = new Random();

    /**
     * The shared instance.
     */
    private static final ExceptionRecorder instance = new ExceptionRecorder();

    /**
     * Private constructor, this class is not intended to be instantiated.
     */
    private ExceptionRecorder()
    {
        // Not intended to be instantiated
    }

    /**
     * Gets the shared instance of the ExceptionRecorder.
     *
     * @return the shared ExceptionRecorder instance.
     */
    public static ExceptionRecorder instance()
    {
        return instance;
    }

    /**
     * <p>
     * Writes out the exception to a file along with trace data if active. The file name is of the form sYYMMDDHHMMSS
     * (_nn).exc where YY..SS is the timestamp (_nn) is an ascending sequence number when multiple exceptions occur in
     * the same second. Returns the filename of the generated exception report. </p>
     *
     * @param throwable to record.
     * @return record("", throwable, "S")
     */
    public String record(Throwable throwable)
    {
        return record("", throwable, "S");
    }

    /**
     * <p>
     * Writes out the exception to a file along with trace data if active. The file name is of the form sYYMMDDHHMMSS
     * (_nn).exc where YY..SS is the timestamp (_nn) is an ascending sequence number when multiple exceptions occur in
     * the same second. Returns the filename of the generated exception report. </p>
     *
     * @param errorMessage to log with the exception report.
     * @param throwable    to record.
     * @return record(errorMessage, throwable, "S")
     */
    public String record(
        String errorMessage,
        Throwable throwable)
    {
        return record(errorMessage, throwable, "S");
    }

    /**
     * The default prefix given, if prefix in {@link #record(String, Throwable, String) is null}.
     */
    private static final String DEFAULT_PREFIX = "andromda";

    /**
     * <p>
     * Writes out the exception to a file along with trace data if active. The file name is of the form sYYMMDDHHMMSS
     * (_nn).exc where YY..SS is the timestamp <_nn>is an ascending sequence number when multiple exceptions occur in
     * the same second. </p>
     *
     * @param message   diagnostic message
     * @param throwable exception to record.
     * @param prefix    for the file name.
     * @return result string
     */
    public String record(
        String message,
        Throwable throwable,
        String prefix)
    {
        String result = null;
        if (StringUtils.isEmpty(prefix))
        {
            prefix = DEFAULT_PREFIX;
        }
        try
        {
            final BuildInformation buildInformation = BuildInformation.instance();
            final String uniqueName = getUniqueName(prefix);
            final File exceptionFile = new File(exceptionDirectory, uniqueName);
            result = exceptionFile.getCanonicalPath();
            final PrintWriter writer = new PrintWriter(new FileWriter(exceptionFile));
            writer.println(FILE_HEADER);
            writer.println("Version ........: " + buildInformation.getBuildVersion());
            writer.println("Error ..........: " + message);
            writer.println("Build ..........: " + buildInformation.getBuildDate());
            writer.println("Build System ...: " + buildInformation.getBuildSystem());
            writer.println("Build JDK ......: " + buildInformation.getBuildJdk());
            writer.println("Build Builder ..: " + buildInformation.getBuildBuilder());

            // Place in try/catch in case system is protected.
            try
            {
                writer.println(RUN_SYSTEM + System.getProperty("os.name") + System.getProperty("os.version"));
                writer.println(RUN_JDK + System.getProperty("java.vm.vendor") + System.getProperty("java.vm.version"));
            }
            catch (Exception ex)
            {
                // ignore
                writer.println(RUN_SYSTEM + INFORMATION_UNAVAILABLE);
                writer.println(RUN_JDK + INFORMATION_UNAVAILABLE);
            }
            writer.println("Main Exception .: " + throwable.getMessage());
            Throwable cause = ExceptionUtils.getRootCause(throwable);
            if (cause == null)
            {
                cause = throwable;
            }
            writer.println("Root Exception .: " + cause);
            cause.printStackTrace(writer);
            writer.close();
            AndroMDALogger.error("Exception recorded in --> '" + result + '\'');
        }
        catch (Throwable th)
        {
            final String errorMessage = "ExceptionRecorder.record error recording exception --> '" + throwable + '\'';
            logger.error(errorMessage, th);
        } // End catch
        return result;
    } // end of method record

    /**
     * The suffix to give the recorded exception files.
     */
    private static final String SUFFIX = ".exc";

    /**
     * Gets a unique file name.
     * @param prefix
     * @return uniqueName
     * @concurrency guarded
     */
    protected synchronized String getUniqueName(String prefix)
    {
        String uniqueName = prefix + cvDateFormat.format(new Date()) + SUFFIX;
        int suffix = 0;
        File exceptionFile = new File(exceptionDirectory, uniqueName);
        while (exceptionFile.exists())
        {
            uniqueName = prefix + cvDateFormat.format(new Date()) + '_' + suffix++ + SUFFIX;
            exceptionFile = new File(exceptionDirectory, uniqueName);

            // Give another user an opportunity to
            // grab a file name. Use a random delay to
            // introduce variability
            try
            {
                Thread.sleep(Math.abs(random.nextInt() % 100));
            }
            catch (InterruptedException e1)
            {
                // ignore
            }
        } // end while

        // Grab the file name, there is a window when we
        // are writing the file, that some one else in
        // a different VM could get the same file name.
        try
        {
            RandomAccessFile file;
            file = new RandomAccessFile(exceptionFile, "rw");
            file.writeChar('t');
            file.close();
        }
        catch (Exception ex)
        {
            // ignore
        }
        return uniqueName;
    } // end method getUniqueName

    static
    {
        /* initialize the exceptionDirectory */
        try
        {
            exceptionDirectory = new File(exceptionDirectoryName);
            if (!exceptionDirectory.exists())
            {
                exceptionDirectory.mkdir();
            }
        }
        catch (Throwable th)
        {
            // ignore
        }
        finally
        {
            if (exceptionDirectory == null)
            {
                exceptionDirectory = new File(".");
            }
        }
    }

    /**
     * Returns the directory to which the exceptions are written.
     *
     * @return the exception directory as a java.io.File instance.
     */
    public File getExceptionDirectory()
    {
        return exceptionDirectory;
    }
}