#include "stdafx.h"
#include "MyBase64.h"
namespace MyBase64{
	void Encode(const string plain,string& encoded)
	{
		unsigned int bytes = plain.size();
		unsigned int outSz = (bytes + 3 - 1) / 3 * 4;

		outSz += (outSz + pemLineSz - 1) / pemLineSz;  // new lines

		unsigned int index = 0;
		
		while (bytes > 2) {
			unsigned char b1 = plain[index++];
			unsigned char b2 = plain[index++];
			unsigned char b3 = plain[index++];

			// encoded idx
			unsigned char e1 = b1 >> 2;
			unsigned char e2 = ((b1 & 0x3) << 4) | (b2 >> 4);
			unsigned char e3 = ((b2 & 0xF) << 2) | (b3 >> 6);
			unsigned char e4 = b3 & 0x3F;

			// store
			encoded.append(1,base64Encode[e1]);
			encoded.append(1,base64Encode[e2]);
			encoded.append(1,base64Encode[e3]);
			encoded.append(1,base64Encode[e4]);
			bytes -= 3;
			//enter anther row
		   /* if ((++j % 16) == 0 && bytes)
				encoded.append(1,'\n');*/
		}

		// last integral
		if (bytes) {
			bool twoBytes = (bytes == 2);

			unsigned char b1 = plain[index++];
			unsigned char b2 = (twoBytes) ? plain[index++]: 0;

			unsigned char e1 = b1 >> 2;
			unsigned char e2 = ((b1 & 0x3) << 4) | (b2 >> 4);
			unsigned char e3 =  (b2 & 0xF) << 2;

			encoded.append(1,base64Encode[e1]);
			encoded.append(1,base64Encode[e2]);
			encoded.append(1,(twoBytes) ? base64Encode[e3] : pad);
			encoded.append(1,pad);
		} 

		encoded.append(1,'\0');
	}
	void Decode(const string coded,string& decoded)
	{
		unsigned int bytes = coded.size();
		unsigned int plainSz = bytes - ((bytes + (pemLineSz - 1)) / pemLineSz); 
		plainSz = (plainSz * 3 + 3) / 4;
		//decoded_.New(plainSz);

		unsigned int i = 0;
		unsigned int j = 0;
		unsigned int index = 0;
		while (bytes > 3) {
			unsigned char e1 =  coded[index++];
			unsigned char e2 =  coded[index++];
			unsigned char e3 =  coded[index++];
			unsigned char e4 =  coded[index++];

			// do asserts first
			if (e1 == 0)            // end file 0's
				break;

			bool pad3 = false;
			bool pad4 = false;
			if (e3 == pad)
				pad3 = true;
			if (e4 == pad)
				pad4 = true;

			e1 = base64Decode[e1 - 0x2B];
			e2 = base64Decode[e2 - 0x2B];
			e3 = (e3 == pad) ? 0 : base64Decode[e3 - 0x2B];
			e4 = (e4 == pad) ? 0 : base64Decode[e4 - 0x2B];

			unsigned char b1 = (e1 << 2) | (e2 >> 4);
			unsigned char b2 = ((e2 & 0xF) << 4) | (e3 >> 2);
			unsigned char b3 = ((e3 & 0x3) << 6) | e4;

			decoded.append(1,b1);
			if (!pad3)
				decoded.append(1,b2);
			if (!pad4)
				decoded.append(1,b3);
			else
				break;
			
			bytes -= 4;
			//if ((++j % 16) == 0) {
			//    unsigned char endLine = coded[index++];//coded_.next();
			//    bytes--;
			//    while (endLine == ' ') {        // remove possible whitespace
			//        endLine = coded[index++];
			//        bytes--;
			//    }
			//    if (endLine == '\r') {
			//        endLine = coded[index++];
			//        bytes--;
			//    }
			//    if (endLine != '\n') {
			//        return;
			//    }
			//}
		}
	}
	unsigned char Ch2Hex(char ch)
	{
		static const char* hex = "0123456789ABCDEF";
		for (unsigned char i = 0;i != 16;++i)
			if (ch == hex[i])
				return i;
		return 0;
	}
	char* Hex2Str(const char* src, int& dstLen)
	{
		int i = 0;
		int cnt = 0;
		int len = strlen(src);
		unsigned char* d = new unsigned char[len];
		memset(d, 0, len);
		while (*src)
		{
			if (i & 1)
			{
				d[cnt++] |= Ch2Hex(*src);
			}
			else
			{
				d[cnt] = Ch2Hex(*src) << 4;
			}
			src++;
			i++;
		}
		dstLen = cnt;
		return (char*)d;
	}
	char* Str2Hex(const char* src, int srcLen)
	{
		string ret;
		static const char* hex = "0123456789ABCDEF";

		for (int i = 0;i != srcLen;++i)
		{
			ret.push_back(hex[(src[i] >> 4) & 0xf]);
			ret.push_back(hex[src[i] & 0xf]);
		}
		char* tmp = new char[ret.length() + 1];
		memset(tmp, 0, ret.length() + 1);
		memcpy(tmp, ret.c_str(), ret.length());
		return tmp;
	}


}