// 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;

 }