DC_Initlizer/PhihongSystemID/SystemID.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PhihongSystemID
{
    public class SystemID
    {
        public ModelName ModelName { get; set; }
        public string SerialNumber { get; set; }

        public string sourceString { get; set; }

        public static bool TryParse(byte[] byteData, out SystemID connectInfo)
        {
            connectInfo = null;
            if (byteData == null || byteData.Length < 14)
                return false;

            string systemIDString = null;
            try
            {
                systemIDString = Encoding.ASCII.GetString(byteData);
            }
            catch
            {
                return false;
            }

            if (!string.IsNullOrEmpty(systemIDString))
            {
                return TryParse(systemIDString, out connectInfo);
            }
            return false;
        }

        public static bool TryParse(string byteString, out SystemID connectInfo)
        {
            connectInfo = null;
            SystemID tmp = new SystemID();

            tmp.sourceString = byteString;

            if (tmp.sourceString.Length < 14)
                return false;

            if (!ModelName.TryParse(tmp.sourceString.Substring(0, 14), out var model))
                return false;
            tmp.ModelName = model;
            tmp.SerialNumber = tmp.sourceString.Substring(14);
            connectInfo = tmp;

            return true;
        }

        public string ToWifiPwd()
        {
            return SerialNumber + ModelName.ToString();
        }

        public override string ToString()
        {
            return sourceString;
        }

        public override bool Equals(object obj)
        {
            return obj.ToString() == this.ToString();
        }

        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }

        public static bool operator ==(SystemID a, SystemID b)
        {
            string stra = null, strb = null;

            if (Object.Equals(a, null))
                stra = null;
            else
                stra = a.ToString();

            if (Object.Equals(b, null))
                strb = null;
            else
                strb = b.ToString();
            return string.Equals(a, b);
        }

        public static bool operator !=(SystemID a, SystemID b)
        {
            string stra = null, strb = null;

            if (Object.Equals(a, null))
                stra = null;
            else
                stra = a.ToString();

            if (Object.Equals(b, null))
                strb = null;
            else
                strb = b.ToString();
            return !string.Equals(a, b);
        }
    }

    public class ModelName
    {
        public enum EVSE_TYPE_CAT
        {
            Unknown,
            AC,
            DC,
            Hybrid
        }

        public enum EVSE_TYPE
        {
            Unknown,
            AC_Cordset,
            AC_Wallmount,
            AC_Pedestal,
            AC_Wallmount_Excellent,
            DC_Wallmount,
            DC_Standalong,
            DC_Movable,
            DC_PowerRack_NoCabinet,
            DC_Disppenser,
            DC_OutputpowerCabinet,
            DC_Infy_30KW_GB,
            DC_PowerRack,
            DC_OutputCommunicationBox
        }

        public enum EVSE_InputConfig
        {
            Unknown, Y, D, L, S, W, T, E, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, AA
        }

        public enum EVSE_SafetyReg
        {
            Unknown,
            CE_Europoean,
            UL_NorthAmerica,
            GB_China,
            CNS_Taiwan,
            JARI_Japan,
            TR25_Singapor,
            KC_Korea,
            British_UK,
            EVready_French,
            M,
            P,
            I,
            F,
            L
        }

        public enum EVSE_network
        {
            None,
            Ethernet,
            Ble,
            EthWiFi,
            Eth4G,
            EthBle,
            EthWiFi4G,
            WiFi
        }

        public EVSE_TYPE Type { get; private set; }
        public EVSE_InputConfig InputConfig { get; private set; }
        public EVSE_SafetyReg SafetyReg { get; private set; }
        public double RatedPower { get; private set; }
        public ConnectorType[] ConnectorTypes { get; private set; }
        public EVSE_network Network { get; private set; }
        public int Generation { get; private set; }
        public string CustomCode { get; private set; }

        public EVSE_TYPE_CAT Type_Cat { get => GetTypeCat(); }

        private string _modelNameString;
        public string modelNameString
        {
            get => _modelNameString;
            set
            {
                if (TryParse(value, out var result))
                {
                    this.Type = result.Type;
                    this.InputConfig = result.InputConfig;
                    this.SafetyReg = result.SafetyReg;
                    this.RatedPower = result.RatedPower;
                    this.ConnectorTypes = result.ConnectorTypes;
                    this.Network = result.Network;
                    this.Generation = result.Generation;
                    this.CustomCode = result.CustomCode;

                    _modelNameString = value;
                }
            }
        }

        public static bool TryParse(byte[] modeNameByte, out ModelName modelName)
        {
            modelName = null;
            string modelNameString;
            try
            {
                modelNameString = Encoding.ASCII.GetString(modeNameByte);
            }
            catch
            {
                return false;
            }

            if (modelNameString.Length != 14 && modelNameString.Length != 12)
                return false;
            return TryParse(modelNameString, out modelName);
        }

        public static bool TryParse(string modeNameString, out ModelName modelName)
        {
            modelName = null;
            ModelName model = new ModelName();

            if (modeNameString == null || modeNameString.Length != 14)
                return false;
            bool isAc = modeNameString[0] == 'A';
            var typeString = modeNameString.Substring(0, 2);
            switch (typeString)
            {
                case "AC":
                    model.Type = EVSE_TYPE.AC_Cordset;
                    break;
                case "AW":
                    model.Type = EVSE_TYPE.AC_Wallmount;
                    break;
                case "AP":
                    model.Type = EVSE_TYPE.AC_Pedestal;
                    break;
                case "DW":
                    model.Type = EVSE_TYPE.DC_Wallmount;
                    break;
                case "DS":
                    model.Type = EVSE_TYPE.DC_Standalong;
                    break;
                case "DM":
                    model.Type = EVSE_TYPE.DC_Movable;
                    break;
                case "DR":
                    model.Type = EVSE_TYPE.DC_PowerRack_NoCabinet;
                    break;
                case "DD":
                    model.Type = EVSE_TYPE.DC_Disppenser;
                    break;
                case "DO":
                    model.Type = EVSE_TYPE.DC_OutputpowerCabinet;
                    break;
                case "DQ":
                    model.Type = EVSE_TYPE.DC_Infy_30KW_GB;
                    break;
                case "DK":
                    model.Type = EVSE_TYPE.DC_PowerRack;
                    break;
                case "DX":
                    model.Type = EVSE_TYPE.DC_OutputCommunicationBox;
                    break;
                default:
                    return false;
            }

            var inputConfigStr = modeNameString.Substring(2, 1);
            switch (inputConfigStr)
            {
                case "Y":
                    model.InputConfig = EVSE_InputConfig.Y;
                    break;
                case "D":
                    model.InputConfig = EVSE_InputConfig.D;
                    break;
                case "L":
                    model.InputConfig = EVSE_InputConfig.L;
                    break;
                case "S":
                    model.InputConfig = EVSE_InputConfig.S;
                    break;
                case "W":
                    model.InputConfig = EVSE_InputConfig.W;
                    break;
                case "T":
                    model.InputConfig = EVSE_InputConfig.T;
                    break;
                case "E":
                    model.InputConfig = EVSE_InputConfig.E;
                    break;
                case "0":
                    model.InputConfig = EVSE_InputConfig.A0;
                    break;
                case "1":
                    model.InputConfig = EVSE_InputConfig.A1;
                    break;
                case "2":
                    model.InputConfig = EVSE_InputConfig.A2;
                    break;
                case "3":
                    model.InputConfig = EVSE_InputConfig.A3;
                    break;
                case "4":
                    model.InputConfig = EVSE_InputConfig.A4;
                    break;
                case "5":
                    model.InputConfig = EVSE_InputConfig.A5;
                    break;
                case "6":
                    model.InputConfig = EVSE_InputConfig.A6;
                    break;
                case "7":
                    model.InputConfig = EVSE_InputConfig.A7;
                    break;
                case "8":
                    model.InputConfig = EVSE_InputConfig.A8;
                    break;
                case "9":
                    model.InputConfig = EVSE_InputConfig.A9;
                    break;
                case "A":
                    model.InputConfig = EVSE_InputConfig.AA;
                    break;
                default:
                    return false;
            }

            var safeRegStr = modeNameString.Substring(3, 1);
            switch (safeRegStr)
            {
                case "E":
                    model.SafetyReg = EVSE_SafetyReg.CE_Europoean;
                    break;
                case "U":
                    model.SafetyReg = EVSE_SafetyReg.UL_NorthAmerica;
                    break;
                case "G":
                    model.SafetyReg = EVSE_SafetyReg.GB_China;
                    break;
                case "C":
                    model.SafetyReg = EVSE_SafetyReg.CNS_Taiwan;
                    break;
                case "J":
                    model.SafetyReg = EVSE_SafetyReg.JARI_Japan;
                    break;
                case "T":
                    model.SafetyReg = EVSE_SafetyReg.TR25_Singapor;
                    break;
                case "K":
                    model.SafetyReg = EVSE_SafetyReg.KC_Korea;
                    break;
                case "B":
                    model.SafetyReg = EVSE_SafetyReg.British_UK;
                    break;
                case "Z":
                    model.SafetyReg = EVSE_SafetyReg.EVready_French;
                    break;
                case "M":
                    model.SafetyReg = EVSE_SafetyReg.M;
                    break;
                case "P":
                    model.SafetyReg = EVSE_SafetyReg.P;
                    break;
                case "I":
                    model.SafetyReg = EVSE_SafetyReg.I;
                    break;
                case "F":
                    model.SafetyReg = EVSE_SafetyReg.F;
                    break;
                case "L":
                    model.SafetyReg = EVSE_SafetyReg.L;
                    break;
                default:
                    return false;
            }

            var ratedPowerStr = modeNameString.Substring(4, 3);
            if (!int.TryParse(ratedPowerStr, out int ratedPowerNum) &&
                ratedPowerNum > 0)
                return false;
            double realnum = (double)ratedPowerNum / 10;
            var exp = ratedPowerNum % 10;
            model.RatedPower = (double)(realnum * (10 ^ exp));

            model.ConnectorTypes = new ConnectorType[3];
            var connectorListStr = modeNameString.Substring(7, 3);
            /*
            model.ConnectorTypes.Add(ConnectorType.CHadeMO);
            model.ConnectorTypes.Add(ConnectorType.CCS);
            model.ConnectorTypes.Add(ConnectorType.IEC);
            */
            for (int index = 0; index < 3; index++)
            {
                var connectorStr = connectorListStr.Substring(index, 1);

                switch (connectorStr)
                {
                    case "0":
                        //none connecter
                        model.ConnectorTypes[index] = ConnectorType.None;
                        break;
                    case "1":
                    case "2":
                    case "3":
                    case "4":
                    case "5":
                    case "6":
                    case "7":
                    case "8":
                        model.ConnectorTypes[index] = ConnectorType.AC;
                        break;
                    case "J":
                    case "K":
                        model.ConnectorTypes[index] = ConnectorType.CHadeMO;
                        break;
                    case "U":
                    case "V":
                    case "T":
                    case "N":
                    case "R":
                        model.ConnectorTypes[index] = ConnectorType.CCS1;
                        break;
                    case "E":
                    case "F":
                    case "D":
                    case "M":
                    case "P":
                        model.ConnectorTypes[index] = ConnectorType.CCS2;
                        break;
                    case "G":
                        model.ConnectorTypes[index] = ConnectorType.GBT;
                        break;
                    case "C":
                        model.ConnectorTypes[index] = ConnectorType.ChaoJi;
                        break;
                    case "W":
                        model.ConnectorTypes[index] = ConnectorType.Wireless;
                        break;
                    default:
                        return false;
                }
            }

            var networkOpStr = modeNameString.Substring(10, 1);
            switch (networkOpStr)
            {
                case "0":
                    model.Network = EVSE_network.None;
                    break;
                case "E":
                    model.Network = EVSE_network.Ethernet;
                    break;
                case "B":
                    model.Network = EVSE_network.Ble;
                    break;
                case "W":
                    model.Network = EVSE_network.EthWiFi;
                    break;
                case "T":
                    model.Network = EVSE_network.Eth4G;
                    break;
                case "U":
                    model.Network = EVSE_network.EthBle;
                    break;
                case "D":
                case "A":
                    model.Network = EVSE_network.EthWiFi4G;
                    break;
                case "F":
                    model.Network = EVSE_network.WiFi;
                    break;
                default:
                    return false;
            }

            var genStr = modeNameString.Substring(11, 1);
            if (!int.TryParse(genStr, out var genInt))
                return false;
            model.Generation = genInt;

            model.CustomCode = modeNameString.Substring(12, 2);
            model._modelNameString = modeNameString;

            modelName = model;
            return true;
        }

        public ModelName() { }

        public override string ToString()
        {
            return modelNameString;
        }

        private EVSE_TYPE_CAT GetTypeCat()
        {
            string typeString = Type.ToString();
            if (typeString.Contains("AC"))
                return EVSE_TYPE_CAT.AC;
            else if (typeString.Contains("DC"))
                return EVSE_TYPE_CAT.DC;
            return EVSE_TYPE_CAT.Hybrid;
        }
    }
}