using System;

using System.Collections.Generic;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

​

namespace Test

{

    public class Program

    {

        static string EMPTY_CELL = "------------";

        public class Partition<T> : List<T>

        {

            public Partition(int capacity): base (capacity)

            {

            }

​

            public string minInclusive

            {

                get;

                set;

            }

​

            public string maxExclusive

            {

                get;

                set;

            }

        }

        /*

          Attempting to insert more than items allowed per partition with a specific partition key.

          With no shuffle shard all writes will go to one partition.

          With Shuffle shard the writes get randomly distributed (we can do better!)        

        */

        public static void Main()

        {

            //noShuffleWrite();

            withShuffleWrite();

        }

​

        static void withShuffleWrite()

        {

            var partitionsNumber = 25;

            var partitions = makePartitions(partitionsNumber);

            var slugs = new string[] {"rey","foo","por","toc","rot"};

            for (var i = 0; i < 20; i++)

            {

                var partitionKey = "div200"; // should be spread across slugs.length partitions

                var slug = slugs.OrderBy(a => Guid.NewGuid()).First();

                partitionKey = partitionKey + slug;

                var hashedGuid = hash(partitionKey);

                //Console.WriteLine("new groupid => " + groupId + " with hashvalue:" + hashedGuid);

                var partition = partitions.FirstOrDefault(p => Convert.ToUInt64(p.minInclusive, 16) <= Convert.ToUInt64(hashedGuid, 16) && Convert.ToUInt64(hashedGuid, 16) < Convert.ToUInt64(p.maxExclusive, 16));

                try

                {

                   // Console.WriteLine("Found partition:" + (partition != null));

                    putRecord(partition, partitionKey);

                }

                catch (Exception e)

                {

                    Console.WriteLine("insert failed for key:" + partitionKey + " with error:" + e.Message);

                }

            }

​

            dumpTable(partitions);

        }

​

        static void noShuffleWrite()

        {

            var partitionsNumber = 25;

            var partitions = makePartitions(partitionsNumber);

            var partitionKey = "div200"; // should go to partition 23

            for (var i = 0; i < 20; i++)

            {

                var hashedGuid = hash(partitionKey);

                var partition = partitions.FirstOrDefault(p => Convert.ToUInt64(p.minInclusive, 16) <= Convert.ToUInt64(hashedGuid, 16) && Convert.ToUInt64(hashedGuid, 16) < Convert.ToUInt64(p.maxExclusive, 16));

                try

                {

                    putRecord(partition, partitionKey);

                }

                catch (Exception e)

                {

                    Console.WriteLine("insert failed for key:" + partitionKey + " with error:" + e.Message);

                }

            }

​

            dumpTable(partitions);

        }

​

        static void putRecord(Partition<string> partition, string key)

        {

            var inserted = false;

            if (key.Length < EMPTY_CELL.Length)

            {

                for(var t = 0 ; key.Length < EMPTY_CELL.Length; t++)

                {

                    key += "-"; 

                }

            }

            for (var i = 0; i < partition.Count(); i++)

            {

                if ((partition[i] as string).Equals(EMPTY_CELL))

                {

                    partition[i] = key;

                    inserted = true;

                    break;

                }

            }

​

            if (!inserted)

                throw new ApplicationException("Partition surpassed capacity it will now split");

        }

​

        static void dumpTable(List<Partition<string>> partitions)

        {

            var items = new List<string>();

            for (var i = 0; i < 10; i++)

            {

                var row = new List<string>();

                var p = 0;

                foreach (var partition in partitions)

                {

                    row.Add(p + " " + partition[i]);

                    p++;

                }

​

                items.Add(string.Join("|", row));

            }

​

            foreach (var item in items)

            {

                Console.WriteLine(item);

            }

        }

​

        static List<Partition<string>> makePartitions(int number)

        {

            var partitions = new List<Partition<string>>();

            var partitionRanges = getPartitionRanges();

            for (var i = 0; i < partitionRanges.Count(); i += 2)

            {

                var partition = new Partition<string>(10);

                partition.minInclusive = partitionRanges[i];

                partition.maxExclusive = partitionRanges[i + 1];

                for (var j = 0; j < 10; j++)

                {

                    partition.Add(EMPTY_CELL);

                }

​

                partitions.Add(partition);

            }

​

            return partitions;

        }

​

        static string[] getPartitionRanges()

        {

            return "0,05C1A53DB92960,05C1A53DB92960,05C1B53DB92960,05C1B53DB92960,05C1BF5D153D90,05C1BF5D153D90,05C1C53DB92960,05C1C53DB92960,05C1C9CD673378,05C1C9CD673378,05C1CF5D153D90,05C1CF5D153D90,05C1D1F5E1A3D4,05C1D1F5E1A3D4,05C1D53DB92960,05C1D53DB92960,05C1D7858FADEC,05C1D7858FADEC,05C1D9CD673378,05C1D9CD673378,05C1DD153DB904,05C1DD153DB904,05C1DF5D153D90,05C1DF5D153D90,05C1E151F5E18E,05C1E151F5E18E,05C1E1F5E1A3D4,05C1E1F5E1A3D4,05C1E399CD671A,05C1E399CD671A,05C1E53DB92960,05C1E53DB92960,05C1E5E1A3EBA6,05C1E5E1A3EBA6,05C1E7858FADEC,05C1E7858FADEC,05C1E9297B7132,05C1E9297B7132,05C1E9CD673378,05C1E9CD673378,05C1EB7151F5BE,05C1EB7151F5BE,05C1ED153DB904,05C1ED153DB904,05C1EDB9297B4A,05C1EDB9297B4A,05C1EF5D153D90,05C1EF5D153D90,FF".Split(',');

        }

​

        static string hash(string keyValue)

        {

            uint hash;

            using (MemoryStream stream = new MemoryStream())

            {

                using (BinaryWriter writer = new BinaryWriter(stream))

                {

                    writer.Write((byte)8);

                    writer.Write(Encoding.UTF8.GetBytes(keyValue));

                    writer.Write((byte)0);

                    hash = MurmurHash(stream.GetBuffer(), stream.Length, 0);

                }

            }

​

            return ToHexEncodedBinaryString(hash);

        }

​

        static uint MurmurHash(byte[] bytes, long length, uint seed = 0)

        {

            uint num = 0xcc9e2d51;

            uint num2 = 0x1b873593;

            uint n = seed;

            for (int i = 0; i < (length - 3L); i += 4)

            {

                uint num5 = BitConverter.ToUInt32(bytes, i) * num;

                num5 = RotateLeft(num5, 15) * num2;

                n ^= num5;

                n = (RotateLeft(n, 13) * 5) + 0xe6546b64;

            }

​

            uint num6 = 0;

            long num7 = length & 3L;

            if ((num7 <= 3L) && (num7 >= 1L))

            {

                switch (((int)(num7 - 1L)))

                {

                    case 0:

                        num6 ^= bytes[(int)((IntPtr)(length - 1L))];

                        break;

                    case 1:

                        num6 ^= (uint)(bytes[(int)((IntPtr)(length - 1L))] << 8);

                        num6 ^= bytes[(int)((IntPtr)(length - 2L))];

                        break;

                    case 2:

                        num6 ^= (uint)(bytes[(int)((IntPtr)(length - 1L))] << 0x10);

                        num6 ^= (uint)(bytes[(int)((IntPtr)(length - 2L))] << 8);

                        num6 ^= bytes[(int)((IntPtr)(length - 3L))];

                        break;

                }

            }

​

            num6 *= num;

            num6 = RotateLeft(num6, 15) * num2;

            n ^= num6;

            n ^= (uint)length;

            n ^= n >> 0x10;

            n *= 0x85ebca6b;

            n ^= n >> 13;

            n *= 0xc2b2ae35;

            return (n ^ (n >> 0x10));

        }

​

        static uint RotateLeft(uint n, int numBits) => ((n << numBits) | (n >> (0x20 - numBits)));

        //

        // Helper for Hex Encoded String

        //

        static string ToHexEncodedBinaryString(double value)

        {

            string str;

            byte[] buffer = new byte[0x150];

            using (MemoryStream stream = new MemoryStream(buffer))

            {

                using (BinaryWriter writer = new BinaryWriter(stream))

                {

                    WriteForBinaryEncoding(writer, value);

                    str = ToHex(buffer, 0, (int)stream.Position);

                }

            }

​

            return str;

        }

​

        static void WriteForBinaryEncoding(BinaryWriter binaryWriter, double value)

        {

            binaryWriter.Write((byte)5);

            ulong num = EncodeDoubleAsUInt64(value);

            binaryWriter.Write((byte)(num >> 0x38));

            num = num << 8;

            byte num2 = 0;

            bool flag = true;

            do

            {

                if (!flag)

                {

                    binaryWriter.Write(num2);

                }

                else

                {

                    flag = false;

                }

​

                num2 = (byte)((num >> 0x38) | ((ulong)1L));

                num = num << 7;

            }

            while (num != 0L);

            binaryWriter.Write((byte)(num2 & 0xfe));

        }

​

        static ulong EncodeDoubleAsUInt64(double value)

        {

            ulong num = (ulong)BitConverter.DoubleToInt64Bits(value);

            ulong num2 = 9223372036854775808L;

            if (num >= num2)

            {

                return (~num + ((ulong)1L));

            }

​

            return (num ^ num2);

        }

​

        static string ToHex(byte[] bytes, int start, int length)

        {

            // create lookup table

            ushort[] lookupArray = new ushort[0x100];

            for (int i = 0; i < 0x100; i++)

            {

                string str = i.ToString("X2", CultureInfo.InvariantCulture);

                lookupArray[i] = (ushort)(str[0] + (str[1] << 8));

            }

​

            // ToHex

            char[] chArray = new char[length * 2];

            for (int i = 0; i < length; i++)

            {

                ushort num2 = lookupArray[bytes[i + start]];

                chArray[2 * i] = (char)(num2 & 0xff);

                chArray[(2 * i) + 1] = (char)(num2 >> 8);

            }

​

            return new string (chArray);

        }

    }

}