namespace Xylem.Common.Logic.ProductionOrderCore.KitronTestResults
{
    using Newtonsoft.Json;
    using Newtonsoft.Json.Converters;
    using Newtonsoft.Json.Linq;
    using System;
    using System.Collections.Generic;
    using System.Globalization;

    public partial class RadioTest
    {
        [JsonProperty("$id")]
        [JsonConverter(typeof(ParseStringConverter))]
        public Int64 Id { get; set; }

        [JsonProperty("TestStepResults")]
        public TestStep TestStepResults { get; set; }

        [JsonProperty("TestStepGP30Interface")]
        public TestStep TestStepGp30Interface { get; set; }

        [JsonProperty("TestStepLoopCalibrate")]
        public TestStep TestStepLoopCalibrate { get; set; }

        [JsonProperty("GUIDKey")]
        public Guid GuidKey { get; set; }

        [JsonProperty("TestID")]
        [JsonConverter(typeof(ParseStringConverter))]
        public Int64 TestId { get; set; }

        [JsonProperty("TestPlace")]
        public String TestPlace { get; set; }

        [JsonProperty("TestAdapter")]
        public String TestAdapter { get; set; }

        [JsonProperty("MaterialNumber")]
        public String MaterialNumber { get; set; }

        [JsonProperty("PanelBarcode")]
        [JsonConverter(typeof(ParseStringConverter))]
        public Int64 PanelBarcode { get; set; }

        [JsonProperty("TestProgramm")]
        public String TestProgramm { get; set; }

        [JsonProperty("TestProgramVer")]
        public String TestProgramVer { get; set; }

        [JsonProperty("TestBoardSerialNr")]
        public String TestBoardSerialNr { get; set; }

        [JsonProperty("TestBoardVersionInfo")]
        public String TestBoardVersionInfo { get; set; }

        [JsonProperty("TestOperator")]
        public String TestOperator { get; set; }

        [JsonProperty("TestMachineName")]
        public String TestMachineName { get; set; }



        [JsonProperty("TestNumber")]
        public String TestNumber { get; set; }

        [JsonProperty("StartDT")]
        public String StartDt { get; set; }

        [JsonProperty("TestDuration")]
        public String TestDuration { get; set; }

        [JsonProperty("TestResult")]
        public Result TestResult { get; set; }

        [JsonProperty("AttachmentFile")]
        public String AttachmentFile { get; set; }
    }

    public class TestStep
    {
        [JsonProperty("$id")]
        [JsonConverter(typeof(ParseStringConverter))]
        public Int64 Id { get; set; }

        [JsonProperty("$values")]
        public Value[] Values { get; set; }
    }

    public class Value
    {
        [JsonProperty("$id")]
        [JsonConverter(typeof(ParseStringConverter))]
        public Int64 Id { get; set; }

        [JsonProperty("TestDate", NullValueHandling = NullValueHandling.Ignore)]
        public DateTimeOffset? TestDate { get; set; }

        [JsonProperty("Barcode", NullValueHandling = NullValueHandling.Ignore)]
        [JsonConverter(typeof(ParseStringConverter))]
        public Int64? Barcode { get; set; }

        [JsonProperty("ResultCalibration", NullValueHandling = NullValueHandling.Ignore)]
        public String ResultCalibration { get; set; }

        [JsonProperty("TestLoop", NullValueHandling = NullValueHandling.Ignore)]
        [JsonConverter(typeof(ParseStringConverter))]
        public Int64? TestLoop { get; set; }

        [JsonProperty("LengthCode", NullValueHandling = NullValueHandling.Ignore)]
        public String LengthCode { get; set; }

        [JsonProperty("RunCalibrate", NullValueHandling = NullValueHandling.Ignore)]
        public String RunCalibrate { get; set; }

        [JsonProperty("RFCalibrationCurrent", NullValueHandling = NullValueHandling.Ignore)]
        public String RfCalibrationCurrent { get; set; }

        [JsonProperty("RFCalibrationPower", NullValueHandling = NullValueHandling.Ignore)]
        public String RfCalibrationPower { get; set; }

        [JsonProperty("iPowerLevelCalculated", NullValueHandling = NullValueHandling.Ignore)]
        public String IPowerLevelCalculated { get; set; }

        [JsonProperty("iExternalPowerlevel", NullValueHandling = NullValueHandling.Ignore)]
        [JsonConverter(typeof(ParseStringConverter))]
        public Int64? IExternalPowerlevel { get; set; }

        [JsonProperty("iAntennaMatching", NullValueHandling = NullValueHandling.Ignore)]
        public String IAntennaMatching { get; set; }

        [JsonProperty("sLookupTablePower", NullValueHandling = NullValueHandling.Ignore)]
        public String SLookupTablePower { get; set; }

        [JsonProperty("dReferenceCurrent1", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferenceCurrent1 { get; set; }

        [JsonProperty("dReferenceCurrentLow1", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferenceCurrentLow1 { get; set; }

        [JsonProperty("dReferenceCurrentHigh1", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferenceCurrentHigh1 { get; set; }

        [JsonProperty("dReferencePower1", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferencePower1 { get; set; }

        [JsonProperty("dReferencePowerLow1", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferencePowerLow1 { get; set; }

        [JsonProperty("dReferencePowerHigh1", NullValueHandling = NullValueHandling.Ignore)]
        public DReferencePowerHigh1? DReferencePowerHigh1 { get; set; }

        [JsonProperty("RunRemeasure", NullValueHandling = NullValueHandling.Ignore)]
        public String RunRemeasure { get; set; }

        [JsonProperty("ResultRemeasure", NullValueHandling = NullValueHandling.Ignore)]
        public String ResultRemeasure { get; set; }

        [JsonProperty("RFRemeasureCurrent", NullValueHandling = NullValueHandling.Ignore)]
        public String RfRemeasureCurrent { get; set; }

        [JsonProperty("RFRemeasurePower", NullValueHandling = NullValueHandling.Ignore)]
        public String RfRemeasurePower { get; set; }

        [JsonProperty("dReferenceCurrent2", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferenceCurrent2 { get; set; }

        [JsonProperty("dReferenceCurrentLow2", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferenceCurrentLow2 { get; set; }

        [JsonProperty("dReferenceCurrentHigh2", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferenceCurrentHigh2 { get; set; }

        [JsonProperty("dReferencePower2", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferencePower2 { get; set; }

        [JsonProperty("dReferencePowerLow2", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferencePowerLow2 { get; set; }

        [JsonProperty("dReferencePowerHigh2", NullValueHandling = NullValueHandling.Ignore)]
        public String DReferencePowerHigh2 { get; set; }

        [JsonProperty("TestStepName", NullValueHandling = NullValueHandling.Ignore)]
        public String TestStepName { get; set; }

        [JsonProperty("TestStepType", NullValueHandling = NullValueHandling.Ignore)]
        public String TestStepType { get; set; }

        [JsonProperty("TestStepDesc", NullValueHandling = NullValueHandling.Ignore)]
        public String TestStepDesc { get; set; }

        [JsonProperty("TestInstrument", NullValueHandling = NullValueHandling.Ignore)]
        public TestInstrument? TestInstrument { get; set; }

        [JsonProperty("TestTypeMeasured", NullValueHandling = NullValueHandling.Ignore)]
        public TestTypeMeasured? TestTypeMeasured { get; set; }

        [JsonProperty("StartDT", NullValueHandling = NullValueHandling.Ignore)]
        public String StartDt { get; set; }

        [JsonProperty("TestDuration", NullValueHandling = NullValueHandling.Ignore)]
        public String TestDuration { get; set; }

        [JsonProperty("Result", NullValueHandling = NullValueHandling.Ignore)]
        public Result? Result { get; set; }

        [JsonProperty("TestValue", NullValueHandling = NullValueHandling.Ignore)]
        public String TestValue { get; set; }

        [JsonProperty("Units", NullValueHandling = NullValueHandling.Ignore)]
        public Units? Units { get; set; }

        [JsonProperty("LowerLimit", NullValueHandling = NullValueHandling.Ignore)]
        public String LowerLimit { get; set; }

        [JsonProperty("UpperLimit", NullValueHandling = NullValueHandling.Ignore)]
        public UpperLimit? UpperLimit { get; set; }

        [JsonProperty("FailDesc", NullValueHandling = NullValueHandling.Ignore)]
        public FailDesc? FailDesc { get; set; }

        [JsonProperty("AttachmentFile", NullValueHandling = NullValueHandling.Ignore)]
        public AttachmentFile? AttachmentFile { get; set; }
    }

    public enum Result { Fail, Pass };

    public enum AttachmentFile { DatenGenesisMfgradiotest433MHzV324Bin, Empty };

    public enum DReferencePowerHigh1 { Empty, The000999999999999979PowerDiff, The004PowerDiff, The031PowerDiff, The033PowerDiff, The034PowerDiff, The15, The182, The200, The2828 };

    public enum FailDesc { CouldNotSetCwWithInternalPowerLevel, Empty, ErrorCheckCalculatePowerDifferenz };

    public enum TestInstrument { Empty, JLinkFlasher, KeyenceBarcoderReader, Multimeter, Pcb };

    public enum TestTypeMeasured { Empty, FlashFirmware, GetAnswerFromPcbDevice, QrCodeRead, ReadFromMeasuringDevice };

    public enum Units { Db, Empty, KHz, MA, Volt, ΜA };

    public struct UpperLimit
    {
        public DReferencePowerHigh1? Enum;
        public Int64? Integer;

        public static implicit operator UpperLimit(DReferencePowerHigh1 enumeration) => new UpperLimit { Enum = enumeration };
        public static implicit operator UpperLimit(Int64 integer) => new UpperLimit { Integer = integer };
    }

    public partial class RadioTest
    {
        public static RadioTest FromJson(String json)
        {
            if (string.IsNullOrEmpty(json)) return new RadioTest { TestResult = Result.Fail };

            try
            {

                if (json.Contains("\"JsonObject\":"))
                {
                    var newFromat = JsonConvert.DeserializeObject<Root>(json);
                    //breakt down all and pass all data to the old format

                    var alternateReturnObj = new RadioTest();

                    if (newFromat.JsonObject.TestResult.ToLower().Contains("pass"))
                    {
                        alternateReturnObj.TestResult = Result.Pass;
                    }

                    if (newFromat.JsonObject.AttachmentFile.ToLower().Contains("_868_"))
                    {

                    }
                    alternateReturnObj.StartDt = newFromat.JsonObject.StartDT;
                    alternateReturnObj.TestStepLoopCalibrate = new TestStep
                    {
                        Values = new Value[23]
                    };

                    var testStepLoopCalibrateToAdd = new List<Value>();

                    var joResponse = JObject.Parse(json);

                    var loopCount = 0;
                    if (joResponse["JsonObject"] == null) return new RadioTest { TestResult = Result.Fail };

                    foreach (var item in joResponse["JsonObject"].Children())
                    {
                        
                        if (item is JProperty pItem)
                        {
                            if (pItem.Name == $"ResultCalibration Loop_{loopCount +1}")
                            {
                                if (pItem.Value.ToString() == "ok")
                                {
                                  
                                    testStepLoopCalibrateToAdd.Add(new Value());
                                    testStepLoopCalibrateToAdd[loopCount].ResultCalibration = pItem.Value.ToString();
                                    testStepLoopCalibrateToAdd[loopCount].SLookupTablePower = newFromat.JsonObject.AttachmentFile.ToLower();
                                    loopCount += 1;
                                }
                            }

                            if (pItem.Name == $"LengthCode Loop_{loopCount}")
                            {
                                if (testStepLoopCalibrateToAdd.Count == loopCount)
                                {
                                    testStepLoopCalibrateToAdd[loopCount-1].LengthCode = pItem.Value.ToString();
                                }

                            }
                            if (pItem.Name == $"PowerLevelCalculated Loop_{loopCount}")
                            {
                                if (testStepLoopCalibrateToAdd.Count == loopCount)
                                {
                                    testStepLoopCalibrateToAdd[loopCount-1].IPowerLevelCalculated = pItem.Value.ToString();
                                }

                            }

                            if (pItem.Name == $"AntennaMatching Loop_{loopCount}")
                            {
                                if (testStepLoopCalibrateToAdd.Count == loopCount)
                                {
                                    testStepLoopCalibrateToAdd[loopCount-1].IAntennaMatching = pItem.Value.ToString();
                                }

                            }


                        }
                        //if (item.Name 
                        //{

                        //}
              
                    }
                    Int32 i = 0;

                    foreach (var item in testStepLoopCalibrateToAdd)
                    {
                        try
                        {
                            if (alternateReturnObj.TestStepLoopCalibrate.Values.Length > i)
                            {
                                alternateReturnObj.TestStepLoopCalibrate.Values.SetValue(item, i);
                                i += 1;
                            }
                        }
                        catch (Exception e)
                        {

                        }
                    }
                   
                    return alternateReturnObj;
                }

                return JsonConvert.DeserializeObject<RadioTest>(json, Converter.Settings);

            }
            catch (Exception)
            {
                return new RadioTest { TestResult = Result.Fail };
            }
        }

    }

    public static class Serialize
    {
        public static String ToJson(this RadioTest self) => JsonConvert.SerializeObject(self, Converter.Settings);
    }

    internal static class Converter
    {
        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
            Converters =
            {
                ResultConverter.Singleton,
                AttachmentFileConverter.Singleton,
                FailDescConverter.Singleton,
                TestInstrumentConverter.Singleton,
                TestTypeMeasuredConverter.Singleton,
                UnitsConverter.Singleton,
                UpperLimitConverter.Singleton,
                DReferencePowerHigh1Converter.Singleton,
                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
            },
        };
    }

    internal class ParseStringConverter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(Int64) || t == typeof(Int64?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            var value = serializer.Deserialize<String>(reader);
            Int64 l;
            if (long.TryParse(value, out l))
            {
                return l;
            }
            return -1;
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (Int64)untypedValue;
            serializer.Serialize(writer, value.ToString());
        }

        public static readonly ParseStringConverter Singleton = new ParseStringConverter();
    }

    internal class ResultConverter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(Result) || t == typeof(Result?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            var value = serializer.Deserialize<String>(reader);
            switch (value)
            {
                case "FAIL":
                    return Result.Fail;
                case "PASS":
                    return Result.Pass;
            }
            throw new Exception("Cannot unmarshal type Result");
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (Result)untypedValue;
            switch (value)
            {
                case Result.Fail:
                    serializer.Serialize(writer, "FAIL");
                    return;
                case Result.Pass:
                    serializer.Serialize(writer, "PASS");
                    return;
            }
            throw new Exception("Cannot marshal type Result");
        }

        public static readonly ResultConverter Singleton = new ResultConverter();
    }

    internal class AttachmentFileConverter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(AttachmentFile) || t == typeof(AttachmentFile?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            var value = serializer.Deserialize<String>(reader);
            switch (value)
            {
                case "":
                    return AttachmentFile.Empty;
                case "Daten\\Genesis_mfgradiotest_433MHz_v324.bin":
                    return AttachmentFile.DatenGenesisMfgradiotest433MHzV324Bin;
                default:
                    return AttachmentFile.Empty;
            }
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (AttachmentFile)untypedValue;
            switch (value)
            {
                case AttachmentFile.Empty:
                    serializer.Serialize(writer, "");
                    return;
                case AttachmentFile.DatenGenesisMfgradiotest433MHzV324Bin:
                    serializer.Serialize(writer, "Daten\\Genesis_mfgradiotest_433MHz_v324.bin");
                    return;
            }
            throw new Exception("Cannot marshal type AttachmentFile");
        }

        public static readonly AttachmentFileConverter Singleton = new AttachmentFileConverter();
    }

    internal class FailDescConverter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(FailDesc) || t == typeof(FailDesc?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            var value = serializer.Deserialize<String>(reader);
            switch (value)
            {

                case "Error Check Calculate Power Differenz":
                    return FailDesc.ErrorCheckCalculatePowerDifferenz;
                case "could not set CW with Internal power level":
                    return FailDesc.CouldNotSetCwWithInternalPowerLevel;
                default:
                    return FailDesc.Empty;
            }
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (FailDesc)untypedValue;
            switch (value)
            {
                case FailDesc.Empty:
                    serializer.Serialize(writer, "");
                    return;
                case FailDesc.ErrorCheckCalculatePowerDifferenz:
                    serializer.Serialize(writer, "Error Check Calculate Power Differenz");
                    return;
                case FailDesc.CouldNotSetCwWithInternalPowerLevel:
                    serializer.Serialize(writer, "could not set CW with Internal power level");
                    return;
            }
            throw new Exception("Cannot marshal type FailDesc");
        }

        public static readonly FailDescConverter Singleton = new FailDescConverter();
    }

    internal class TestInstrumentConverter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(TestInstrument) || t == typeof(TestInstrument?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            var value = serializer.Deserialize<String>(reader);
            switch (value)
            {
                case "":
                    return TestInstrument.Empty;
                case "J-Link Flasher":
                    return TestInstrument.JLinkFlasher;
                case "Keyence Barcoder Reader":
                    return TestInstrument.KeyenceBarcoderReader;
                case "Multimeter":
                    return TestInstrument.Multimeter;
                case "PCB":
                    return TestInstrument.Pcb;
            }
            return TestInstrument.Empty;
            // throw new Exception("Cannot unmarshal type TestInstrument");
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (TestInstrument)untypedValue;
            switch (value)
            {
                case TestInstrument.Empty:
                    serializer.Serialize(writer, "");
                    return;
                case TestInstrument.JLinkFlasher:
                    serializer.Serialize(writer, "J-Link Flasher");
                    return;
                case TestInstrument.KeyenceBarcoderReader:
                    serializer.Serialize(writer, "Keyence Barcoder Reader");
                    return;
                case TestInstrument.Multimeter:
                    serializer.Serialize(writer, "Multimeter");
                    return;
                case TestInstrument.Pcb:
                    serializer.Serialize(writer, "PCB");
                    return;
            }
            throw new Exception("Cannot marshal type TestInstrument");
        }

        public static readonly TestInstrumentConverter Singleton = new TestInstrumentConverter();
    }

    internal class TestTypeMeasuredConverter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(TestTypeMeasured) || t == typeof(TestTypeMeasured?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            var value = serializer.Deserialize<String>(reader);
            switch (value)
            {
                case "":
                    return TestTypeMeasured.Empty;
                case "Flash Firmware":
                    return TestTypeMeasured.FlashFirmware;
                case "Get Answer from PCB Device":
                    return TestTypeMeasured.GetAnswerFromPcbDevice;
                case "QR Code read":
                    return TestTypeMeasured.QrCodeRead;
                case "Read from Measuring Device":
                    return TestTypeMeasured.ReadFromMeasuringDevice;
            }
            return TestTypeMeasured.Empty; 
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (TestTypeMeasured)untypedValue;
            switch (value)
            {
                case TestTypeMeasured.Empty:
                    serializer.Serialize(writer, "");
                    return;
                case TestTypeMeasured.FlashFirmware:
                    serializer.Serialize(writer, "Flash Firmware");
                    return;
                case TestTypeMeasured.GetAnswerFromPcbDevice:
                    serializer.Serialize(writer, "Get Answer from PCB Device");
                    return;
                case TestTypeMeasured.QrCodeRead:
                    serializer.Serialize(writer, "QR Code read");
                    return;
                case TestTypeMeasured.ReadFromMeasuringDevice:
                    serializer.Serialize(writer, "Read from Measuring Device");
                    return;
            }
            throw new Exception("Cannot marshal type TestTypeMeasured");
        }

        public static readonly TestTypeMeasuredConverter Singleton = new TestTypeMeasuredConverter();
    }

    internal class UnitsConverter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(Units) || t == typeof(Units?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            var value = serializer.Deserialize<String>(reader);
            switch (value)
            {
                case "":
                    return Units.Empty;
                case "Volt":
                    return Units.Volt;
                case "db":
                    return Units.Db;
                case "kHz":
                    return Units.KHz;
                case "mA":
                    return Units.MA;
                case "µA":
                    return Units.ΜA;
            }
            throw new Exception("Cannot unmarshal type Units");
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (Units)untypedValue;
            switch (value)
            {
                case Units.Empty:
                    serializer.Serialize(writer, "");
                    return;
                case Units.Volt:
                    serializer.Serialize(writer, "Volt");
                    return;
                case Units.Db:
                    serializer.Serialize(writer, "db");
                    return;
                case Units.KHz:
                    serializer.Serialize(writer, "kHz");
                    return;
                case Units.MA:
                    serializer.Serialize(writer, "mA");
                    return;
                case Units.ΜA:
                    serializer.Serialize(writer, "µA");
                    return;
            }
            throw new Exception("Cannot marshal type Units");
        }

        public static readonly UnitsConverter Singleton = new UnitsConverter();
    }

    internal class UpperLimitConverter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(UpperLimit) || t == typeof(UpperLimit?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            switch (reader.TokenType)
            {
                case JsonToken.String:
                case JsonToken.Date:
                    var stringValue = serializer.Deserialize<String>(reader);
                    switch (stringValue)
                    {
                        case "":
                            return new UpperLimit { Enum = DReferencePowerHigh1.Empty };
                        case "-0.31 PowerDiff":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The031PowerDiff };
                        case "-0.33 PowerDiff":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The033PowerDiff };
                        case "-0.34 PowerDiff":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The034PowerDiff };
                        case "0.00999999999999979 PowerDiff":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The000999999999999979PowerDiff };
                        case "0.04 PowerDiff":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The004PowerDiff };
                        case "1.5":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The15 };
                        case "1.82":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The182 };
                        case "2,828":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The2828 };
                        case "20.0":
                            return new UpperLimit { Enum = DReferencePowerHigh1.The200 };
                        default:
                            return new UpperLimit { Enum = DReferencePowerHigh1.Empty };

                    }
            }
            throw new Exception("Cannot unmarshal type UpperLimit");
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            var value = (UpperLimit)untypedValue;
            if (value.Enum != null)
            {
                switch (value.Enum)
                {
                    case DReferencePowerHigh1.Empty:
                        serializer.Serialize(writer, "");
                        return;
                    case DReferencePowerHigh1.The031PowerDiff:
                        serializer.Serialize(writer, "-0.31 PowerDiff");
                        return;
                    case DReferencePowerHigh1.The033PowerDiff:
                        serializer.Serialize(writer, "-0.33 PowerDiff");
                        return;
                    case DReferencePowerHigh1.The034PowerDiff:
                        serializer.Serialize(writer, "-0.34 PowerDiff");
                        return;
                    case DReferencePowerHigh1.The000999999999999979PowerDiff:
                        serializer.Serialize(writer, "0.00999999999999979 PowerDiff");
                        return;
                    case DReferencePowerHigh1.The004PowerDiff:
                        serializer.Serialize(writer, "0.04 PowerDiff");
                        return;
                    case DReferencePowerHigh1.The15:
                        serializer.Serialize(writer, "1.5");
                        return;
                    case DReferencePowerHigh1.The182:
                        serializer.Serialize(writer, "1.82");
                        return;
                    case DReferencePowerHigh1.The2828:
                        serializer.Serialize(writer, "2,828");
                        return;
                    case DReferencePowerHigh1.The200:
                        serializer.Serialize(writer, "20.0");
                        return;
                }
            }
            if (value.Integer != null)
            {
                serializer.Serialize(writer, value.Integer.Value.ToString());
                return;
            }
            throw new Exception("Cannot marshal type UpperLimit");
        }

        public static readonly UpperLimitConverter Singleton = new UpperLimitConverter();
    }

    internal class DReferencePowerHigh1Converter : JsonConverter
    {
        public override Boolean CanConvert(Type t) => t == typeof(DReferencePowerHigh1) || t == typeof(DReferencePowerHigh1?);

        public override Object ReadJson(JsonReader reader, Type t, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
            {
                return null;
            }

            var value = serializer.Deserialize<String>(reader);
            switch (value)
            {
                case "":
                    return DReferencePowerHigh1.Empty;
                case "-0.31 PowerDiff":
                    return DReferencePowerHigh1.The031PowerDiff;
                case "-0.33 PowerDiff":
                    return DReferencePowerHigh1.The033PowerDiff;
                case "-0.34 PowerDiff":
                    return DReferencePowerHigh1.The034PowerDiff;
                case "0.00999999999999979 PowerDiff":
                    return DReferencePowerHigh1.The000999999999999979PowerDiff;
                case "0.04 PowerDiff":
                    return DReferencePowerHigh1.The004PowerDiff;
                case "1.5":
                    return DReferencePowerHigh1.The15;
                case "1.82":
                    return DReferencePowerHigh1.The182;
                case "2,828":
                    return DReferencePowerHigh1.The2828;
                case "20.0":
                    return DReferencePowerHigh1.The200;
            }
            return DReferencePowerHigh1.Empty;
            //throw new Exception("Cannot unmarshal type DReferencePowerHigh1");
        }

        public override void WriteJson(JsonWriter writer, Object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (DReferencePowerHigh1)untypedValue;
            switch (value)
            {
                case DReferencePowerHigh1.Empty:
                    serializer.Serialize(writer, "");
                    return;
                case DReferencePowerHigh1.The031PowerDiff:
                    serializer.Serialize(writer, "-0.31 PowerDiff");
                    return;
                case DReferencePowerHigh1.The033PowerDiff:
                    serializer.Serialize(writer, "-0.33 PowerDiff");
                    return;
                case DReferencePowerHigh1.The034PowerDiff:
                    serializer.Serialize(writer, "-0.34 PowerDiff");
                    return;
                case DReferencePowerHigh1.The000999999999999979PowerDiff:
                    serializer.Serialize(writer, "0.00999999999999979 PowerDiff");
                    return;
                case DReferencePowerHigh1.The004PowerDiff:
                    serializer.Serialize(writer, "0.04 PowerDiff");
                    return;
                case DReferencePowerHigh1.The15:
                    serializer.Serialize(writer, "1.5");
                    return;
                case DReferencePowerHigh1.The182:
                    serializer.Serialize(writer, "1.82");
                    return;
                case DReferencePowerHigh1.The2828:
                    serializer.Serialize(writer, "2,828");
                    return;
                case DReferencePowerHigh1.The200:
                    serializer.Serialize(writer, "20.0");
                    return;
            }
            throw new Exception("Cannot marshal type DReferencePowerHigh1");
        }

        public static readonly DReferencePowerHigh1Converter Singleton = new DReferencePowerHigh1Converter();
    }
}