using System;

using System.Collections.Generic;

using System.Linq;

using System.Text.Json;

using System.Text.Json.Serialization;

public class Program

{

public class GeneralEnumJsonConverter<T> : JsonConverter<T> where T : Enum

{

​

    private readonly EnumStringLookup<T> enumStringLookup = new();

​

    /// <summary>

    /// Reads and converts a JSON string to an enum.

    /// </summary>

    /// <param name="reader">the <see cref="Utf8JsonReader"/> to read from</param>

    /// <param name="typeToConvert">the <see cref="Enum"/> type being converted</param>

    /// <param name="options">the <see cref="JsonSerializerOptions"/> being used</param>

    /// <returns>the converted enum</returns>

    /// <exception cref="InvalidCastException">when the JSON string does not match an enum value</exception>

    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

    {

        var input = reader.GetString();

        if (input != null)

        {

            return enumStringLookup.Lookup(input);

        }

​

        throw new InvalidCastException($"Invalid value \"{input}\" for {typeof(T)}");

    }

​

    /// <summary>

    /// Writes an enum as a JSON string.

    /// </summary>

    /// <param name="writer">the <see cref="Utf8JsonWriter"/> to write to</param>

    /// <param name="value">the value to be written</param>

    /// <param name="options">the <see cref="JsonSerializerOptions"/> being used</param>

    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)

    {

        writer.WriteStringValue(enumStringLookup.Lookup(value));

    }

}

public class EnumStringLookup<T> where T : Enum

{

    private readonly Dictionary<string, T> stringToEnumDictionary = new();

    private readonly Dictionary<string, T> stringToEnumDictionary2 = new();

    private readonly Dictionary<T, string> enumToStringDictionary = new();

​

    /// <summary>

    /// Calculates and caches SCREAM_CASE strings for enum values.

    /// </summary>

    internal EnumStringLookup()

    {

        foreach (T enumValue in Enum.GetValues(typeof(T)))

        {

            var screamValue = PascalToScreamCaseTranslator.TranslateToScreamCase(enumValue.ToString());

            stringToEnumDictionary.Add(screamValue, enumValue);

            stringToEnumDictionary2.Add(enumValue.ToString(), enumValue);

            enumToStringDictionary.Add(enumValue, screamValue);

        }

    }

​

    /// <summary>

    /// Gets the enum value for a SCREAM_CASE string.

    /// </summary>

    /// <param name="value">a SCREAM_CASE string</param>

    /// <returns>the corresponding enum value of type T</returns>

    /// <exception cref="InvalidCastException">if the string does not map to an enum value</exception>

    internal T Lookup(string value)

    {

        if (stringToEnumDictionary.ContainsKey(value))

        {

            return stringToEnumDictionary[value];

        }

        if (stringToEnumDictionary2.ContainsKey(value))

        {

            return stringToEnumDictionary2[value];

        }

​

        throw new InvalidCastException($"Invalid value \"{value}\" for {typeof(T)}");

    }

​

    /// <summary>

    /// Gets the SCREAM_CASE string for an enum value.

    /// </summary>

    /// <param name="value">an enum value of type T</param>

    /// <returns>the SCREAM_CASE string value for the enum value name</returns>

    internal string Lookup(T value)

    {

        return enumToStringDictionary[value];

    }

}

​

    public static class PascalToScreamCaseTranslator

{

    public static string TranslateToScreamCase(string pascalCase)

    {

        string pascalCase2 = pascalCase;

        return string.Concat(pascalCase2.Select((char c, int i) => (i > 0 && ((char.IsUpper(c) && (!char.IsUpper(pascalCase2[i - 1]) || (i < pascalCase2.Length - 1 && !char.IsUpper(pascalCase2[i + 1])))) || (char.IsDigit(c) && !char.IsDigit(pascalCase2[i - 1])))) ? $"_{c}" : c.ToString())).ToUpper();

    }

}

​

    [JsonConverter(typeof(GeneralEnumJsonConverter<State>))]

    public enum State

    {

        /// <summary>

        /// Indicates an invalid State.  This should only happen due to parsing errors or when objects do not exist.

        /// </summary>

        Invalid = 0,

​

        /// <summary>

        /// Currently being processed.

        /// </summary>

        ReadyToPay = 1,

​

        /// <summary>

        /// Payment have been sent.

        /// </summary>

        Submitted = 2,

​

        /// <summary>

        /// The payment have been complete.

        /// </summary>

        PaymentComplete = 3,

​

        /// <summary>

        /// The payment has been put on hold.

        /// </summary>

        OnHold = 4,

​

        /// <summary>

        /// The payment has been removed.

        /// </summary>

        Removed = 5,

​

        /// <summary>

        /// The bill was sent to a payment lane.

        /// </summary>

        SentToPaymentLane = 6,

​

        /// <summary>

        /// The bill was paid by an external source.

        /// </summary>

        ExternalPayment = 7     

    }

    public class Bill

    {

        public string BillId { get; set; }

        //[JsonConverter(typeof(GeneralEnumJsonConverter<State>))]

        public State State { get; set; }

    }

    public class BillS

    {

        public string BillId { get; set; }

        //[JsonConverter(typeof(JsonStringEnumConverter))]

        public State State { get; set; }

    }

    public static void Main()

    {

        Bill bill = new ()

        {

            BillId = "somevalue",

            State = State.SentToPaymentLane

        };

        BillS billS = new ()

        {

            BillId = "somevalue",

            State = State.SentToPaymentLane

        };      

        var serialized = JsonSerializer.Serialize(bill);

        Console.WriteLine(serialized); 

        var de = JsonSerializer.Deserialize<Bill>(serialized);

        Console.WriteLine($"{de.BillId} - {Enum.GetName(de.State)}");

        var serialized2 = JsonSerializer.Serialize(bill, new JsonSerializerOptions { Converters = { new JsonStringEnumConverter() }});

        Console.WriteLine(serialized2);

        var de2 = JsonSerializer.Deserialize<Bill>(serialized2);

        Console.WriteLine($"{de2.BillId} - {Enum.GetName(de2.State)}");

        var serialized3 = JsonSerializer.Serialize(billS);

        Console.WriteLine(serialized3);

        var de3 = JsonSerializer.Deserialize<Bill>(serialized3);

        Console.WriteLine($"{de3.BillId} - {Enum.GetName(de3.State)}");     

    }

}