//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.Diagnostics;
using System.Reflection;
using System.IO;
using OpenTap.Diagnostic;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;

namespace OpenTap
{
    /// <summary>
    /// Identifies the type of event that is logged.
    /// </summary>
    public enum LogEventType
    {
        /// <summary>
        ///     Recoverable error.
        /// </summary>
        Error = 10,
        /// <summary>
        ///     Noncritical problem.
        /// </summary>
        Warning = 20,
        /// <summary>
        ///     Informational message.
        /// </summary>
        Information = 30,
        /// <summary>
        ///     Debugging trace.
        /// </summary>
        Debug = 40
    }

    /// <summary>
    /// Encapsulates the features of the OpenTAP logging infrastructure.
    /// </summary>
    public class TraceSource
    {
        internal ILog log;

        /// <summary> The object that owns this trace source. </summary>
        internal object Owner;
        internal TraceSource(ILog logSource)
        {
            log = logSource;
        }

        LogContext.LogInjector redirectedLog => Log.RedirectedLog;

        /// <summary>
        /// Blocks until all messages posted up to this point have reached all TraceListeners.  
        /// </summary>
        public void Flush()
        {
            Log.Flush();
        }

        /// <summary>
        /// Register a single event.
        /// </summary>
        public void TraceEvent(LogEventType te, int id, string message)
        {
            
            if (message == null)
                throw new ArgumentNullException(nameof(message));
            if(redirectedLog != null)
                redirectedLog.LogEvent(log.Source, (int)te, message);
            else
                log.LogEvent((int)te, message);
        }

        /// <summary> Register a single event with formatting and duration. </summary>
        public void TraceEvent(long durationNs, LogEventType te, int id, string message, params object[] args)
        {
            if(redirectedLog != null)
                redirectedLog.LogEvent(log.Source, (int)te, durationNs, message, args);
            else
                log.LogEvent((int)te, durationNs, message, args);
        }
        
        /// <summary> Register a single event without formatting and duration. </summary>
        public void TraceEvent(long durationNs, LogEventType te, int id, string message)
        {
            // this overload is important since otherwise the logging system will use 
            // the overload with [args] even though there are none. And that can give
            // problems if the message itself contains formatting demarcations e.g '{0}'
            if (redirectedLog != null)
                redirectedLog.LogEvent(log.Source, (int)te, durationNs, message);
            else
                log.LogEvent((int)te, durationNs, message);
        }

        /// <summary>
        /// Register a single event with formatting
        /// </summary>
        public void TraceEvent(LogEventType te, int id, string message, params object[] args)
        {
            if (message == null)
                throw new ArgumentNullException(nameof(message));
            if (args == null)
                throw new ArgumentNullException(nameof(args));
            if(redirectedLog != null)
                redirectedLog.LogEvent(log.Source, (int)te, message, args);
            else
                log.LogEvent((int)te, message, args);
        }
    }

    /// <summary>
    /// Base class for various listeners.
    /// </summary>
    public class TraceListener : ILogListener
    {
        void ILogListener.EventsLogged(IEnumerable<Event> events)
        {
            TraceEvents(events);
        }

        /// <summary>
        /// Receives all log messages. The virtual method simply calls <see cref="TraceEvent(string, LogEventType, int, string)"/> directly.  
        /// </summary>
        public virtual void TraceEvents(IEnumerable<Event> events)
        {
            foreach (var evt in events)
                TraceEvent(evt.Source, (LogEventType)evt.EventType, 0, evt.Message);
        }

        /// <summary>
        /// Empty TraceEvent method.
        /// </summary>
        public virtual void TraceEvent(string source, LogEventType eventType, int id, string format)
        {
        }

        /// <summary>
        /// Empty TraceEvent method.
        /// </summary>
        public virtual void TraceEvent(string source, LogEventType eventType, int id, string format, params object[] args)
        {
            TraceEvent(source, eventType, id, string.Format(format, args));
        }

        /// <summary>
        /// Virtual method to match System.Diagnostics.TraceListener. Might be removed.
        /// </summary>
        public virtual void Write(string str)
        {
        }

        /// <summary>
        /// Virtual method to match System.Diagnostics.TraceListener. Might be removed.
        /// </summary>
        public virtual void WriteLine(string str)
        {
        }

        /// <summary>
        /// Waits until all sent log messages have been processed by this and all other TraceListeners.
        /// </summary>
        public virtual void Flush()
        {
            Log.Flush();
        }
    }

    /// <summary>
    /// Simple TraceListener which outputs data to a TextWriter.
    /// </summary>
    class TextWriterTraceListener : TraceListener, IDisposable
    {
        private TextWriter writer;

        readonly object lockObject = new object();

        /// <summary>
        /// The writer that is used as the output.
        /// </summary>
        public TextWriter Writer
        {
            get => writer;
            set
            {
                if (writer != value)
                {
                    lock(lockObject)
                        writer = value;
                }
            }
        }

        /// <summary>
        /// Creates a new TextWriterTraceListener writing to the given filename.
        /// </summary>
        public TextWriterTraceListener(string filename)
            : this(new FileStream(filename, FileMode.Append))
        {
        }

        /// <summary>
        /// Creates a new TextWriterTraceListener writing to the given stream.
        /// </summary>
        public TextWriterTraceListener(Stream stream)
        {
            Writer = new StreamWriter(stream);
        }

        /// <summary>
        /// Writes a string to the current Writer.
        /// </summary>
        public override void Write(string message)
        {
            lock(lockObject)
                Writer.Write(message);
        }

        /// <summary>
        /// Writes a string including a newline to the current Writer.
        /// </summary>
        public override void WriteLine(string message)
        {
            lock(lockObject)
                Writer.WriteLine(message);
        }

        /// <summary>
        /// Flushes the log system and the current Writer.
        /// </summary>
        public override void Flush()
        {
            base.Flush();
            lock(lockObject) 
                writer.Flush();
        }

        /// <summary>
        /// Frees up the writer.
        /// </summary>
        public void Dispose()
        {
            lock(lockObject)
            {
                if (writer != null)
                {
                    writer.Close();
                    writer = null;
                }
            }
        }
    }

    /// <summary>
    /// This class extends System.Diagnostics.Log to provide shorthand methods 
    /// for logging/tracing messages at different levels.
    /// </summary>
    public static class Log
    {
        static readonly LogContext rootLogContext = (LogContext)LogFactory.CreateContext();

        internal static ILogTimestampProvider Timestamper
        {
            get => rootLogContext.Timestamper;
            set => rootLogContext.Timestamper = value;
        }

        static readonly SessionLocal<LogContext.LogInjector> logField = new SessionLocal<LogContext.LogInjector>(null);
        static readonly SessionLocal<LogContext> sessionLogContext = new SessionLocal<LogContext>(rootLogContext);

        internal static void WithNewContext()
        {
            var ctx = new LogContext();
            
            logField.Value = new LogContext.LogInjector(ctx);
            sessionLogContext.Value = ctx;
        }

        internal static LogContext.LogInjector RedirectedLog => logField.Value;

        /// <summary> The current log context. </summary>
        public static ILogContext Context => sessionLogContext.Value;

        /// <summary> Makes a TraceListener start receiving log messages. </summary>
        /// <param name="listener">The TraceListener to add.</param>
        public static void AddListener(ILogListener listener)
        {
            if (listener == null)
                throw new ArgumentNullException(nameof(listener));
            var ctx = Context;
            ctx.Flush();
            ctx.AttachListener(listener);
        }
        
        /// <summary> Stops a specified TraceListener from receiving log messages. </summary>
        /// <param name="listener">The TraceListener to remove.</param>
        public static void RemoveListener(ILogListener listener)
        {
            if (listener == null)
                throw new ArgumentNullException(nameof(listener));
            var ctx = Context;
            listener.Flush();
            ctx.DetachListener(listener);
            listener.Flush();
        }
        /// <summary>
        /// Gets all added TraceListeners.
        /// </summary>
        /// <returns>A readonly collection of TraceListeners.</returns>
        public static ReadOnlyCollection<ILogListener> GetListeners()
        {
            return sessionLogContext.Value?.GetListeners();
        }
        /// <summary> Creates a new log source. </summary>
        /// <param name="name">The name of the Log.</param>
        /// <returns>The created Log.</returns>
        public static TraceSource CreateSource(string name)
        {
            return new TraceSource(rootLogContext.CreateLog(name));
        }

        // ConditionalWeakTable keys does not count as a reference and are automatically removed on GC. This way we avoid leak. CWT's are thread safe.
        static readonly System.Runtime.CompilerServices.ConditionalWeakTable<object, TraceSource> ownedTraceSources = new System.Runtime.CompilerServices.ConditionalWeakTable<object, TraceSource>();
        static readonly object addlock = new object();
        /// <summary> Creates a new owned log source. Note that any given object can only have one owned TraceSource.</summary>
        /// <param name="name">The name of the Log.</param>
        /// <param name="owner">The object owning the log. This is used to enable OpenTAP to emit log messages on behalf of the owner object. </param>
        /// <returns>The created Log.</returns>
        public static TraceSource CreateSource(string name, object owner)
        {
            if (owner == null)
                throw new ArgumentNullException(nameof(owner));
            var source = CreateSource(name);
            source.Owner = owner;
            lock (addlock)
            {
                ownedTraceSources.Remove(owner);
                ownedTraceSources.Add(owner, source); // in this version of .NET there is no Update method...
            }
            return source;
        }
        
        /// <summary> Gets the source of a specified owner. </summary>
        /// <param name="owner"></param>
        /// <returns>returns the TraceSource or null if the owner owns no source.</returns>
        public static TraceSource GetOwnedSource(object owner)
        {
            if (owner == null)
                throw new ArgumentNullException(nameof(owner));
            lock (addlock)
            {
                ownedTraceSources.TryGetValue(owner, out TraceSource source);
                return source;
            }
        }

        /// <summary>
        /// Removes a previously Created Log from the list of sources.
        /// </summary>
        /// <param name="source"></param>
        public static void RemoveSource(TraceSource source)
        {
            if (source == null)
                throw new ArgumentNullException(nameof(source));
            rootLogContext.RemoveLog(source.log);
        }

        static Log()
        {
            // This improves performance by disabling a critical region that the .NET framework 
            // would otherwise put around writing to _all_ listeners. With UseGlobalLock set to 
            // false instead, a critical region will only be put around each listener individually 
            // and only if they have IsThreadSafe=false. UseGlobalLock=false is also required to
            // prevent a deadlock when using the Log Breaking feature in the GUI.
            Trace.UseGlobalLock = false;

            rootLogContext.Async = true;
            rootLogContext.MessageBufferSize = 8 * 1024 * 1024;
        }

        // Performance: Reuse the string build each time to avoid generating GC pressure.
        [ThreadStatic]
        static StringBuilder sb;

        /// <summary>
        /// like traceEvent except it uses a stopwatch 'timer' to write formatted time after the message [{1:0}ms].
        /// Usually used to signal in the log how long an operation took.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="elapsed"></param>
        /// <param name="eventType"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        static void traceEvent(this TraceSource trace, TimeSpan elapsed, LogEventType eventType, string message, params object[] args)
        {
            if (message == null)
                throw new ArgumentNullException(nameof(message));
            var timespan = ShortTimeSpan.FromSeconds(elapsed.TotalSeconds);

            if (sb == null)
                sb = StringBuilderCache.GetStringBuilder();
            sb.Clear();
            if (args.Length == 0)
            {
                sb.Append(message);
            }
            else
            {
                sb.AppendFormat(message, args);
            }
            sb.Append(" [");
            timespan.ToString(sb);
            sb.Append("]");
            // * 1_000_000 steals about 20 bits of precision
            // so ticks can be about 2^43 before overflowing (signed int)
            // 
            long durationNs = elapsed.Ticks * NanoSecondsPerTick;
            trace.TraceEvent(durationNs, eventType, 0, sb.ToString());
        }

        // this should always be exactly 100.
        const long NanoSecondsPerTick = 1_000_000_000 / TimeSpan.TicksPerSecond;

        /// <summary>
        /// Write a message to the log with a given trace level.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="eventType"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        static void traceEvent(this TraceSource trace, LogEventType eventType, string message, params object[] args)
        {
            if (message == null)
                throw new ArgumentNullException(nameof(message));
            if (args.Length == 0)
            {
                trace.TraceEvent(eventType, 0, message);    
            }
            else
            {
                trace.TraceEvent(eventType, 0, message, args);
            }
            
        }

        static void exceptionEvent(this TraceSource trace, Exception exception, LogEventType eventType)
        {
            if (exception == null)
                throw new ArgumentNullException(nameof(exception));
            WriteException(trace, exception, eventType);
        }

        /// <summary>
        /// Trace a message at level "Information" (<see cref="LogEventType.Information"/>).
        /// </summary>
        /// <param name="trace">this(extension method).</param>
        /// <param name="message">Message to write.</param>
        public static void TraceInformation(this TraceSource trace, string message)
        {
            Info(trace, message);
        }

        /// <summary>
        /// Trace a message at level "Debug" (<see cref="LogEventType.Debug"/>).
        /// </summary>
        /// <param name="trace">this(extension method).</param>
        /// <param name="message">Message to write.</param>
        /// <param name="args">parameters (see <see cref="String.Format(string, object)"/>).</param>
        public static void Debug(this TraceSource trace, string message, params object[] args)
        {
            traceEvent(trace, LogEventType.Debug, message, args);
        }

        /// <summary>
        /// Writes a message with the time measured by timer appended in the format [xx.x (m/u/n)s].
        /// if timer is a TimerToken it will be disposed.
        /// Information level log message.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="timer"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        public static void Info(this TraceSource trace, Stopwatch timer, string message, params object[] args)
        {
            if (timer == null)
                throw new ArgumentNullException("timer");
            traceEvent(trace, timer.Elapsed, LogEventType.Information, message, args);
        }

        /// <summary>
        /// Writes a message with the time measured by timer appended in the format [xx.x (m/u/n)s].
        /// if timer is a TimerToken it will be disposed.
        /// Debug level end message.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="timer"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        public static void Debug(this TraceSource trace, Stopwatch timer, string message, params object[] args)
        {
            if (timer == null)
                throw new ArgumentNullException("timer");
            traceEvent(trace, timer.Elapsed, LogEventType.Debug, message, args);
        }
        /// <summary>
        /// Writes a message with the time measured by timer appended in the format [xx.x (m/u/n)s].
        /// if timer is a TimerToken it will be disposed.
        /// Warning level end message.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="timer"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        public static void Warning(this TraceSource trace, Stopwatch timer, string message, params object[] args)
        {
            if (timer == null)
                throw new ArgumentNullException("timer");
            traceEvent(trace, timer.Elapsed, LogEventType.Warning, message, args);
        }
        /// <summary>
        /// Writes a message with the time measured by timer appended in the format [xx.x (m/u/n)s].
        /// if timer is a TimerToken it will be disposed.
        /// Error level end message.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="timer"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        public static void Error(this TraceSource trace, Stopwatch timer, string message, params object[] args)
        {
            if (timer == null)
                throw new ArgumentNullException("timer");
            traceEvent(trace, timer.Elapsed, LogEventType.Error, message, args);
        }

        /// <summary>
        /// Writes a message with the time appended in the format [xx.x (m/u/n)s].
        /// if timer is a TimerToken it will be disposed.
        /// Information level log message.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="elapsed"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        public static void Info(this TraceSource trace, TimeSpan elapsed, string message, params object[] args)
        {
            traceEvent(trace, elapsed, LogEventType.Information, message, args);
        }

        /// <summary>
        /// Writes a message with the time appended in the format [xx.x (m/u/n)s].
        /// if timer is a TimerToken it will be disposed.
        /// Debug level end message.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="elapsed"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        public static void Debug(this TraceSource trace, TimeSpan elapsed, string message, params object[] args)
        {
            traceEvent(trace, elapsed, LogEventType.Debug, message, args);
        }
        
        /// <summary>
        /// Writes a message with the time appended in the format [xx.x (m/u/n)s].
        /// if timer is a TimerToken it will be disposed.
        /// Warning level end message.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="elapsed"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        public static void Warning(this TraceSource trace, TimeSpan elapsed, string message, params object[] args)
        {
            traceEvent(trace, elapsed, LogEventType.Warning, message, args);
        }
        /// <summary>
        /// Writes a message with the time appended in the format [xx.x (m/u/n)s].
        /// if timer is a TimerToken it will be disposed.
        /// Error level end message.
        /// </summary>
        /// <param name="trace"></param>
        /// <param name="elapsed"></param>
        /// <param name="message"></param>
        /// <param name="args"></param>
        public static void Error(this TraceSource trace, TimeSpan elapsed, string message, params object[] args)
        {
            traceEvent(trace, elapsed, LogEventType.Error, message, args);
        }
        /// <summary>
        /// Trace a message at level "Information" (<see cref="LogEventType.Information"/>).
        /// </summary>
        /// <param name="trace">this(extension method).</param>
        /// <param name="message">Message to write.</param>
        /// <param name="args">parameters (see <see cref="String.Format(string, object)"/>).</param>
        public static void Info(this TraceSource trace, string message, params object[] args)
        {
            traceEvent(trace, LogEventType.Information, message, args);
        }

        /// <summary>
        /// Trace a message at level "Warning" (<see cref="LogEventType.Warning"/>).
        /// </summary>
        /// <param name="trace">this(extension method).</param>
        /// <param name="message">Message to write.</param>
        /// <param name="args">parameters (see <see cref="String.Format(string, object)"/>).</param>
        public static void Warning(this TraceSource trace, string message, params object[] args)
        {
            traceEvent(trace, LogEventType.Warning, message, args);
        }

        /// <summary>
        /// Trace a message at level "Error" (<see cref="LogEventType.Error"/>).
        /// </summary>
        /// <param name="trace">this(extension method).</param>
        /// <param name="message">Message to write.</param>
        /// <param name="args">parameters (see <see cref="String.Format(string, object)"/>).</param>
        public static void Error(this TraceSource trace, string message, params object[] args)
        {
            traceEvent(trace, LogEventType.Error, message, args);
        }

        /// <summary>
        /// Write exception details (including stack trace) to the trace at level "Debug" (<see cref="LogEventType.Error"/>). 
        /// </summary>
        /// <param name="trace">this(extension method).</param>
        /// <param name="exception">Inputs error exception.</param>
        public static void Debug(this TraceSource trace, Exception exception)
        {
            exceptionEvent(trace, exception, LogEventType.Debug);
        }

        /// <summary>
        /// Write exception details (including stack trace) to the trace at level "Error" (<see cref="LogEventType.Error"/>). 
        /// </summary>
        /// <param name="trace">this(extension method).</param>
        /// <param name="exception">Inputs error exception.</param>
        public static void Error(this TraceSource trace, Exception exception)
        {
            exceptionEvent(trace, exception, LogEventType.Error);
        }

        const int callerStackTraceLimit = 4;
        static void WriteStackTrace(TraceSource trace, StackTrace stack, LogEventType level)
        {
            var frames = stack.GetFrames() ?? Array.Empty<StackFrame>(); 
            var lines = frames
                .Skip(3) // Skip the frames from the logging itself.
                .Where(line => line.HasMethod()); // only take those with the method available.
            int lineCount = lines.Count();
            
            lines = lines.Take(callerStackTraceLimit); // Just show the top of the call stack.
            
            foreach (StackFrame line in lines)
            {
                var fixedLine =  $"at {line.GetMethod()}";
                if (line.HasSource())
                {
                    fixedLine += $" in {line.GetFileName()}:line {line.GetFileLineNumber()}";
                }
                trace.TraceEvent(level, 2, "    " + fixedLine, false);
            }

            if (lineCount > callerStackTraceLimit)
            {
                trace.TraceEvent(level, 2, "    ...");
            }
        }

        static void WriteException(TraceSource trace, Exception exception, LogEventType level, bool appendStack = true, bool isInner = false)
        {
            var exceptionName = exception.GetType().Name;
            try
            {
                var exceptionMessage = exception.Message
                    .Replace("{", "{{")
                    .Replace("}", "}}");
                if (isInner)
                    trace.TraceEvent(level, 2, "  Inner " + exceptionName + ": " + exceptionMessage, false);
                else
                    trace.TraceEvent(level, 2, exceptionName + ": " + exceptionMessage);
                if (exception.StackTrace != null)
                {
                    string[] lines = exception.StackTrace.Split(new char[] {'\n'});
                    foreach (string line in lines)
                    {
                        var fixedLine = line.Replace("{", "{{").Replace("}", "}}").Trim();
                        trace.TraceEvent(LogEventType.Debug, 2, "    " + fixedLine, false);
                    }
                }

                if (exception is ReflectionTypeLoadException)
                {
                    ReflectionTypeLoadException reflectionTypeLoadException = (ReflectionTypeLoadException) exception;
                    foreach (Exception ex in reflectionTypeLoadException.LoaderExceptions)
                    {
                        WriteException(trace, ex, level, false);
                    }
                }
                else if (exception is AggregateException ag)
                {
                    foreach (var inner in ag.InnerExceptions)
                    {
                        WriteException(trace, inner, level, false, true);
                    }
                }
                else if (exception.InnerException is Exception inner)
                {
                    WriteException(trace, inner, level, false, true);
                }
            }
            catch (Exception)
            {
                trace.TraceEvent(level, 2, "Error caught while logging an exception.");
            }

            if (appendStack)
            {
                try
                {
                    var stackTrace = new StackTrace(true);
                    trace.TraceEvent(level, 2, "Exception caught at:");
                    WriteStackTrace(trace, stackTrace, level);
                }
                catch
                {
                    trace.TraceEvent(level, 2, "Error retrieving current stacktrace.");
                }
            }
        }

        /// <summary>
        /// Flushes all waiting log trace events.
        /// </summary>
        public static void Flush()
        {
            rootLogContext.Flush();
        }

        /// <summary>
        /// Puts the current log context into synchronous mode.
        /// All TraceSources will now wait for their trace events to be handled by all TraceListeners before returning.
        /// </summary>
        public static void StartSync()
        {
            Flush();
            rootLogContext.Async = false;
        }

        /// <summary>
        /// Ends synchronous mode. Must be called after <c ref="StartSync"/>.
        /// </summary>
        public static void StopSync()
        {
            rootLogContext.Async = true;
            Flush();
        }
    }

    /// <summary>
    /// Extension methods for Exception.
    /// </summary>
    static class ExceptionExtensions
    {
        /// <summary>
        /// Finds the message of the inner most exception for this exception. If no inner exceptions are set, the message of this exception is returned.
        /// COMExceptions are ignored as their message is not very useful.
        /// </summary>
        public static string GetInnerMostExceptionMessage(this Exception ex)
        {
            if (ex is AggregateException ag)
            {
                if(ag.InnerExceptions.Count == 1)
                    return ag.InnerExceptions[0].GetInnerMostExceptionMessage();
                return ag.Message;
            }
            if (ex is System.Runtime.InteropServices.COMException)
                return ex.Message;
            return ex.InnerException?.GetInnerMostExceptionMessage() ?? ex.Message;
        }

        public static void Rethrow(this Exception ex)
        {
            System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
        }

        public static void RethrowInner(this Exception ex)
        {
            if(ex is AggregateException a && a.InnerExceptions.Count > 1)
                ex.Rethrow();
            else
                (ex.InnerException ?? ex).Rethrow();
        }
    }

    static class StringBuilderCache
    {
        [ThreadStatic]
        static StringBuilder sb;

        public static StringBuilder GetStringBuilder()
        {
            var sb2 = sb ??= new StringBuilder();
            sb2.Clear();
            return sb2;   
        }
    }
}