#include <fstream>
#include <iostream>
#include "UOHash.h"
#include <stdarg.h>
#include "URLCodec.h"
#include "basecodec.hpp"
#include "base36_codec.hpp"
#include <rhash_torrent.h>
#include <cryptopp/shake.h>
#include <cryptopp/base32.h>
#include <cryptopp/base64.h>
#include <cryptopp/basecode.h>

namespace uns
{
	bool UOHash::FileExist(std::string file)
	{
		std::fstream fs(file, std::ios::in);
		if (fs.is_open())
		{
			fs.close();
			return true;
		}
		else
			return false;
	}

	int UOHash::CalculateHashSize(HashID HashID)
	{
		switch (HashID)
		{
			case HashID::CRC32: return 8;
			case HashID::MD4: return 32;
			case HashID::MD5: return 32;
			case HashID::SHA1: return 40;
			case HashID::TIGER: return 48;
			case HashID::TTH: return 39;
			case HashID::BTIH: return 40;
			case HashID::ED2K: return 32;
			case HashID::AICH: return 32;
			case HashID::WHIRLPOOL: return 128;
			case HashID::RIPEMD160: return 40;
			case HashID::GOST94: return 64;
			case HashID::GOST94_CRYPTOPRO: return 64;
			case HashID::HAS160: return 40;
			case HashID::GOST12_256: return 64;
			case HashID::GOST12_512: return 128;
			case HashID::SHA224: return 56;
			case HashID::SHA256: return 64;
			case HashID::SHA384: return 96;
			case HashID::SHA512: return 128;
			case HashID::EDONR256: return 64;
			case HashID::EDONR512: return 128;
			case HashID::SHA3_224: return 56;
			case HashID::SHA3_256: return 64;
			case HashID::SHA3_384: return 96;
			case HashID::SHA3_512: return 128;
			case HashID::CRC32C: return 8;
			case HashID::SNEFRU128: return 32;
			case HashID::SNEFRU256: return 64;
			case HashID::BLAKE2S: return 64;
			case HashID::BLAKE2B: return 128;
			default: return 0;
		}
		return -1;
	}

	std::string UOHash::RemoveWhiteChar(std::string str)
	{
		std::string ret;
		for (auto& ele : str)
			if ((ele != ' ') && (ele != '\n') && (ele != '\t'))
				ret.push_back(ele);
		return ret;
	}

	int UOHash::CalculateHashExSize(HashID HashID, int output_bits)
	{
		if (HashID == HashID::SHAKE128)
			return 64;
		else if (HashID == HashID::SHAKE256)
			return 128;
		else
			return 0;
	}

	rhash_print_sum_flags UOHash::PickOutputType(HashID HashID)
	{
		if ((HashID == HashID::TTH) || (HashID == HashID::AICH))
			return RHPR_BASE32;
		else
			return RHPR_HEX;
	}

	HashResult UOHash::DecodeString(HashID HashID, std::string Source)
	{
		if (HashID < HashID::BASE16)
			return HashResult::Faliure(INVALID_HASH_FUNCTION);
		else
		{
			switch (HashID)
			{
				case HashID::BASE16:
				{
					std::string output;
					if (basecodec::decodeBase16(Source, output))
						return HashResult::Success(output);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				case HashID::BASE32:
				{
					std::string ret = "";
					CryptoPP::StringSource source(Source, true, new CryptoPP::Base32Decoder(new CryptoPP::StringSink(ret)));
					if (ret == "")
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
					else
						return HashResult::Success(ret);
				}
				case HashID::BASE32_HEX:
				{
					std::string ret = "";
					CryptoPP::StringSource source(Source, true, new CryptoPP::Base32HexDecoder(new CryptoPP::StringSink(ret)));
					if (ret == "")
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
					else
						return HashResult::Success(ret);
				}
				case HashID::BASE36:
				{
					std::string out;
					if (basecodec::decodeBase36ToDecimalString(Source, out))
						return HashResult::Success(out);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				case HashID::BASE62:
				{
					std::string out;
					if (basecodec::decodeBase62(Source, out))
						return HashResult::Success(out);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				case HashID::BASE58:
				{
					std::string out;
					if (basecodec::decodeBase58(Source, out))
						return HashResult::Success(out);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				case HashID::BASE64:
				{
					std::string ret = "";
					CryptoPP::StringSource source(Source, true, new CryptoPP::Base64Decoder(new CryptoPP::StringSink(ret)));
					if (ret == "")
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
					else
						return HashResult::Success(ret);
				}
				case HashID::BASE64_URL:
				{
					std::string ret = "";
					CryptoPP::StringSource source(Source, true, new CryptoPP::Base64URLDecoder(new CryptoPP::StringSink(ret)));
					if (ret == "")
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
					else
						return HashResult::Success(ret);
				}
				case HashID::BASE85:
				{
					std::string output;
					if (basecodec::decodeBase85(Source, output))
						return HashResult::Success(output);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				case HashID::BASE91:
				{
					std::string output;
					if (basecodec::decodeBase91(Source, output))
						return HashResult::Success(output);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				case HashID::URL:
				{
					std::string out;
					if (urlcodec::url_decode(Source, out))
						return HashResult::Success(out);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				default:
					return HashResult::Faliure(INVALID_HASH_FUNCTION);
			}
			return HashResult::Faliure(INVALID_HASH_FUNCTION);
		}
	}

	HashResult UOHash::HashString(HashID HashID, std::string Source, int ex_output_bits)
	{
		if (HashID >= HashID::__RHASH_MAX)
		{
			switch (HashID)
			{
				case HashID::SHAKE128:
				{
					if (ex_output_bits <= 0)
						return HashResult::Faliure(INVALID_HASHEX_ARGUMENT);
					CryptoPP::SHAKE128 shake128(ex_output_bits);
					int hash_size = CalculateHashExSize(HashID, ex_output_bits);
					unsigned char* recv = new unsigned char[ex_output_bits + 10];
					char* hashstr = new char[hash_size + 10];
					memset(recv, 0, (ex_output_bits + 10));
					memset(hashstr, 0, (hash_size + 10));
					shake128.CalculateDigest(recv, (const unsigned char*)Source.data(), Source.size());
					rhash_print_bytes(hashstr, recv, (hash_size / 2), (RHPR_HEX | RHPR_UPPERCASE));
					std::string str(hashstr);
					delete[] recv;
					recv = nullptr;
					delete[] hashstr;
					hashstr = nullptr;
					return HashResult::Success(RemoveWhiteChar(str));
				}
				case HashID::SHAKE256:
				{
					if (ex_output_bits <= 0)
						return HashResult::Faliure(INVALID_HASHEX_ARGUMENT);
					CryptoPP::SHAKE256 shake256(ex_output_bits);
					int hash_size = CalculateHashExSize(HashID, ex_output_bits);
					unsigned char* recv = new unsigned char[ex_output_bits + 10];
					char* hashstr = new char[hash_size + 10];
					memset(recv, 0, (ex_output_bits + 10));
					memset(hashstr, 0, (hash_size + 10));
					shake256.CalculateDigest(recv, (const unsigned char*)Source.data(), Source.size());
					rhash_print_bytes(hashstr, recv, (hash_size / 2), (RHPR_HEX | RHPR_UPPERCASE));
					std::string str(hashstr);
					delete[] recv;
					recv = nullptr;
					delete[] hashstr;
					hashstr = nullptr;
					return HashResult::Success(RemoveWhiteChar(str));
				}
				case HashID::BASE16:
					return HashResult::Success(basecodec::encodeBase16(Source));
				case HashID::BASE32:
				{
					try
					{
						std::string ret = "";
						CryptoPP::Base32Encoder b32enc;
						b32enc.Detach(new CryptoPP::StringSink(ret));
						b32enc.Put(reinterpret_cast<CryptoPP::byte*>(&Source[0]), Source.size());
						if (ret == "")
							return HashResult::Faliure(HASH_CALCULATION_ERROR);
						else
							return HashResult::Success(RemoveWhiteChar(ret));
					}
					catch (...)
					{
						return HashResult::Faliure(HASH_LIBRARY_ERROR);
					}
				}
				case HashID::BASE32_HEX:
				{
					try
					{
						std::string ret = "";
						CryptoPP::Base32HexEncoder b32enc_hex;
						b32enc_hex.Detach(new CryptoPP::StringSink(ret));
						b32enc_hex.Put(reinterpret_cast<CryptoPP::byte*>(&Source[0]), Source.size());
						if (ret == "")
							return HashResult::Faliure(HASH_CALCULATION_ERROR);
						else
							return HashResult::Success(RemoveWhiteChar(ret));
					}
					catch (...)
					{
						return HashResult::Faliure(HASH_LIBRARY_ERROR);
					}
				}
				case HashID::BASE36:
				{
					std::string out;
					if (basecodec::encodeBase36FromDecimalString(Source, out))
						return HashResult::Success(out);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				case HashID::BASE58:
					return HashResult::Success(basecodec::encodeBase58(Source));
				case HashID::BASE62:
					return HashResult::Success(basecodec::encodeBase62(Source));
				case HashID::BASE64:
				{
					try
					{
						std::string ret = "";
						CryptoPP::Base64Encoder b64enc;
						b64enc.Detach(new CryptoPP::StringSink(ret));
						b64enc.Put(reinterpret_cast<CryptoPP::byte*>(&Source[0]), Source.size());
						if (ret == "")
							return HashResult::Faliure(HASH_CALCULATION_ERROR);
						else
							return HashResult::Success(RemoveWhiteChar(ret));
					}
					catch (...)
					{
						return HashResult::Faliure(HASH_LIBRARY_ERROR);
					}
				}
				case HashID::BASE64_URL:
				{
					try
					{
						std::string ret = "";
						CryptoPP::Base64URLEncoder b64enc_url;
						b64enc_url.Detach(new CryptoPP::StringSink(ret));
						b64enc_url.Put(reinterpret_cast<CryptoPP::byte*>(&Source[0]), Source.size());
						if (ret == "")
							return HashResult::Faliure(HASH_CALCULATION_ERROR);
						else
							return HashResult::Success(RemoveWhiteChar(ret));
					}
					catch (...)
					{
						return HashResult::Faliure(HASH_LIBRARY_ERROR);
					}
				}
				case HashID::BASE85:
					return HashResult::Success(basecodec::encodeBase85(Source));
				case HashID::BASE91:
				{
					std::string out;
					if (basecodec::encodeBase91(Source, out))
						return HashResult::Success(out);
					else
						return HashResult::Faliure(HASH_CALCULATION_ERROR);
				}
				case HashID::URL:
					return HashResult::Success(urlcodec::url_encode(Source));
				default:
					return HashResult::Faliure(INVALID_HASH_FUNCTION);
			}
			return HashResult::Faliure(INVALID_HASH_FUNCTION);
		}
		else
		{
			int HashSize = CalculateHashSize(HashID);
			if (HashSize < 8)
				return HashResult::Faliure(INVALID_HASH_FUNCTION);
			char* src = new char[Source.length() + 1];
			unsigned char* dst = new unsigned char[(HashSize * 4) + 1];
			char* str = new char[HashSize + 1];
			strcpy(src, Source.c_str());
			memset(dst, 0, sizeof(dst));
			memset(str, 0, sizeof(str));
			rhash_library_init();
			int res = rhash_msg((int)HashID, src, strlen(src), dst);
			if (res < 0)
				return HashResult::Faliure(HASH_CALCULATION_ERROR);
			rhash_print_bytes(str, dst, rhash_get_digest_size((int)HashID), (PickOutputType(HashID) | RHPR_UPPERCASE));
			std::string ret = std::string(str);
			delete[] src;
			delete[] dst;
			delete[] str;
			return HashResult((ret.length() >= 8), RemoveWhiteChar(ret), HASH_LIBRARY_ERROR);
		}
	}

	HashResult UOHash::HashFile(HashID HashID, std::string File, int ex_output_bits)
	{
		if (HashID >= HashID::__RHASH_MAX)
			return HashResult::Faliure(INVALID_HASH_FUNCTION);
		if (!FileExist(File))
			return HashResult::Faliure(FILE_DOES_NOT_EXIST);
		int HashSize = CalculateHashSize(HashID);
		if (HashSize < 8)
			return HashResult::Faliure(INVALID_HASH_FUNCTION);
		unsigned char* dst = new unsigned char[(HashSize * 4) + 1];
		char* str = new char[HashSize + 1];
		rhash_library_init();
		int res = rhash_file((int)HashID, File.c_str(), dst);
		if (res < 0)
			return HashResult::Faliure(HASH_CALCULATION_ERROR);
		rhash_print_bytes(str, dst, rhash_get_digest_size((int)HashID), (PickOutputType(HashID) | RHPR_UPPERCASE));
		std::string ret = std::string(str);
		delete[] dst;
		delete[] str;
		return HashResult((ret.length() >= 8), RemoveWhiteChar(ret), HASH_LIBRARY_ERROR);
	}
};