// This file is under GNU General Public License 3.0

// see LICENSE.txt

#include <stdbool.h>

#include <stdlib.h>

#include <assert.h>

#include <string.h>

#include "platform.h"

#include "base64.h"

static char translate_char_to_bits(char input) {

    if (input >= 65 && input <= 90)

        return input - 65;

    if (input >= 97 && input <= 122)

        return input - 71; // 97 - 26

    if (input >= 48 && input <= 57)

        return input + 4; // 52 - 48

    if (input == '+')

        return 62;

    if (input == '/')

        return 63;

    if (input == ' ' || input == '\r' || input == '\n')

        return 127;

    return -1;    

}

static bool _is_whitespace(const char in) {

    switch (in) {

        case ' ':

        case '\r':

        case '\t':

        case '\n':

            return true;

        default:

            return false;

    }        

}

static size_t subtract_whitespace(const char* input, int length) {

    size_t actual_size = length;

    int i;

    const char* curr = input;

    for (i = 0; i < length; i++, curr++) {

        if (_is_whitespace(*curr))

            actual_size--;

    }

    return actual_size;

}

static void trim_end(const char* input, int* length) {

    const char* end = input + *length;

    int start_length = *length;

    int i;

    for (i = 0; i < start_length; i++) {

        if (!_is_whitespace(*(--end)))

            break;

        (*length) = (*length) - 1;        

    }

}    

char next_char(const char** input_ptr, const char* end) {

    const char* input = *input_ptr;

    char this_ch = 0;

    while (input < end) {

        this_ch = *input++;

        if (!this_ch)

            return 0;

        if (_is_whitespace(this_ch))

            continue;

        break;    

    }

    *input_ptr = input;

    return this_ch;

}

// 4 chars = 3 output bytes

bloblist_t* base64_str_to_binary_blob(const char* input, int length) {

    if (length == 0)

        return NULL;

    trim_end(input, &length);

    const char* input_curr;

    input_curr = input;

    const char* input_end = input_curr + length;

    length = subtract_whitespace(input, length);

    size_t final_length = (length / 4) * 3;

    // padded -- FIXME: whitespace in between ==!!!! 

    if (*(input_end - 1) == '=') {

        final_length -= 1;

        if (*(input_end - 2) == '=')

            final_length -=1;

    }

    else {

        // not padded

        int leftover = length % 4;

        switch (leftover) {

            case 0:

                break;

            case 2:

                final_length++;

                break;

            case 3:

                final_length+=2;

                break;

            default:

                return NULL;

        }

    }

    void* blobby = calloc(final_length, 1);

    char* blobby_curr = (char*)blobby;

    // if the last 1 or 2 bytes are padded, we do those after

    size_t number_of_rounds = final_length / 3;

    unsigned int cycle;

    // full 3-byte rounds

    for (cycle = 0; cycle < number_of_rounds; cycle++) {

        char byte_array[] = {0,0,0};

        char in_val = next_char(&input_curr, input_end);

        if (in_val == 0)

            goto pEp_error; // can ALSO happen when input_curr == input_end,

                            // which simply shouldn't happen, since we're

                            // interating based on expected OUTPUT, not

                            // input.

        char out_val = translate_char_to_bits(in_val);

        if (out_val > 63)

            goto pEp_error;

        byte_array[0] |= out_val << 2;

        in_val = next_char(&input_curr, input_end);

        if (in_val == 0)

            goto pEp_error;         

        out_val = translate_char_to_bits(in_val);

        if (out_val > 63)

            goto pEp_error;

        byte_array[0] |= out_val >> 4;

        byte_array[1] = out_val << 4;

        in_val = next_char(&input_curr, input_end);

        if (in_val == 0)

            goto pEp_error;         

        out_val = translate_char_to_bits(in_val);

        if (out_val > 63)

            goto pEp_error;

        byte_array[1] |= out_val >> 2;

        byte_array[2] = out_val << 6;

        in_val = next_char(&input_curr, input_end);

        if (in_val == 0)

            goto pEp_error;         

        out_val = translate_char_to_bits(in_val);

        if (out_val > 63)

            goto pEp_error;

        byte_array[2] |= out_val;

        // Now write everything to the blob

        *blobby_curr++ = byte_array[0];

        *blobby_curr++ = byte_array[1];

        *blobby_curr++ = byte_array[2];        

    }

    int last_bytes = final_length % 3;

    if (last_bytes != 0) {

        char byte_1 = 0;

        char byte_2 = 0;

        char in_val = next_char(&input_curr, input_end);

        if (in_val == 0)

            goto pEp_error;         

        char out_val = translate_char_to_bits(in_val);

        if (out_val > 63)

            goto pEp_error;

        byte_1 = out_val << 2;

        in_val = next_char(&input_curr, input_end);

        if (in_val == 0)

            goto pEp_error;         

        out_val = translate_char_to_bits(in_val);

        if (out_val > 63)

            goto pEp_error;

        byte_1 |= out_val >> 4;

        *blobby_curr++ = byte_1;                   

        if (last_bytes == 2) {

            byte_2 = out_val << 4;

            in_val = next_char(&input_curr, input_end);

            if (in_val == 0)

                goto pEp_error;         

            out_val = translate_char_to_bits(in_val);

            if (out_val > 63)

                goto pEp_error;

            byte_2 |= out_val >> 2;

            *blobby_curr++ = byte_2;

        }

    }

    return new_bloblist((char*)blobby, final_length, NULL, NULL);

pEp_error:

    free(blobby);

    return NULL;

}