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

// declaram tipul "byte"
typedef unsigned char byte;

// declaram tabelul de corespondenta baza 64
const char* tabel_b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// declaram functia de conversie din baza 64 inapoi in binar
byte* B64_DEC(char* intrare, unsigned int* dimensiune_iesire)
{
	return NULL;
}

// declaram functia de conversie din binar in baza 64
char* B64_ENC(byte* intrare, unsigned int lungime)
{
	// sa facem o bucla care merge pe sirul intrare din 3 in 3 pozitii, cat timp pozitia este mai
	// mica decat lungimea sirului
	for (int i = 0; i + 2 < lungime; i += 3)
	{
		byte primii_6 = intrare[i + 0] >> 2;
		byte ultimii_2 = intrare[i + 0] & 0b00000011;

		byte primii_4 = intrare[i + 1] >> 4;
		byte ultimii_4 = intrare[i + 1] & 0b00001111;

		byte primii_2 = intrare[i + 2] >> 6;
		byte ultimii_6 = intrare[i + 2] & 0b00111111;

		byte prima_valoare = primii_6;
		byte a_doua_valoare = ultimii_2 << 4 | primii_4;
		byte a_treia_valoare = ultimii_4 << 2 | primii_2;
		byte a_patra_valoare = ultimii_6;

		char prima_litera = tabel_b64[prima_valoare];
		char a_doua_litera = tabel_b64[a_doua_valoare];
		char a_treia_litera = tabel_b64[a_treia_valoare];
		char a_patra_litera = tabel_b64[a_patra_valoare];

		printf("%c%c%c%c", prima_litera, a_doua_litera, a_treia_litera, a_patra_litera);
	}

	if (lungime % 3 == 1)
	{
		intrare[lungime - 1]; // 3f ‭001111    11‬
		// ne-a ramas 1 byte. deci putem scoate inca 2 caractere B64
		// primii 6 biti reprezinta 1 caracter. ultimii 2 biti reprezinta
		// al doilea caracter
		char primii_6 = intrare[lungime - 1] >> 2;
		char ultimii_2 = intrare[lungime - 1] & 0b00000011;
		ultimii_2 = ultimii_2 << 4;

		char penultima_litera = tabel_b64[primii_6];
		char ultima_litera = tabel_b64[ultimii_2];

		printf("%c%c==", penultima_litera, ultima_litera);
	}
	else if (lungime % 3 == 2)
	{
		intrare[lungime - 2];
		intrare[lungime - 1];
		// luam primii 6 biti din penultimul byte. -> il indexam si aflam caracterul B64
		// luam ultimii 2 biti din penltimu byte, ii adunam cu primii 4 biti din ultimul byte ->
		// il indexam si aflam caracterul b64
		// luam ultimii 4 biti din ultimul byte, ii completam cu 2 biti de 0
		// -> indexam si aflam caracterul B64

		byte primii_6 = intrare[lungime - 2] >> 2;
		byte ultimii_2 = intrare[lungime - 2] & 0b00000011;
		byte primii_4 = intrare[lungime - 1] >> 4;
		byte ultimii_4 = intrare[lungime - 1] & 0b00001111;

		char antepenultima_litera = tabel_b64[primii_6];
		char penultima_litera = tabel_b64[ultimii_2 << 4 | primii_4];
		char ultima_litera = tabel_b64[ultimii_4 << 2];


		printf("%c%c%c=", antepenultima_litera, penultima_litera, ultima_litera);


	}


	return NULL;
}

// declaram o functie pentru testat functiile de conversie
void test()
{
	FILE* pFile;
	long lSize;
	byte* buffer;
	size_t result;

	 fopen_s(&pFile,"E:/games/Diablo III/x64/Diablo III64.exe", "rb");
	if (pFile == NULL) { fputs("File error", stderr); exit(1); }

	// obtain file size:
	fseek(pFile, 0, SEEK_END);
	lSize = ftell(pFile);
	rewind(pFile);

	// allocate memory to contain the whole file:
	buffer = (byte*)malloc(sizeof(byte) * lSize);
	if (buffer == NULL) { fputs("Memory error", stderr); exit(2); }

	// copy the file into the buffer:
	result = fread(buffer, 1, lSize, pFile);
	if (result != lSize) { fputs("Reading error", stderr); exit(3); }

	B64_ENC(buffer, lSize);
}
int main(int argc, char** argv)
{
	test();

	char c;
	scanf_s("%c", &c);

	return 0;
}