//-----------------------------------------------------------------------
// <copyright file="Trace.cs" company="Craig Sutherland">
//     Copyright (c) 2009 Craig Sutherland. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------

namespace FastForward.WinCore
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using NLog;
    using System.Threading;
    using System.Diagnostics;

    /// <summary>
    /// Provides tracing functionality.
    /// </summary>
    public class Trace
        : IDisposable
    {
        #region Private fields
        #region logFactory
        /// <summary>
        /// The <see cref="LogFactory"/> to use in initialising new loggers.
        /// </summary>
        private static LogFactory logFactory = new LogFactory();
        #endregion

        #region currentId
        /// <summary>
        /// The currently available identifier.
        /// </summary>
        private static int currentId = 0;
        #endregion

        #region logger
        /// <summary>
        /// The logger to use.
        /// </summary>
        private Logger logger;
        #endregion

        #region id
        /// <summary>
        /// The id of the current trace.
        /// </summary>
        private int id;
        #endregion

        #region hasFinished
        /// <summary>
        /// Has this trace finished yet?
        /// </summary>
        private bool hasFinished;
        #endregion
        #endregion

        #region Constructors
        /// <summary>
        /// Initialise a new <see cref="BuildQueueTreeNode"/>.
        /// </summary>
        /// <param name="logger">The logger to use.</param>
        /// <param name="id">The identifier of the trace.</param>
        private Trace(Logger logger, int id)
        {
            this.logger = logger;
            this.id = id;
        }
        #endregion

        #region Public properties
        #region MethodName
        /// <summary>
        /// The method being traced.
        /// </summary>
        public string MethodName { get; set; }
        #endregion
        #endregion

        #region Public methods
        #region Start()
        /// <summary>
        /// Starts a new trace event.
        /// </summary>
        /// <param name="description">The description of the trace event.</param>
        /// <returns>The new <see cref="Trace"/> instance.</returns>
        public static Trace Start(string description)
        {
            var newId = Interlocked.Increment(ref Trace.currentId);
            var logger = Trace.logFactory.GetLogger("Trace.Logger");
            var trace = new Trace(logger, newId);

            if (logger.IsTraceEnabled)
            {
                var frame = new StackFrame(1);
                var method = frame.GetMethod();
                trace.MethodName = method.DeclaringType.FullName + "." + method.Name;
                var message = newId.ToString("00000") +
                    "->" +
                    trace.MethodName +
                    " start: " +
                    description ?? string.Empty;
                logger.Trace(message);
            }

            return trace;
        }
        #endregion

        #region Finish()
        /// <summary>
        /// Finishes a trace.
        /// </summary>
        public void Finish()
        {
            this.hasFinished = true;
            if (this.logger.IsTraceEnabled)
            {
                var message = this.id.ToString("00000") + "->" + this.MethodName + " end";
                this.logger.Trace(message);
            }
        }
        #endregion

        #region Dispose()
        /// <summary>
        /// Clean up and end the trace.
        /// </summary>
        public void Dispose()
        {
            if (!hasFinished)
            {
                this.Finish();
            }
        }
        #endregion
        #endregion
    }
}