using MonotonicContext = HpTimeStamps.MonotonicStampContext;
using WallClock = System.DateTime;
using HpStamp = System.DateTime;
using HpStampSource = HpTimeStamps.TimeStampSource;
namespace ExampleTimestamps
{
    using MonotonicStamp = MonotonicTimeStamp<MonotonicContext>;
    using MonoStampSource = MonotonicTimeStampUtil<MonotonicContext>;

    /// <summary>
    /// Static class used for obtaining DateTimes and other timestamps
    /// </summary>
    /// <remarks>In a non-demo implementation, <see cref="s_defaultProvider"/> should be WriteOnce (with thread-safe initializer)
    /// or readonly if you don't need to dynamically change default at runtime.
    /// </remarks>
    public static partial class TimeStampProvider
    {
        /// <summary>
        /// Indicates type of stamps retrieved by <see cref="Now"/> and <see cref="UtcNow"/>
        /// properties.
        /// </summary>
        public static DefaultStampType DefaultStampType
        {
            get
            {
                DefaultStampProvider provider = s_defaultProvider;
                switch (provider)
                {
                    default:
                    case null:
                        throw new InvalidOperationException("The provider is null or not of a recognized type.");
                    case WallClockProvider _:
                        return DefaultStampType.Wall;
                    case MonotonicClockProvider _:
                        return DefaultStampType.Monotonic;
                    case HighPrecisionClockProvider _:
                        return DefaultStampType.HighPrecision;
                }
            }
        }

        /// <summary>
        /// Use the default provider to get a timestamp expressed in local time
        /// </summary>
        public static DateTime Now
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => s_defaultProvider.DefaultNow;
        }

        /// <summary>
        /// Use the default provider to get a timestamp in UTC time
        /// </summary>
        public static DateTime UtcNow
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => s_defaultProvider.DefaultUtcNow;
        }

        /// <summary>
        /// Get a monotonic timestamp
        /// </summary>
        public static MonotonicStamp MonoNow
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => MonoStampSource.StampNow;
        }

        /// <summary>
        /// Get a monotonic timestamp expressed as a utc datetime
        /// </summary>
        public static DateTime MonoUtcNow
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => MonoNow.ToUtcDateTime();
        }

        /// <summary>
        /// Get a monotonic timestamp expressed as a local datetime
        /// </summary>
        public static DateTime MonoLocalNow
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => MonoNow.ToLocalDateTime();
        }

        /// <summary>
        /// Get a high precision timestamp expressed as a local time
        /// </summary>
        public static HpStamp HpNow
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => HpStampSource.Now;
        }

        /// <summary>
        /// Get a high precision timestamp expressed in UTC
        /// </summary>
        public static DateTime HpUtcNow
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => HpStampSource.UtcNow;
        }

        /// <summary>
        /// Get the wall clock time expressed as local time
        /// </summary>
        public static DateTime WallNow
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => WallClock.Now;
        }

        /// <summary>
        /// Get the wall clock time expressed in utc
        /// </summary>
        public static HpStamp WallUtcNow
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => WallClock.UtcNow;
        }

        /// <summary>
        /// True if, on this thread, the high precision clock needs calibration.
        /// </summary>
        public static bool HpNeedsCalibration
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => HpStampSource.NeedsCalibration;
        }

        /// <summary>
        /// The amount of time elapsed since the High Precision clock's
        /// last calibration on this thread.
        /// </summary>
        public static TimeSpan TimeSinceLastCalibration
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => HpStampSource.TimeSinceCalibration;
        }

        /// <summary>
        /// Monotonic stamp context used by monotonic clock.  Contains
        /// information about frequencies, conversions, a reference time, etc.
        /// </summary>
        public static ref readonly MonotonicContext MonotonicContext
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get => ref MonoStampSource.StampContext;
        }

        #region Mutators
        /// <summary>
        /// Calibrate the high precision clock now
        /// </summary>
        public static void CalibrateNow() => HpStampSource.Calibrate();
        /// <summary>
        /// Make <see cref="Now"/> and <see cref="UtcNow"/> use a monotonic clock as their source
        /// </summary>
        public static void UseMonotonicDefaultStamps() => s_defaultProvider = CreateMonotonicClock();
        /// <summary>
        /// Make <see cref="Now"/> and <see cref="UtcNow"/> use a high precision clock as their source
        /// </summary>
        public static void UseHighPrecisionDefaultStamps() => s_defaultProvider = CreateHpClock();
        /// <summary>
        /// Make <see cref="Now"/> and <see cref="UtcNow"/> use the wall clock as their source.
        /// </summary>
        public static void UseWallClockDefaultStamps() => s_defaultProvider = CreateWallClock();
        #endregion
        
        /// <summary>
        /// Adjust 
        /// </summary>
        static TimeStampProvider() => s_defaultProvider = new MonotonicClockProvider();


        [NotNull] private static DefaultStampProvider s_defaultProvider;

    }

/// <summary>
       /// Monotonic clocks are suitable for measuring the time elapsed between events and 
       /// use <see cref="System.Diagnostics.Stopwatch"/> (which uses a high resolution event timer
       /// if available).  On systems where it is available as a High Resolution clock
       /// (at least Linux and Windows right now) , it is also monotonic.  This means that the clock always
       /// moves forward ... unlike the wall clock, you can never take two readings and have the later reading
       /// yield an earlier time.  Unlike the wall clock, it is STEADY.  It is not subject to changes.  Using
       /// Stopwatch directly is often possible, but it does not give you a timestamp -- just elapsed time.
       ///
       /// In many scenarios (in my line of work) it is desirable to have a "dual use" timestamp: one that
       /// is suitable for displaying the date/time of events AND being safely usable to calculate elapsed time between events.
       /// 
       /// This stamp is designed to serve in this dual-use scenario (suitable to say what time something happened AND
       /// to use with other stamps to measure elapsed time).  Unlike the high precision clock provided, these stamps
       /// are calibrated once per process (across all threads) and thus can be used to establish at least a rough
       /// ordering of events across multiple threads.
       /// 
       /// Advantages: (note some advantages can also be disadvantages and vice versa)
       ///     1- It is safe to rely on this to measure intervals.
       ///     2- It is (usually) more accurate (vis-a-vis time elapsed between events), down to the precision and accuracy
       ///         of the hardware's high precision event time.
       ///     3- Unlike just using stopwatch you can still use these to log the time something happened AND use it to measure elapsed time
       ///     4- It is convertible to a DateTime.
       ///     5- It can safely be used to express a "timeout" deadline without fear that system clock will change, causing incorrect behavior.
       /// Disadvantages:
       ///     1- Because these (of necessity) are calibrated only once per process, over time there will likely be drift
       ///        between the system clock and this clock.  The system clock is usually synchronized and updated for daylights savings,
       ///        timezone changes, etc.  Thus, if (for example) it becomes daylight savings time while a process is running,
       ///        these stamps (when expressed as a DateTime or printed to ISO-8601) will not accurately reflect the actual time at which the event occurred.
       ///         a. Example.
       ///             -You start using these stamps at midnight on a day when transitioning to standard from daylight savings time.
       ///             -At what would normally be 3 am, the system clock moves back one hour for a "second" 2am.
       ///             -These timestamps will now not accurately reflect the local time at which something happened
       ///     2- These are not suitable for use across process boundaries or for serialization.  To keep the data in each value
       ///        small, calibration data is static (which correlates high precision performance counter ticks to a wall clock time once).  Thus
       ///        each value contains only an offset in stopwatch ticks from the reference time.  The reference time will be different for every process
       ///        and high precision event counter resolution varies by system.  Outside of current process, these values are meaningless
       ///     3- Some systems have very peculiar frequencies for the high performance event counter (as accessed via <see cref="System.Diagnostics.Stopwatch"/>).
       ///        On most Windows 10 systems I have tested this project on, the resolution of the <see cref="System.Diagnostics.Stopwatch"/> (and thus
       ///        this clock) is 10,000,000 ticks per second (i.e. 1 tick per tenth of a microsecond -- the same as <see cref="DateTime"/> and <see cref="TimeSpan"/>)
       ///        thus making conversions to and from DateTime and TimeSpan straightforward and without data loss.  On the Linux systems I have tested (Amazon Linux 2 and Ubuntu 20.04),
       ///        the resolution of stopwatch is 1,000,000,000.  This conversion is relatively straight forward and round: you lose hundredths and thousandths of microsecond resolution
       ///        when converting to DateTime and TimeSpan.  On other systems, however, the high precision event counter may have a resolution (though presumably a higher accuracy) LOWER than DateTime
       ///        and TimeSpan and have very non-round conversion factors (for example, on Windows Server hosted by Amazon AWS Work spaces, my test machine has a frequency of  2,441,366), which
       ///        complicated this project far beyond what I had originally anticipated.
       ///
       /// Note that is clock is unique in that it does not directly produce <see cref="DateTime"/> values.  Rather, it produces objects that express the time in terms of <see cref="System.Diagnostics.Stopwatch"/>
       /// ticks.  This keeps the actual size of individual values quite small.  They are fully convertible to DateTime but may lose precision based on the relative resolution of <see cref="DateTime"/> and <see cref="TimeSpan"/>
       /// and <see cref="System.Diagnostics.Stopwatch"/>.  Because which direction the loss will occur in and whether there will be loss due to rounding cannot be determined, conversions between this and datetime have to be explicit.
       /// These stamps provide <see cref="MonotonicStamp.ToLocalDateTime"/> and <see cref="MonotonicStamp.ToUtcDateTime"/> method for conversion as well as explicit casts.  Also, if not converting to DateTime before usage,
       /// this type has a companion analog to <see cref="TimeSpan"/> called <see cref="Duration"/>.  <see cref="Duration"/> is represented in terms of the same frequency as <see cref="MonotonicStamp"/> so arithmetic
       /// is not complex.  
       ///
       /// If you wish to serialize this data, you can:
       ///
       ///      1- convert <see cref="MonotonicStamp"/> to <see cref="DateTime"/> or <see cref="Duration"/> to <see cref="TimeSpan"/> first and save those values.  This may involve loss of precision depending
       ///         on frequencies.
       ///      2- convert <see cref="MonotonicStamp"/> to <see cref="PortableMonotonicStamp"/> or <see cref="Duration"/> to <see cref="PortableDuration"/>.  <see cref="PortableDuration"/> and <see cref="PortableMonotonicStamp"/>
       ///         (across ALL systems) have nanoseconds resolution -- unless your system's <see cref="Stopwatch"/> has a resolution finer than nanoseconds, there will not be lost precision .... EXCEPT perhaps some slight loss
       ///         if the <see cref="Stopwatch"/> frequency does not lend itself to clean conversion.  This is minimal in my experience.       
       /// 
       /// </summary>
       static void MonotonicClockExample()
       {
           MonotonicStamp startedStuffAt = TimeStampProvider.MonoNow;
           Duration doImportantStuffFor = Duration.FromMilliseconds(250);
           DoStuffUntil(startedStuffAt + doImportantStuffFor, CancellationToken.None);
           MonotonicStamp doneAt = TimeStampProvider.MonoNow;

           Console.WriteLine($"Started stuff at: {startedStuffAt}.");
           Console.WriteLine($"Did stuff for {doImportantStuffFor.TotalMilliseconds:N3}.");
           Console.WriteLine($"Ended at: {doneAt}.");

           //if you make your default stamp provider monotonic, it will convert to date time immediately. 
           //choose between wall / monotonic / high precision as "default" in TimeStampProvider based upon
           //what you think is the best default behavior.
           DateTime asDtUtc = startedStuffAt.ToUtcDateTime();
           DateTime asDtLocal = startedStuffAt.ToLocalDateTime();
           TimeSpan converted = (TimeSpan) doImportantStuffFor;
           DateTime doneAtUtc = doneAt.ToUtcDateTime();
           
           Console.WriteLine($"Stamp expressed as utc stamp: {asDtUtc:O}.");
           Console.WriteLine($"Stamp expressed as local stamp: {asDtLocal:O}.");
           Console.WriteLine($"Duration converted to TimeSpan: {converted.TotalMilliseconds:N3}.");
           Console.WriteLine($"Done at as utc timestamp: {doneAtUtc:O}.");

           PortableMonotonicStamp portableStampVersion = (PortableMonotonicStamp) startedStuffAt;
           PortableDuration portableDuration = (PortableDuration) doImportantStuffFor;
           PortableMonotonicStamp sum = portableStampVersion + portableDuration;
           Console.WriteLine("Portable duration: {0}.", portableDuration);
           Console.WriteLine($"Portable duration as microseconds: {portableDuration.TotalMicroseconds:N3}");
           Console.WriteLine("Portable stamp: {0}.", portableStampVersion);
           Console.WriteLine("Portable stamp as local: {0}.", portableStampVersion.ToLocalString());
           Console.WriteLine("sum: {0}.", sum);

           (string stampXml, PortableMonotonicStamp roundTripped) = Serialize(in sum);
           Console.WriteLine($"Xml for sum: {stampXml}.");
           Console.WriteLine($"Round tripped stamp: {roundTripped}.");

           (string durXml, PortableDuration roundTrippedDur) = Serialize(in portableDuration);
           Console.WriteLine($"Xml for portableDuration: {durXml}.");
           Console.WriteLine($"Round tripped value: {roundTrippedDur}");
           Console.WriteLine("Round tripped dur microseconds: {0:N3}.", roundTrippedDur.TotalMicroseconds);
       }

/// <summary>
/// Like the wall clock and unlike the monotonic clock, this source simply provides regular DateTimes but it used the <see cref="Stopwatch"/>
/// rather than wall clock.  Like <see cref="MonotonicTimeStamp{TStampContext}"/>, there is an association of a stopwatch reading with a wall clock reading
/// used to translate results from calls to <see cref="Stopwatch.GetTimestamp"/> to date times.  UNLIKE the monotonic clock, the calibration here is done on
/// a PER THREAD basis.  Also, the calibration is for a limited duration .... after a time limit expires the stamps will be re-calibrated to the wall clock.
///
/// Advantages:
///     1- Unlike monotonic clock, periodic recalibration reduces chance of significant drift between system clock and this clock.
///     2- On a per-thread basis within a given calibration period (assuming no system clock change) the stamps produced will be
///        more accurate (as far as <see cref="Stopwatch"/> and hardware allow) than stamps obtained with DateTime.Now.
///     3- They can thus be used for benchmarks or within smaller time windows to measure performance / benchmark as well
///        as serve as reasonably accurate timestamps (assuming one calibration period, no system clock change during it).
/// Disadvantages:
///     1- Per thread.  Cannot be used to reliably relate relative occurrence of events on different threads.
///     2- Recalibration overhead (call <see cref="TimeStampProvider.CalibrateNow"/> before use to minimize possibility)
///     3- If a big adjustment to system clock happens after calibration but timestamps are read BEFORE next recalibration, stamps will not be accurate
///        vis-a-vis wall clock
///     4. If some stamps are gathered during calibration period A, then calibration period A ends and a big change is made to system clock, then recalibration happens
///        at period B, then more stamps are read, the stamps from period A cannot be used with stamps from period B to accurately measure elapsed time.
/// </summary>
static void HighPrecisionClockExample()
{
    bool needsCalibration = TimeStampProvider.HpNeedsCalibration;
    Console.WriteLine($"needs calibration?: {needsCalibration}");
    if (needsCalibration)
    {
        Console.WriteLine("Calibrating.");
        TimeStampProvider.CalibrateNow();
        needsCalibration = TimeStampProvider.HpNeedsCalibration;
        Console.WriteLine($"needs calibration?: {needsCalibration}");
        Debug.Assert(!needsCalibration);
    }

    Console.WriteLine($"Elapsed time since last calibration: {TimeStampProvider.TimeSinceLastCalibration}.");
    
    var stamps = GetStamps(10);
    Console.WriteLine("Going to print timestamps: ");
    int stampCount = 0;
    foreach (var stamp in stamps)
    {
        Console.WriteLine("Hp stamp# {0:N}: [{1:O}].", ++stampCount, stamp);
    }
    Console.WriteLine("Done printing hp stamps.");

    TimeSpan differenceLastFirst = stamps.Last() - stamps.First();
    Console.WriteLine($"Time between first and last stamp: {differenceLastFirst}.");

    Console.WriteLine($"Final Elapsed time since calibration: {TimeStampProvider.TimeSinceLastCalibration}.");

    static ImmutableArray<HpStamp> GetStamps(int numStamps)
    {
        Debug.Assert(numStamps > 0);
        var arr = ImmutableArray.CreateBuilder<HpStamp>(numStamps);
        for (int i = 1; i <= numStamps; ++i)
        {
            arr.Add(TimeStampProvider.HpNow);
        }

        return arr.MoveToImmutable();
    }
}