using System;

//##########################################################################################################

//https://metadataconsulting.blogspot.com/2019/12/CSharp-Convert-a-GUID-to-a-Darwin-Descriptor-and-back.html

//##########################################################################################################

public static class Program

{

    class GUID2DD

    {

        //   Conversion of this VB code to C# by http://metadataconsulting.blogspot.com/

        //   Some portions modernized, but an interesting exercise converting from a old language unexpressive to more modern lang

        //   Source Code: https://www.symantec.com/connect/articles/working-darwin-descriptors

        //

        //   Auto VB translators 

        //   1.https://www.developerfusion.com/tools/convert/vb-to-csharp/?batchId=8e249124-06d2-4955-a238-dc2914a9cd3d - not good

        //   2.https://www.carlosag.net/tools/codetranslator/ - super fast!

​

        //  'VB Code - Copyright EdT 2012

        //  'Script converts standard GUID to Darwin Descriptor and vice versa

        //  'A standard GUID requires 38 characters and contains 5 groups of hexadecimal characters separated by dashes.

        //  'The valid format for a standard GUID is:

        //  '{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}

        //  'where X is a hex digit (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F).

        // 

        //  'This program can copy the result of the conversion process to the clipboard.

        //  'To do this it uses the MS Office Word automation object, so for this to work,

        //  'a version of MSOffice must be present. Unfortunately, VBScript does not have

        //  'a native method for copying variables to the clipboard.

        public string GetConvertedGUID(string strProductCode) {

            string Block1;

            string Block2;

            string Block3;

            string Block4;

            string strMungedCode = string.Empty; 

            long Dec1;

            long Dec2;

            long Dec3;

            long Dec4;

            string strPart1; 

            string strPart2; 

            string strPart3; 

            string strPart4; 

            const int intArraySize = 32;

            int[] arrSequence = new int[]{2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 11, 12, 13, 14, 28, 29, 26, 27, 23, 24, 21, 22, 36, 37, 34, 35, 32, 33, 30, 31};

           // Generate the RegProduct Code

            for (int intIndex = 0; intIndex <= (intArraySize - 1); intIndex++) 

            {

                strMungedCode = (strMungedCode + strProductCode.Substring((arrSequence[intIndex] - 1), 1));

            }

            Block1 = strMungedCode.Substring(0, 8);

            Block2 = strMungedCode.Substring(8, 8);

            Block3 = strMungedCode.Substring(16, 8);

            Block4 = strMungedCode.Substring(24, 8);

            Dec1 = HextoDec(Block1);

            strPart1 = DecToBase85(Dec1);

            Dec2 = HextoDec(Block2);

            strPart2 = DecToBase85(Dec2);

            Dec3 = HextoDec(Block3);

            strPart3 = DecToBase85(Dec3);

            Dec4 = HextoDec(Block4);

            strPart4 = DecToBase85(Dec4);

​

            return (strPart1.ReverseString()

                        + (strPart2

                        + (strPart3 + strPart4.ReverseString())));

        }

​

        public long HextoDec(string strHex)

        {

            //string strDigit;

            //int intDigit;

            //int intValue;

            long lngResult = 0;

​

            ////for (int intIndex = strHex.Length; (intIndex <= 1); intIndex = (intIndex + -1)) 

            //for (int intIndex = strHex.Length; intIndex >= 1; intIndex--)

            //{

            //    strDigit = strHex.Substring((intIndex - 1), 1);

            //    intDigit = (("0123456789ABCDEF".IndexOf(strDigit.ToUpper()) + 1) - 1);

            //    if ((intDigit >= 0)) {

            //        //intValue = (intDigit * (16 | (strHex.Length - intIndex)));

            //        // TODO: Warning!!! The operator should be an XOR ^ instead of an OR, but not available in CodeDOM

​

            //        //Mon 09-Dec-19 6:54pm metadataconsulting.ca - XOR used

            //        intValue = (intDigit * (16 ^ (strHex.Length - intIndex)));

            //        lngResult = (lngResult + intValue);

            //    }

            //    else {

            //        lngResult = 0;

            //        intIndex = 0;

            //        //stop the loop

            //    }

            //}

​

            lngResult = Convert.ToInt64(strHex, 16); 

            return lngResult;

        }

        private string DecitoHex(int ddec)

        {

            //// Must return eight hex bytes

            //decimal hex1;

            //string hex2 = ""; 

            //int hexlen;

​

            //while ((strDec > 15)) {

​

            //    hex1 = (( (strDec / 16) - (int)(strDec / 16) ) * 16);

​

            //    hex2 = ("0123456789ABCDEF".Substring(hex1.ToString(), 1) + hex2);

            //    strDec = int((strDec / 16));

​

            //    hex2 = ("0123456789ABCDEF".Substring(strDec, 1) + hex2);

            //    hexlen = hex2.Length;

            //    DecToHex = (string((8 - hexlen), "0") + hex2);

            //}

​

            return ddec.ToString("X8");

        }

​

        public string DecToBase85(long strDecimal) {

            // Multiples of 85 = 85, 7225, 614125, 52200625

            int strDec = (int)strDecimal;

​

            string Base85 = "!$%&\'()*+,-.0123456789=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{}~";

            int num;

            string quint1;

            string quint2;

            string quint3;

            string quint4;

            string quint5;

            //int Offset;

            quint1 = "!";

            quint2 = "!";

            quint3 = "!";

            quint4 = "!";

            quint5 = "!";

​

            if ((strDecimal < 85))

            {

                //quint1 = Base85.Substring(strDec, 1);

                long mod = strDecimal % 85;

                num = (int)mod;

                quint1 = Base85.Substring(num, 1);

            }

​

            if (strDecimal > 84 && strDecimal < 7225)

            {

                //    Offset = strDec;

                //    strDec = (int)((strDec / 85));

                //    num = (((Offset / 85) 

                //                - strDec) 

                //                * 85);

                //    quint1 = Base85.Substring(num, 1);

                //    quint2 = Base85.Substring(strDec, 1);

​

                num = (int)(strDecimal / 85) % 85;

                quint1 = Base85.Substring(num, 1);

​

                long mod = strDecimal % 85;

                num = (int)mod;

                quint2 = Base85.Substring(num, 1);

            }

​

            if (((strDecimal > 7224) && (strDecimal < 614125)))

            {

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

                //quint1 = Base85.Substring(num, 1);

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

                //quint2 = Base85.Substring(num, 1);

                //quint3 = Base85.Substring(strDec, 1);

​

                num = (int)(strDecimal / 7225) % 85;

                quint1 = Base85.Substring(num, 1);

​

                num = (int)(strDecimal / 85) % 85;

                quint2 = Base85.Substring(num, 1);

​

                long mod = strDecimal % 85;

                num = (int)mod;

                quint3 = Base85.Substring(num, 1);

​

            }

​

            if (((strDecimal > 614124) && (strDecimal < 52200625)))

            {

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

                //quint1 = Base85.Substring(num, 1);

​

                num = (int)(strDecimal / 614125) % 85;

                quint1 = Base85.Substring(num, 1);

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

                //quint2 = Base85.Substring(num, 1);

​

                num = (int)(strDecimal / 7225) % 85;

                quint2 = Base85.Substring(num, 1);

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

                //quint3 = Base85.Substring(num, 1);

                //quint4 = Base85.Substring(strDec, 1);

​

                num = (int)(strDecimal / 85) % 85;

                quint3 = Base85.Substring(num, 1);

​

                long mod = strDecimal % 85;

                num = (int)mod;

                quint4 = Base85.Substring(num, 1);

            }

​

            if ((strDecimal > 52200624))

            {

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

                num = (int)(strDecimal/52200625) % 85; 

                quint1 = Base85.Substring(num, 1);

​

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

​

                num = (int)(strDecimal / 614125) % 85; 

                quint2 = Base85.Substring(num, 1);

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

​

                num = (int)(strDecimal / 7225) % 85;

                quint3 = Base85.Substring(num, 1);

                //Offset = strDec;

                //strDec = (int)((strDec / 85));

                //num = (((Offset / 85) 

                //            - strDec) 

                //            * 85);

                num = (int)(strDecimal / 85) % 85;

                quint4 = Base85.Substring(num, 1);

​

                long mod = strDecimal % 85;

                num = (int)mod; 

                quint5 = Base85.Substring(num, 1);

            }

            return (quint1 

                        + (quint2 

                        + (quint3 

                        + (quint4 + quint5))));

        }

​

​

​

        //Function DDtoHex(darwin) renamed from VB

        public string DDtoGUID(string darwin) {

            string quad1;

            string quad2;

            string quad3;

            string quad4;

            string mungedStr;

            quad1 = darwin.Substring(0, 5);

            quad1 = QuadtoHex(quad1);

            quad2 = darwin.Substring(5, 5);

            quad2 = QuadtoHex(quad2);

            quad3 = darwin.Substring(10, 5);

            quad3 = QuadtoHex(quad3);

            quad4 = darwin.Substring(15, 5);

            quad4 = QuadtoHex(quad4);

            mungedStr = (quad1 

                        + (quad2 

                        + (quad3 + quad4)));

            return ReconstructProductCode(mungedStr);

        }

        public string QuadtoHex(string quad) {

            char chr;

            string Base85;

            int b85;

            int ddec;

            Base85 = "!$%&\'()*+,-.0123456789=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{}~";

            ddec = 0;

            for (int i = 5; i >= 1; i--)

            {

                //chr = (char)quad.Substring((i - 1), 1);

                chr = quad[(i-1)];  

                b85 = ((Base85.IndexOf(chr) + 1) - 1);

                ddec = (ddec + b85);

                if ((i > 1)) {

                    ddec = (ddec * 85);

                }

            }

​

            return DecitoHex(ddec);

        }

​

​

        public string ReconstructProductCode(string munged) {

            string strProductCode;

            const int intArraySize = 32;

            strProductCode = "{";

            int[] arrSequence = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 13, 14, 15, 16, 9, 10, 11, 12, 23, 24, 21, 22, 19, 20, 17, 18, 31, 32, 29, 30, 27, 28, 25, 26};

            // // Generate the Product Code

            for (int intIndex = 0; (intIndex 

                        <= (intArraySize - 1)); intIndex++) {

                strProductCode = (strProductCode + munged.Substring((arrSequence[intIndex] - 1), 1));

                if (((intIndex == 7) 

                            || ((intIndex == 11) 

                            || ((intIndex == 15) 

                            || (intIndex == 19))))) {

                    strProductCode = (strProductCode + "-");

                }

            }

            return (strProductCode + "}");

        }

    }

    public static string ReverseString(this string s)

    {

        if (string.IsNullOrEmpty(s))

            return s; 

​

        char[] array = new char[s.Length];

        int forward = 0;

        for (int i = s.Length - 1; i >= 0; i--)

        {

            array[forward++] = s[i];

        }

        return new string(array);

    }

​

    public static void Main()

    {

         GUID2DD conv = new GUID2DD();

​

        string code = "w_1^VX!!!!!!!!!MKKSk"; 

        //string code = "{91120000-0030-0000-0000-0000000ff1ce}"; //expect from above

        string result = string.Empty;

​

        // check if this is a GUID

        if ((code.Length == 38))

        {

​

            if ((code.Substring(0, 1) == "{"))

                result = conv.GetConvertedGUID(code);

​

        }

        else if ((code.Length == 20))

        {

​

            result = conv.DDtoGUID(code);

        }

        else

        {

​

            result = "Format of string submitted does not match that of a regular GUID or a Darwin Descriptor. Entries must" +

                " be of the form {xxxxxxxx-xxxx-xxxx-xxxx-Xxxxxxxxxxxx} or xxxxxxxxxxxxxxxxxxxx (len=20)";

        }

​

        Console.WriteLine(code+"  => " + result);

​

    }

}