// <copyright file="DefaultTextWriterTraceListener.cs" company="Skiviez, Inc."> 
// Copyright (c) 2009 by Skiviez, Inc. All rights reserved. 
// </copyright>

namespace Skiviez.Hedgehog.Model
{
    using System;
    using System.Configuration;
    using System.Diagnostics;
    using System.Diagnostics.CodeAnalysis;
    using System.IO;
    using System.Security.Permissions;
    using System.Text;

    /// <summary>
    /// Our implementation of <see cref="TextWriterTraceListener" />. The reason we
    /// can't use Microsoft's is because they hard-coded how the initializeData
    /// filename is loaded for that class in TraceUtils. They do some magic such that
    /// it can be relative for ASP.NET Web sites, relative to the configuration file
    /// (which is what you want) and not the current working directory of the ASP.NET
    /// process (which is %SYSTEMDIR%, typically). So we do the mangling here ourselves.
    /// </summary>
    [HostProtection(SecurityAction.LinkDemand, Synchronization = true)]
    public class TextWriterTraceListener : TraceListener
    {
        /// <summary>
        /// The file name that we are writing to.
        /// </summary>
        private string fileName;

        /// <summary>
        /// Our text writer.
        /// </summary>
        private TextWriter writer;

        /// <summary>
        /// Initializes a new instance of the TextWriterTraceListener class 
        /// with TextWriter as the output recipient. 
        /// </summary>
        public TextWriterTraceListener()
        {
        }

        /// <summary>
        /// Initializes a new instance of the TextWriterTraceListener class, 
        /// using the stream as the recipient of the debugging and tracing output. 
        /// </summary>
        /// <param name="stream"> Stream that represents the stream the 
        /// TextWriterTraceListener writes to.</param>
        public TextWriterTraceListener(Stream stream) : this(stream, string.Empty)
        {
        }

        /// <summary>
        /// Initializes a new instance of the TextWriterTraceListener class 
        /// using the specified writer as recipient of the tracing or debugging 
        /// output. 
        /// </summary>
        /// <param name="writer">A TextWriter that receives the output from 
        /// the TextWriterTraceListener. </param>
        public TextWriterTraceListener(TextWriter writer) : this(writer, string.Empty)
        {
        }

        /// <summary>
        /// Initializes a new instance of the TextWriterTraceListener class, 
        /// using the file as the recipient of the debugging and tracing output. 
        /// </summary>
        /// <param name="fileName">The name of the file the 
        /// TextWriterTraceListener writes to. </param>
        public TextWriterTraceListener(string fileName)
        {
            this.fileName = MungeFileName(fileName);
        }

        /// <summary>
        /// Initializes a new instance of the TextWriterTraceListener class with
        /// the specified name, using the stream as the recipient of the 
        /// debugging and tracing output. 
        /// </summary>
        /// <param name="stream"> Stream that represents the stream the 
        /// TextWriterTraceListener writes to. </param>
        /// <param name="name">The name of the new instance. </param>
        public TextWriterTraceListener(Stream stream, string name) : base(name)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            this.writer = new StreamWriter(stream);
        }

        /// <summary>
        /// Initializes a new instance of the TextWriterTraceListener class 
        /// with the specified name, using the specified writer as recipient of
        /// the tracing or debugging output. 
        /// </summary>
        /// <param name="writer">A TextWriter that receives the output from the 
        /// TextWriterTraceListener.</param>
        /// <param name="name">The name of the new instance. </param>
        public TextWriterTraceListener(TextWriter writer, string name) : base(name)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }

            this.writer = writer;
        }

        /// <summary>
        /// Initializes a new instance of the TextWriterTraceListener class 
        /// with the specified name, using the file as the recipient of the 
        /// debugging and tracing output. 
        /// </summary>
        /// <param name="fileName">the fileName to output to</param>
        /// <param name="name">the name of the trace listener</param>
        public TextWriterTraceListener(string fileName, string name) : base(name)
        {
            this.fileName = MungeFileName(fileName);
        }

        /// <summary>
        /// Gets or sets the text writer that receives the tracing or 
        /// debugging output. 
        /// </summary>
        public TextWriter Writer
        {
            get
            {
                this.EnsureWriter();
                return this.writer;
            }

            set
            {
                this.writer = value;
            }
        }

        /// <summary>
        /// Closes the Writer so that it no longer receives tracing or 
        /// debugging output. 
        /// </summary>
        public override void Close()
        {
            if (this.writer != null)
            {
                this.writer.Close();
            }

            this.writer = null;
        }

        /// <summary>
        /// Flushes the output buffer for the Writer.
        /// </summary>
        public override void Flush()
        {
            if (this.EnsureWriter())
            {
                this.writer.Flush();
            }
        }

        /// <summary>
        /// Writes a message to this instance's Writer. 
        /// </summary>
        /// <param name="message">The message to write.</param>
        public override void Write(string message)
        {
            if (this.EnsureWriter())
            {
                if (this.NeedIndent)
                {
                    this.WriteIndent();
                }

                this.writer.Write(message);
            }
        }

        /// <summary>
        /// Writes a message to this instance's Writer followed by a line terminator. 
        /// </summary>
        /// <param name="message">The message to write.</param>
        public override void WriteLine(string message)
        {
            if (this.EnsureWriter())
            {
                if (this.NeedIndent)
                {
                    this.WriteIndent();
                }

                this.writer.WriteLine(message);
                this.NeedIndent = true;
            }
        }

        /// <summary>
        /// Disposes this TextWriterTraceListener object. 
        /// </summary>
        /// <param name="disposing">whether or not to release managed resources</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (this.writer != null)
                {
                    this.writer.Dispose();
                }

                this.Close();
            }
        }

        /// <summary>
        /// Gets an encoding with the given fallback encoding.
        /// </summary>
        /// <param name="encoding">the fallback encoding</param>
        /// <returns>the cloned encoding.</returns>
        private static Encoding GetEncodingWithFallback(Encoding encoding)
        {
            Encoding encoding2 = (Encoding)encoding.Clone();
            encoding2.EncoderFallback = EncoderFallback.ReplacementFallback;
            encoding2.DecoderFallback = DecoderFallback.ReplacementFallback;
            return encoding2;
        }

        /// <summary>
        /// Munges the file name such that if it is a relative path, we go
        /// relative from the configuration file and not from the current working
        /// directory. This makes things work as expected on ASP.NET sites and
        /// makes other applications similarly work with non-astonishing
        /// behavior.
        /// </summary>
        /// <param name="fileName">the file name to munge</param>
        /// <returns>the munged filename</returns>
        private static string MungeFileName(string fileName)
        {
            string configPath;
            string mungedFileName;

            mungedFileName = fileName;

            if (fileName[0] != Path.DirectorySeparatorChar &&
                fileName[0] != Path.AltDirectorySeparatorChar &&
                !Path.IsPathRooted(fileName))
            {
                ConfigurationSection configSection;

                configSection = (ConfigurationSection)ConfigurationManager.GetSection("system.diagnostics");
                if (configSection != null)
                {
                    configPath = configSection.ElementInformation.Source;

                    if (!string.IsNullOrEmpty(configPath))
                    {
                        string directoryName;

                        directoryName = Path.GetDirectoryName(configPath);

                        if (directoryName != null)
                        {
                            mungedFileName = Path.Combine(directoryName, fileName);
                        }
                    }
                }
            }

            return mungedFileName;
        }

        /// <summary>
        /// Ensures that a text writer exists.
        /// </summary>
        /// <returns>whether or not a text writer was created</returns>
        [SuppressMessage(
            "Microsoft.Design",
            "CA1031",
            Justification = "Generally, we don't trace config errors to bring down the app.")]
        private bool EnsureWriter()
        {
            bool flag = true;
            if (this.writer == null)
            {
                flag = false;
                if (this.fileName == null)
                {
                    return flag;
                }

                Encoding encodingWithFallback = GetEncodingWithFallback(new UTF8Encoding(false));
                string fullPath = Path.GetFullPath(this.fileName);
                string directoryName = Path.GetDirectoryName(fullPath);
                string fileName = Path.GetFileName(fullPath);
                for (int i = 0; i < 2; i++)
                {
                    try
                    {
                        this.writer = new StreamWriter(fullPath, true, encodingWithFallback, 0x1000);
                        flag = true;
                        break;
                    }
                    catch (IOException)
                    {
                        fileName = Guid.NewGuid().ToString() + fileName;
                        fullPath = Path.Combine(directoryName, fileName);
                    }
                    catch (UnauthorizedAccessException)
                    {
                        break;
                    }
                    catch (Exception)
                    {
                        break;
                    }
                }

                if (!flag)
                {
                    this.fileName = null;
                }
            }

            return flag;
        }
    }
}