#include <stdio.h>
#include <string.h>
#include <stdlib.h>

static const unsigned char base64_encode[] =
	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	"abcdefghijklmnopqrstuvwxyz"
	"0123456789+/";

static const unsigned char hex_encode[] =
	"0123456789abcdef";

/*
 * This functions accepts a string and returns it base64 encoded
*/
void three_bytes_to_base64(char * encode, int bytes_to_print, char *result)
{
	unsigned char one, two, three, four;
	unsigned char tmp;
	char ret[4];
	
	// first six bits
	one = encode[0] >> 2;
	ret[0] = base64_encode[one];
	if(bytes_to_print-- > 0)
		result[0] = ret[0];
	// second six bits
	// two last bits of first byte
	tmp = encode[0] & 0x03;
	two = encode[1] >> 4;
	tmp = tmp << 4;
	two = tmp | two;
	ret[1] = base64_encode[two];
	if(bytes_to_print-- > 0)
		result[1] = ret[1];
	// second six bits
	// two last bits of first byte
	// third six bits
	tmp = encode[1] & 0x0F;
	tmp = tmp << 2;
	three = encode[2] & 0xC0;
	three = three >> 6;
	three = tmp | three;
	ret[2] = base64_encode[three];
	if(bytes_to_print-- > 0)
		result[2] = ret[2];
	// last six bit11s
	four = encode[2] & 0x3F;
	ret[3] = base64_encode[four];
	ret[4] = '\0';
	if(bytes_to_print-- > 0)
		result[3] = ret[3];
	}




static char string_to_hex_map[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
				   0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
				   0x0E, 0x0F};
/*
 * This function converts the first char of a string into its corresponding 
 * hex value
 *
 * @return On Sucess return 0, if char is no valid hex value returns -1
 */
int hex_char_to_bit(char toEncode)
{
	char encode;
	switch(toEncode) {
		case '0':
			encode = string_to_hex_map[0];
			break;
		case '1':
			encode = string_to_hex_map[1];
			break;
		case '2':
			encode = string_to_hex_map[2];
			break;
		case '3':
			encode = string_to_hex_map[3];
			break;
		case '4':
			encode = string_to_hex_map[4];
			break;
		case '5':
			encode = string_to_hex_map[5];
			break;
		case '6':
			encode = string_to_hex_map[6];
			break;
		case '7':
			encode = string_to_hex_map[7];
			break;
		case '8':
			encode = string_to_hex_map[8];
			break;
		case '9':
			encode = string_to_hex_map[9];
			break;
		case 'a':
			encode = string_to_hex_map[10];
			break;
		case 'b':
			encode = string_to_hex_map[11];
			break;
		case 'c':
			encode = string_to_hex_map[12];
			break;
		case 'd':
			encode = string_to_hex_map[13];
			break;
		case 'e':
			encode = string_to_hex_map[14];
			break;
		case 'f':
			encode = string_to_hex_map[15];
			break;
		default:
			return -1;
	}

	return encode;

}


void two_char_hex(char *start, char *result)
{
	char first = hex_char_to_bit(start[0]);
	char second = hex_char_to_bit(start[1]);
	
	*result = first;
	*result = *result << 4;
	*result = *result | second;
}

int convert_hex_string_to_binary(char *encode, char* result)
{
	int i;
	int length = strlen(encode);

	for(i = 0;i< length/2;i++)
		two_char_hex(&encode[i*2], &result[i]);

	return i;
}

int convert_to_base64(char *encode, char *result)
{
	int length = strlen(encode);
	
	int rounds = length / 3;
	int bytes_last_round = length % 3;
	int i;

	for (i=0;i<rounds;i++) {
		three_bytes_to_base64(encode + i*3,4, &result[i*4]);
	}
	// in der letzen runde nicht mehr alle ausgeben
	// nur noch 3-leftover
	if (bytes_last_round > 0) {
		three_bytes_to_base64(encode + i*3, 1+bytes_last_round, &result[i*4]);

		for(i=0;i<(3-bytes_last_round);i++)
			result[i*4+(1+bytes_last_round)] = '=';
	}

}

void xor_string(char *str1, char* str2, char *result) {
	int length = strlen(str1);
	int i;
	for(i=0;i<length;i++)
		result[i] = str1[i] ^ str2[i];
	
	return;
		
}

void hex_binary_to_string(char *str1, char *result)
{
	int i;
	int length = strlen(str1);
	int tmp = 0;

	for(i=0;i<length;i++) {
		tmp = str1[i] & 0xF0;
		tmp = tmp >> 4;
		result[i] = hex_encode[tmp];
		tmp = str1[i] & 0x0F;
		result[i+1] = hex_encode[tmp];
	}
}

int main(int argc, char **argv)
{
	if (argc == 3 ) {
		int length = strlen(argv[1]);
		char *tmp = malloc(length);
		char *tmp2 = malloc(length);
		char *base64= malloc(length);
		char *__xor_string = malloc(length);
		char *back_hex = malloc(length);
		int i = convert_hex_string_to_binary(argv[1], tmp);
		int j = convert_hex_string_to_binary(argv[2], tmp2);
		xor_string(tmp, tmp2, __xor_string);
		hex_binary_to_string(tmp2, back_hex);
		printf("%s\n", tmp);
		printf("%s\n", tmp2);
		printf("%s\n", argv[2]);
		printf("%s\n", back_hex);
		printf("%s\n", __xor_string);
		convert_to_base64(tmp, base64);
		//printf("%s\n", base64);
	}
}