/*
 *  Baltisot
 *  Copyright (C) 1999-2009 Nicolas "Pixel" Noble
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <Base85.h>

String Base85::encode_block(unsigned char in_tab[4], int len) {
    unsigned int tuple;
    char r[6];
    
    tuple  = in_tab[0];
    tuple |= in_tab[1] <<  8;
    tuple |= in_tab[2] << 16;
    tuple |= in_tab[3] << 24;
    
    r[0] = (tuple % 85) + '!';
    tuple /= 85;
    r[1] = (tuple % 85) + '!';
    tuple /= 85;
    r[2] = len > 1 ? (tuple % 85) + '!' : '~';
    tuple /= 85;
    r[3] = len > 2 ? (tuple % 85) + '!' : '~';
    tuple /= 85;
    r[4] = len > 3 ? (tuple % 85) + '!' : '~';
    r[5] = 0;
    
    return r;
}

String Base85::encode(const char * data, int stream_size) {
    String encoded = "";
    unsigned char in_tab[4];
    int len, i, s_pos;

    s_pos = 0;

    while (stream_size > 0) {
        in_tab[0] = 0;
        in_tab[1] = 0;
        in_tab[2] = 0;
        in_tab[3] = 0;

        len = stream_size >= 4 ? 4 : stream_size;

        for (i = 0; i < len; i++) {
            in_tab[i] = data[s_pos + i];
        }

        encoded += encode_block(in_tab, len);

        s_pos += 4;
        stream_size -= 4;
    }

    return encoded;
}

int Base85::decode_block(char s1, char s2, char s3, char s4, char s5, unsigned char * out_tab) {
    int len, sb1, sb2, sb3, sb4, sb5;
    unsigned int tuple;

    len = s3 == '~' ? 1 : s4 == '~' ? 2 : s5 == '~' ? 3 : 4;
    s3 = (s3 == '~') || (s3 == 0) ? '!' : s3;
    s4 = (s4 == '~') || (s4 == 0) ? '!' : s4;
    s5 = (s5 == '~') || (s5 == 0) ? '!' : s5;
    
    sb1 = s1 - '!';
    sb2 = s2 - '!';
    sb3 = s3 - '!';
    sb4 = s4 - '!';
    sb5 = s5 - '!';
    
    tuple  = s5; tuple *= 85;
    tuple |= s4; tuple *= 85;
    tuple |= s3; tuple *= 85;
    tuple |= s2; tuple *= 85;
    tuple |= s1;
    
    out_tab[0] = tuple & 255; tuple >>= 8;
    out_tab[1] = tuple & 255; tuple >>= 8;
    out_tab[2] = tuple & 255; tuple >>= 8;
    out_tab[3] = tuple & 255;
    
    return len;
}

unsigned char * Base85::decode(const String & str_in, int * len_out) {
    int s_len = str_in.strlen(), len = 0, i, j, t_len;
    char s1, s2, s3, s4, s5;
    unsigned char t_out[4];
    unsigned char * out = (unsigned char *) malloc(s_len * 4 / 5 + 5);
    unsigned char * p = out;
    
    for (i = 0; i < s_len; i += 5) {
        s1 = str_in[i + 0];
        s2 = str_in[i + 1];
        s3 = str_in[i + 2];
        s4 = str_in[i + 3];
        s5 = str_in[i + 4];
        t_len = decode_block(s1, s2, s3, s4, s5, t_out);
        
        for (j = 0; j < t_len; j++) {
            *(p++) = t_out[j];
        }

        len += t_len;
    }
    
    if (len_out) {
        *len_out = len;
    }

    return out;
}