using System;

using System.Collections.Generic;

using System.Linq;

using System.Globalization;

using System.Text.RegularExpressions;

​

/*

     A static utility that allows all possible dates to survive the round trip between our poorly designed format and UTC.

     What this allows is:

    - Dates in the UI format can be parsed back into a DateTimeOffset with a matching  TimeZoneInfo (not *the* timezone.. The many-to-1 problem).

    - DateTimeOffset's, DateTimes with TimeZoneInfo, DateTime with Offsets to be formatted to a string which includes a timezone that matches for the 

      provided date and time (not, necessarily, the time zone provided).

    About this while time zone thing (this keeps coming up we can't seem to squash this confusion)

​

    Why Date Times, Offsets,and TimeZones are all different:

    - For DateTime instances to be deterministic, they must have a fixed value offset from some unchanging time like UTC. And, ideally, that offset is 0.

      You cannot, for example, include a date time value with a _timezone_ like (PT) and expect it to be deterministic for anything but _past_ datetime 

      values. Why ? because a time zone's offset to a date is relative to the date itself **and the history of that locality**. An change to the

      municipal time tracking for any zone can happen at any time. That's why all ISO date formats include the offset from UTC (or GMT) and none include

      a timezone and an unchanging date.

    - UTC offsets are not a way to determine a timezone! Many time zones will have the same releative to some date. It's that a timezone has an offset at

      a point in time, and that offset need not be unique.

​

    - Time Zones are a poorly defined (non-unique or uniform) moving target, see: https://en.wikipedia.org/wiki/List_of_time_zone_abbreviations

      Unless you absolutely have to, DO NOT, attempt to come up with your own abbreviations.    

​

  The right thing to do is ...

​

   - Always work in UTC when recording dates.

   - Translate to any preferred zone for display, and uses the language-provided name

     (since common abbreviations overlap https://en.wikipedia.org/wiki/List_of_time_zone_abbreviations)

   - Use you absolutely must use time zone abbreviations, use a library for this purpose (e.g. https://github.com/mattjohnsonpint/TimeZoneNames).

        - Use you absolutely must use time zone name abbreviations across different languages, pick one source of truth and for the offical source

          of truth (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) to your names, and share mappings as a JSON file or something between 

          all places that need to use it.

*/

public static class PoorlyDesignedDateFormat {

    private static readonly Dictionary<string, TimeZoneInfo> CodesToReferenceZones = new Dictionary<string, TimeZoneInfo>

    {

        { "ET", TimeZoneInfo.FindSystemTimeZoneById("America/New_York") },

        { "CT", TimeZoneInfo.FindSystemTimeZoneById("America/Chicago") },

        { "MT", TimeZoneInfo.FindSystemTimeZoneById("America/Denver") },

        { "PT", TimeZoneInfo.FindSystemTimeZoneById("America/Los_Angeles") },

    };

​

    private static readonly Regex PatternForWonkeyFormatUseDInOurTests = new Regex(

        @"([0-1][0-9]):([0-5][0-9])([AaPp][Mm]) ([aA-zZ]{2}) ([A-Z][a-z]{2})-([0-3][0-9]) ([0-9]{4})");

    private static readonly string IntermediaryFormat = "hh:mmtt 'TZC' MMM-dd yyyy";

    public static (DateTimeOffset, TimeZoneInfo) Parse(string rawValue)

    {

        var match = PatternForWonkeyFormatUseDInOurTests.Match(rawValue);

        if (!match.Success)

        {

            throw new ArgumentException("String not in the poorly designed format");

        }

        var hours =  Int32.Parse(match.Groups[1].Value);

        var minutes = Int32.Parse(match.Groups[2].Value);

        var amPM = match.Groups[3].Value.ToUpper();

        var twoCharTz = match.Groups[4].Value.ToUpper();

        var threeCharMonth = match.Groups[5].Value;

        var dayOfMonth = Int32.Parse(match.Groups[6].Value);

        var year = match.Groups[7].Value;

        var referenceTimezone = CodesToReferenceZones[twoCharTz];

​

        var intermediaryFormattedValue = string.Format(

            "{0:D2}:{1:D2}{2} TZC {3}-{4:D2} {5}", hours, minutes,amPM,threeCharMonth, dayOfMonth, year);

        var parsedDate = DateTime.ParseExact(

            intermediaryFormattedValue,

            IntermediaryFormat,

            CultureInfo.InvariantCulture,

            DateTimeStyles.AssumeLocal);

        var unspecifiedDT = DateTime.SpecifyKind(parsedDate, DateTimeKind.Unspecified);

        var dateTimeWithOffset = TimeZoneInfo.ConvertTime(

            new DateTimeOffset(unspecifiedDT, referenceTimezone.GetUtcOffset(unspecifiedDT)), referenceTimezone);

        return (dateTimeWithOffset, referenceTimezone);

    }

    public static string Format(DateTime dateValue, TimeZoneInfo tzInfo) => Format(TimeZoneInfo.ConvertTime(new DateTimeOffset(dateValue, TimeSpan.Zero), tzInfo));

    public static string Format(DateTimeOffset dateValue) => Format(dateValue.DateTime, dateValue.Offset);

​

    public static string Format(DateTime dateValue, TimeSpan utcOffset)

    {

        // Find find the first matching offset for the passed tzinfo from the standard list, should one exist.

        var ambigiousCodeToUse = CodesToReferenceZones

            .First(kvPair => kvPair.Value.GetUtcOffset(dateValue) == utcOffset)

            .Key;

        return dateValue.ToString(IntermediaryFormat)

            .Replace("TZC", ambigiousCodeToUse)

            .Replace("AM", "am")

            .Replace("pm", "pm");

    }

}

​

public class Program

{

    public static void WriteOutParseInfo(string sourceDateTimeString)

    {

        var (dateTime, timeZone) = PoorlyDesignedDateFormat.Parse(sourceDateTimeString);

        Console.WriteLine($"\n\tFormatted Date: {sourceDateTimeString}\t\n\tDate: {dateTime.ToString()}\n\tTimeZone: {timeZone.DisplayName}");

    }

    public static void WriteOutFormatInfo(DateTime utcDate, TimeZoneInfo targetTimeZone)

    {

        var formattedString = PoorlyDesignedDateFormat.Format(utcDate, targetTimeZone);

        var dateInZone = TimeZoneInfo.ConvertTime(

            new DateTimeOffset(utcDate, TimeSpan.Zero), targetTimeZone);

        Console.WriteLine($"\n\tUtcDate: {utcDate.ToString()}\n\tZone:{targetTimeZone.DisplayName}\n\tDate In Targe TimeZone: {dateInZone.ToString()}\n\tFormattedDate: {formattedString}");

    }

    public static void WriteOutRoundTrip(string sourceDateTimeString)

    {

        var (dateTime, timeZone) = PoorlyDesignedDateFormat.Parse(sourceDateTimeString);

        var reformattedDateTime = PoorlyDesignedDateFormat.Format(dateTime);

        Console.WriteLine($"\n\tSourceDateTime: {sourceDateTimeString}\n\tParsedDateTime: {dateTime}\n\tFormattedDateTime: {reformattedDateTime}");

    }

    public static void Main()

    {

        Console.WriteLine("Going from the bad format to DateTimeOffset w/TimeZone looks like:\n");

        // *Correctly* converts the time specified to UTC accounting for the offset represented by the two digit code at the date/time specified

        // (meaning, daylight savings is accounted for).

        WriteOutParseInfo("12:01am PT Jan-01 2001");

        WriteOutParseInfo("12:01am PT Jul-01 2001");

        WriteOutParseInfo("12:01am MT Jan-01 2001");

        WriteOutParseInfo("12:01am MT Jul-01 2001");

        Console.WriteLine("\n\nGoing the other way looks like\n");

        // *Correctly* converts any _convertable_ date time to the poorly designed format. Arizona is a great example since it _is not_ directly mappable.

        var azTimezone = TimeZoneInfo.FindSystemTimeZoneById("America/Phoenix");

        // 7am UTC time on two different days (always midnight for Arizona)

        var janRefDateUTC = DateTime.SpecifyKind(DateTime.Parse("2021-01-01T07:00:00.0000000Z"), DateTimeKind.Unspecified);

        var julRefDateUTC = DateTime.SpecifyKind(DateTime.Parse("2021-07-01T07:00:00.0000000Z"), DateTimeKind.Unspecified);

​

        // Conver the Jan date to an AZ local time - NOTICE! THERE IS NO WAY TO REPRESENT AZ TIME

        // IN OUR FORMAT DURING HALF THE YEAR!

        WriteOutFormatInfo(janRefDateUTC, azTimezone);

        WriteOutFormatInfo(julRefDateUTC, azTimezone);

        Console.WriteLine("\n\nThe full round trip looks like\n");

        WriteOutRoundTrip("12:01am PT Jan-01 2001");

        WriteOutRoundTrip("12:01am PT Jul-01 2001");

    }

}