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

#define alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
static char *decoding_table = NULL;
static int mod_table[] = {0, 2, 1};

size_t getFilesize ( char * inputName )
{
    FILE * buff = fopen ( inputName, "rb" );
    fseek ( buff, 0, SEEK_END );
    size_t res = ftell (  buff );
    fclose ( buff );
    return res;
}

void build_decoding_table() {

    decoding_table = malloc(256);

    for (int i = 0; i < 64; i++)
        decoding_table[(unsigned char) alphabet[i]] = i;
}


void base64_cleanup() {
    free(decoding_table);
}

char *base64_encode(char *data,
                    size_t input_length,
                    size_t *output_length) {

    *output_length = 4 * ((input_length + 2) / 3);

    char *encoded_data = malloc(*output_length);
    if (encoded_data == NULL) return NULL;

    for (int i = 0, j = 0; i < input_length;) {

        uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0;
        uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0;
        uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0;

        uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;

        encoded_data[j++] = alphabet[(triple >> 3 * 6) & 0x3F];
        encoded_data[j++] = alphabet[(triple >> 2 * 6) & 0x3F];
        encoded_data[j++] = alphabet[(triple >> 1 * 6) & 0x3F];
        encoded_data[j++] = alphabet[(triple >> 0 * 6) & 0x3F];
    }

    for (int i = 0; i < mod_table[input_length % 3]; i++)
        encoded_data[*output_length - 1 - i] = '=';

    return encoded_data;
}

char *base64_decode(char *data,
                             size_t input_length,
                             size_t *output_length) {

    if (decoding_table == NULL) build_decoding_table();

    if (input_length % 4 != 0) return NULL;

    *output_length = input_length / 4 * 3;
    if (data[input_length - 1] == '=') (*output_length)--;
    if (data[input_length - 2] == '=') (*output_length)--;

    char *decoded_data = malloc(*output_length);
    if (decoded_data == NULL) return NULL;

    for (int i = 0, j = 0; i < input_length;) {

        uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];

        uint32_t triple = (sextet_a << 3 * 6)
        + (sextet_b << 2 * 6)
        + (sextet_c << 1 * 6)
        + (sextet_d << 0 * 6);

        if (j < *output_length) decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
        if (j < *output_length) decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
        if (j < *output_length) decoded_data[j++] = (triple >> 0 * 8) & 0xFF;
    }

    return decoded_data;
}

int main ( int argc, char ** argv )
{
    size_t input_length = getFilesize ( argv [ 1 ] );
    char * input = ( char * ) malloc ( input_length );
    FILE * in = fopen ( argv [ 1 ], "rb" );
    fread ( input, 1, input_length, in);
    size_t output_length = 0;
    char * encoded = base64_encode ( input, input_length, &output_length);
    char * decoded = base64_decode ( encoded, output_length, &input_length);
    FILE * out = fopen ( "out.out", "wb");
    fwrite ( decoded, sizeof (char), input_length, out);
}