/*
 * Util.Logger.cs
 * Authors: Adam Nabinger
 * Copyright (c) 2007-2008 Cornell University

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
using System;
using System.Diagnostics;

namespace Util
{
	/// <summary>
	/// Util.Logger class for quickly and easily writing anything to timestamped log files.
	/// Any number of loggers created with the default constructor or the copy constructor are guaranteed to be thread safe and will write all log calls to the file in the order the calls were made.
	/// All IO is done in the background, so any number of log calls will not degrade game performance.
	/// </summary>
	public sealed class Logger : IDisposable
    {
        #region Constants

        /// <summary>
        /// String constant for used for separating files in a single string
        /// </summary>
        internal const string LogSeparator = "\t";

        #endregion

        #region Fields

        // The writer used for writing out the logged events
        private readonly LogWriter MyLogWriter;

        // Whether or not the logger has been initialized
        private bool initialized;

        // Whether or not the logger has been disposed
        private bool disposed;

#if DEBUG
		/// <summary>
		/// In Debug Mode, all log output is duplicated to the console.
		/// As with writing anything to the console, this could degrade performance in debug mode.
		/// </summary>
		public static bool DEBUG_DuplicateToConsole = true;

		/// <summary>
		/// Should the loggers append to an existing file, rather than overwritting it.
		/// </summary>
		public static bool Append;

		/// <summary>
		/// Should Debug Events (those with negative event codes) be written to the log file.
		/// </summary>
		private bool writeDebugEvents = true;
#else
		/// <summary>
		/// Should the loggers append to an existing file, rather than overwritting it.
		/// </summary>
		public static bool Append = true;
#endif

		/// <summary>
		/// Should the high-precision cpu tick time stamps be written to the log files.
		/// </summary>
		public static bool WriteHighPrecisionTicks = true;

        // Whether or not writing to the parallel port has been enabled
		private readonly bool parallelPortEnabled;

        // The writer for writing out the logged events to the parallel port
		internal ParallelPortWriter parallelPortWriter;

        #endregion

        #region Properties

        /// <summary>
        /// Gets whether or not writing to the parallel port has been enabled
		/// </summary>
		public bool ParallelPortEnabled { get { return parallelPortEnabled; } }

		/// <summary>
		/// Gets whether or not the logger has been disposed
		/// </summary>
		[Obsolete("If you've disposed of the logger, you shouldn't be writing to it. This shouldn't be used, fix your code instead of checking the logger.")]
		public bool Disposed { get { return disposed; } }

		#endregion

        #region Creation

        /// <summary>
        /// Create a new logger writing to the given logFile.
        /// </summary>
        /// <param name="logFile">The file to write to.</param>
		public Logger(string logFile)
		{
			MyLogWriter = new LogWriter(logFile);
            parallelPortEnabled = Settings.ParallelPortEnabled;
		}

        /// <summary>
        /// Create a new logger writing to the given logFile, specifying parallelPortEnabled.
        /// </summary>
		/// <param name="logFile">The file to write to.</param>
        /// <param name="parallelPortEnabled">Whether or not writing to the parallel port is enabled.</param>
		public Logger(string logFile, bool parallelPortEnabled)
		{
			MyLogWriter = new LogWriter(logFile);
			this.parallelPortEnabled = parallelPortEnabled;
		}

        /// <summary>
        /// Create a new logger for writing to the same file as the given logger.
        /// </summary>
        /// <param name="logger">The logger to copy the file to write to from.</param>
		public Logger(Logger logger)
		{
#if DEBUG
			if (!logger.initialized || logger.disposed)
			{
				throw new Exception("Logger can only be cloned from an active Logger.");	
			}
#endif
			MyLogWriter = logger.MyLogWriter;
            parallelPortEnabled = logger.parallelPortEnabled;
        }

        /// <summary>
        /// Create a new logger for writing to the same file as the given logger, 
        /// specifying parallelPortEnabled.
        /// </summary>
        /// <param name="logger">The logger to copy the file to write to from.</param>
        /// <param name="parallelPortEnabled">Whether or not writing to the parallel port is enabled.</param>
		public Logger(Logger logger, bool parallelPortEnabled)
        {
#if DEBUG
			if (!logger.initialized || logger.disposed)
			{
				throw new Exception("Logger can only be cloned from an active Logger.");
			}
#endif
            MyLogWriter = logger.MyLogWriter;
			this.parallelPortEnabled = parallelPortEnabled;
        }

        #endregion

        #region Destruction

        /// <summary>
		/// A Logger should be disposed when it's finished with.
		/// This finalizer will attempt cleanup, and complain if appropriate.
		/// </summary>
		~Logger()
		{
#if DEBUG
			if (disposed || !initialized)
			{
				return;
			}
#endif
			Dispose();
#if DEBUG
			Console.WriteLine("Logger was not disposed!");
			MainGame.LogError("Logger was not disposed!");
			throw new InvalidOperationException("Logger was not disposed!");
#endif
        }

        /// <summary>
        /// Dispose this Logger and any resources it's using, Automatically flushing 
        /// any pending writes.
        /// </summary>
        public void Dispose()
        {
            if (!initialized || disposed)
            {
                return;
            }
            disposed = true;
            MyLogWriter.Dispose();
            if (parallelPortEnabled)
            {
                parallelPortWriter.Dispose();
            }
            GC.SuppressFinalize(this);
        }

        #endregion

        #region Initialization

        /// <summary>
		/// A Logger must be initialized before use.
		/// </summary>
		public void Initialize()
		{
			if (initialized || disposed)
			{
				return;
			}
			initialized = true;
			MyLogWriter.Initialize();
			if (!parallelPortEnabled)
			{
				return;
			}
			parallelPortWriter = new ParallelPortWriter();
			parallelPortWriter.Initialize();
        }

        #endregion

        #region Write

        /// <summary>
        /// Write an event code to the log, with no info text.
        /// </summary>
		/// <param name="eventCode">Numeric representation of the event code</param>
		public void Write(int eventCode)
		{
#if DEBUG
			if (!initialized || disposed)
			{
				throw new InvalidOperationException("Logger was not initialized, or was disposed.");
			}
#endif
			if (parallelPortEnabled && eventCode > 0 && (eventCode & 4294967040) == 0)
			{
				parallelPortWriter.Write((byte)eventCode);
			}
			MyLogWriter.Enqueue(new LogEvent(string.Empty, Stopwatch.GetTimestamp(), eventCode));
		}

		/// <summary>
		/// Write an event code to the log, with the given info text.
		/// </summary>
        /// <param name="eventCode">Numeric representation of the event code</param>
        /// <param name="text">Text to log.</param>
		public void Write(int eventCode, string text)
		{
#if DEBUG
			if (!initialized || disposed)
			{
				throw new InvalidOperationException("Logger was not initialized, or was disposed.");
			}
#endif
			if (parallelPortEnabled && eventCode > 0 && (eventCode & 4294967040) == 0)
			{
				parallelPortWriter.Write((byte)eventCode);
			}
			MyLogWriter.Enqueue(new LogEvent(text, Stopwatch.GetTimestamp(), eventCode));
		}

		/// <summary>
		/// Write a line of text to the log.
		/// This function will automatically timestamp and flag the message.
		/// This function will return immediately without waiting for the IO to finish.
		/// </summary>
		/// <param name="text">Text to log.</param>
		public void Write(string text)
		{
			MyLogWriter.Enqueue(new LogEvent(text, Stopwatch.GetTimestamp()));
		}

        public void Write(int code, Type eType)
        {
            MyLogWriter.Enqueue(new LogEvent(Enum.GetName(eType, code), Stopwatch.GetTimestamp(), code));
        }

        public void Write(int code, Type eType, string text)
        {
            MyLogWriter.Enqueue(new LogEvent(Enum.GetName(eType, code) + " " + text, Stopwatch.GetTimestamp(), code));
        }

		internal void Write(InputEvent e)
		{
			MyLogWriter.Enqueue(new LogEvent(string.Empty, e.Timestamp, e.EventCode));
		}

        /// <summary>
        /// Write a line of text to the log.
        /// This function will return immediately without waiting for the IO to finish.
        /// </summary>
        /// <param name="e">The input event with the time stamp and event code information</param>
        /// <param name="info">The associated information for the logged event</param>
		internal void Write(InputEvent e, string info)
		{
			MyLogWriter.Enqueue(new LogEvent(info, e.Timestamp, e.EventCode));
        }

        #endregion
    }
}