using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Data;
using OpenCLTemplate;

namespace OpenCL_Watch_It_Crash
{
    class Program
    {
        static void Main(string[] a1rgs)
        {
            //Initializes devices and sets up everything
            CLCalc.InitCL();

            //Creates variables that will be passed to OpenCL

            char[] C1 = new char[] { '0', '1', '2', '3' };
            char[] C2 = new char[] { '0', '1', '2', '3' };
            char[] C3 = new char[] { '0', '1', '2', '3' };
            char[] C4 = new char[] { '0', '1', '2', '3' };
            char[] C5 = new char[] { '0', '1', '2', '3' };
            char[] C6 = new char[] { '0', '1', '2', '3' };
            char[] C7 = new char[] { '0', '1', '2', '3' };
            char[] C8 = new char[] { '0', '1', '2', '3' };
            char[] K1 = new char[] { '0', '1', '2', '3' };
            char[] K2 = new char[] { '0', '1', '2', '3' };
            char[] K3 = new char[] { '0', '1', '2', '3' };
            char[] K4 = new char[] { '0', '1', '2', '3' };
            char[] K5 = new char[] { '0', '1', '2', '3' };
            char[] K6 = new char[] { '0', '1', '2', '3' };
            char[] K7 = new char[] { '0', '1', '2', '3' };
            char[] K8 = new char[] { '0', '1', '2', '3' };
            char[] H1 = new char[] { '0', '1', '2', '3' };
            char[] H2 = new char[] { '0', '1', '2', '3' };
            char[] H3 = new char[] { '0', '1', '2', '3' };
            char[] H4 = new char[] { '0', '1', '2', '3' };
            char[] H5 = new char[] { '0', '1', '2', '3' };
            char[] H6 = new char[] { '0', '1', '2', '3' };
            char[] H7 = new char[] { '0', '1', '2', '3' };
            char[] H8 = new char[] { '0', '1', '2', '3' };


            //This is the OpenCL source code. A string! It will not be compiled
            //by your compiler. It will be compiled by the OpenCL compiler.
            string s = @"

                        __constant int numberOfCTextsInABatch = 1;  // bitstream format:  <count><item><item><item>...<item><count><item><item>...<item>  until there are numerOfCTextsInABatch <count>/<item> sets
                        __constant int initialPermutation[64] ={58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4,62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7};
                        __constant int inversePermutation[64] ={40,8,48,16,56,24,64,32,39,7,47,15,55,23,63,31,38,6,46,14,54,22,62,30,37,5,45,13,53,21,61,29,36,4,44,12,52,20,60,28,35,3,43,11,51,19,59,27,34,2,42,10,50,18,58,26,33,1,41,9,49,17,57,25};
                        __constant int EBitSelectionTable[48] ={32,1,2,3,4,5,4,5,6,7,8,9,8,9,10,11,12,13,12,13,14,15,16,17,16,17,18,19,20,21,20,21,22,23,24,25,24,25,26,27,28,29,28,29,30,31,32,1};
                        __constant int PTable[32] ={16,7,20,21,29,12,28,17,1,15,23,26,5,18,31,10,2,8,24,14,32,27,3,9,19,13,30,6,22,11,4,25};
                        __constant int shiftTable[16]={1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
                        __constant int permutedChoice1[48]={49,41,33,25,17,9,58,50,42,34,26,18,2,59,51,43,35,27,11,3,60,52,44,36,55,47,39,31,23,15,62,54,46,38,30,22,6,61,53,45,37,29,13,5,28,20,12,4};
                        __constant int permutedChoice2[48]={14,17,11,24,1,5,3,28,15,6,21,10,23,19,12,4,26,8,16,7,27,20,13,2,41,52,31,37,47,55,30,40,51,45,33,48,44,49,39,56,34,53,46,42,50,36,29,32};
                         __constant int S1[4][16] ={
                        {14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
                        {0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
                        {4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
                        {15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}};
                          __constant int S2[4][16] ={
                        {15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
                        {3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
                        {0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
                        {13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}};
                          __constant int S3[4][16] ={
                        {10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
                        {13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
                        {13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
                        {1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}};
                          __constant int S4[4][16] ={
                        {7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
                        {13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
                        {10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
                        {3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}};
                          __constant int S5[4][16] ={
                        {2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
                        {14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
                        {4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
                        {11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}};
                          __constant int S6[4][16] ={
                        {12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
                        {10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
                        {9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
                        {4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}};
                          __constant int S7[4][16] ={
                        {4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
                        {13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
                        {1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
                        {6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}};
                          __constant int S8[4][16] ={
                        {13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
                        {1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
                        {7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
                        {2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}};


__kernel void unpackCharsToBits(__global unsigned char bytesInput[8], __global unsigned char bitsOutput[64])
{

	int X=0;
	for (int i=0; i<8; i++)
	{
		int beingTested = bytesInput[i];
		for (int j=0; j<8; j++)
		{
			int shiftCount = 7 - j;
			int mask = 1 << shiftCount;
			int testValue = mask & beingTested;
			if (testValue != 0)
				bitsOutput[X++] = 1;
			else
				bitsOutput[X++] = 0;
		}
    }

}

 
   __kernel void            majorFunction(   __global       char * C1,
                                        __global       char * C2,
                                        __global       char * C3,
                                        __global       char * C4,
                                        __global       char * C5,
                                        __global       char * C6,
                                        __global       char * C7,
                                        __global       char * C8,
                                        __global       char * K1,
                                        __global       char * K2,
                                        __global       char * K3,
                                        __global       char * K4,
                                        __global       char * K5,
                                        __global       char * K6,
                                        __global       char * K7,
                                        __global       char * K8,
                                        __global       char * H1,
                                        __global       char * H2,
                                        __global       char * H3,
                                        __global       char * H4,
                                        __global       char * H5,
                                        __global       char * H6,
                                        __global       char * H7,
                                        __global       char * H8)
                            {
                                int tid = get_global_id(0);

                                __local char CText[8];
                                __local char KText[8];
                                __local char hashText[8];

                                __local char DBlock[64];
                                __local char KBlock[64];

                                CText[0] = C1[tid];
                                CText[1] = C2[tid];
                                CText[2] = C3[tid];
                                CText[3] = C4[tid];
                                CText[4] = C5[tid];
                                CText[5] = C6[tid];
                                CText[6] = C7[tid];
                                CText[7] = C8[tid];
                                KText[0] = K1[tid];
                                KText[1] = K2[tid];
                                KText[2] = K3[tid];
                                KText[3] = K4[tid];
                                KText[4] = K5[tid];
                                KText[5] = K6[tid];
                                KText[6] = K7[tid];
                                KText[7] = K8[tid];
                                hashText[0] = H1[tid];
                                hashText[1] = H2[tid];
                                hashText[2] = H3[tid];
                                hashText[3] = H4[tid];
                                hashText[4] = H5[tid];
                                hashText[5] = H6[tid];
                                hashText[6] = H7[tid];
                                hashText[7] = H8[tid];

	                            unpackCharsToBits((__local)CText,(__local)DBlock); 
	                            unpackCharsToBits((__local)KText,(__local)KBlock);  

                                H1[tid] = (DBlock[0] == 0) ? '0' : '1';
                                H2[tid] = (DBlock[1] == 0) ? '0' : '1';
                                H3[tid] = (DBlock[2] == 0) ? '0' : '1';
                                H4[tid] = (DBlock[3] == 0) ? '0' : '1';
                                H5[tid] = (DBlock[4] == 0) ? '0' : '1';
                                H6[tid] = (DBlock[5] == 0) ? '0' : '1';
                                H7[tid] = (DBlock[6] == 0) ? '0' : '1';
                                H8[tid] = (DBlock[7] == 0) ? '0' : '1';
 
                               
                            }
                      ";

            //Use the API to compile the program
            CLCalc.Program.Compile(new string[] { s });

            //Gets a handle to the OpenCL function we will call

            CLCalc.Program.Kernel majorFunction = new CLCalc.Program.Kernel("majorFunction");

            //Copies variables to the OpenCL device memory

            CLCalc.Program.Variable varC1 = new CLCalc.Program.Variable(C1);
            CLCalc.Program.Variable varC2 = new CLCalc.Program.Variable(C2);
            CLCalc.Program.Variable varC3 = new CLCalc.Program.Variable(C3);
            CLCalc.Program.Variable varC4 = new CLCalc.Program.Variable(C4);
            CLCalc.Program.Variable varC5 = new CLCalc.Program.Variable(C5);
            CLCalc.Program.Variable varC6 = new CLCalc.Program.Variable(C6);
            CLCalc.Program.Variable varC7 = new CLCalc.Program.Variable(C7);
            CLCalc.Program.Variable varC8 = new CLCalc.Program.Variable(C8);
            CLCalc.Program.Variable varK1 = new CLCalc.Program.Variable(K1);
            CLCalc.Program.Variable varK2 = new CLCalc.Program.Variable(K2);
            CLCalc.Program.Variable varK3 = new CLCalc.Program.Variable(K3);
            CLCalc.Program.Variable varK4 = new CLCalc.Program.Variable(K4);
            CLCalc.Program.Variable varK5 = new CLCalc.Program.Variable(K5);
            CLCalc.Program.Variable varK6 = new CLCalc.Program.Variable(K6);
            CLCalc.Program.Variable varK7 = new CLCalc.Program.Variable(K7);
            CLCalc.Program.Variable varK8 = new CLCalc.Program.Variable(K8);
            CLCalc.Program.Variable varH1 = new CLCalc.Program.Variable(H1);
            CLCalc.Program.Variable varH2 = new CLCalc.Program.Variable(H2);
            CLCalc.Program.Variable varH3 = new CLCalc.Program.Variable(H3);
            CLCalc.Program.Variable varH4 = new CLCalc.Program.Variable(H4);
            CLCalc.Program.Variable varH5 = new CLCalc.Program.Variable(H5);
            CLCalc.Program.Variable varH6 = new CLCalc.Program.Variable(H6);
            CLCalc.Program.Variable varH7 = new CLCalc.Program.Variable(H7);
            CLCalc.Program.Variable varH8 = new CLCalc.Program.Variable(H8);



            CLCalc.Program.Variable[] myOwnPersonalArgs = { varC1, varC2, varC3, varC4, varC5, varC6, varC7, varC8, varK1, varK2, varK3, varK4, varK5, varK6, varK7, varK8, varH1, varH2, varH3, varH4, varH5, varH6, varH7, varH8 };





            int[] myOwnPersonalMax = new int[] { 1 };

            majorFunction.Execute(myOwnPersonalArgs, myOwnPersonalMax);
            Console.WriteLine("And now...");
            try
            {
                varH1.ReadFromDeviceTo(H1);
                varH2.ReadFromDeviceTo(H2);
                varH3.ReadFromDeviceTo(H3);
                varH4.ReadFromDeviceTo(H4);
                varH5.ReadFromDeviceTo(H5);
                varH6.ReadFromDeviceTo(H6);
                varH7.ReadFromDeviceTo(H7);
                varH8.ReadFromDeviceTo(H8);
            }
            catch (Exception eA)
            {
                Console.WriteLine("Contingency.");
                Console.WriteLine(eA.Message);
                Console.WriteLine(eA.StackTrace);
                return;
            }





            Console.WriteLine("Damned if it did not work.");
            Console.WriteLine(H1[0].ToString() + " " +
                            H2[0].ToString() + " " +
                            H3[0].ToString() + " " +
                            H4[0].ToString() + " " +
                            H5[0].ToString() + " " +
                            H6[0].ToString() + " " +
                            H7[0].ToString() + " " +
                            H8[0].ToString());
        }
    }
}