#include "md5ex1.h"
#include <string.h>
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define FF(a, b, c, d, x, s, ac) \
    { (a) += F((b), (c), (d)) + (x) + (uint32_t)(ac); \
      (a) = ROTATE_LEFT((a), (s)); \
      (a) += (b); }
#define GG(a, b, c, d, x, s, ac) \
    { (a) += G((b), (c), (d)) + (x) + (uint32_t)(ac); \
      (a) = ROTATE_LEFT((a), (s)); \
      (a) += (b); }
#define HH(a, b, c, d, x, s, ac) \
    { (a) += H((b), (c), (d)) + (x) + (uint32_t)(ac); \
      (a) = ROTATE_LEFT((a), (s)); \
      (a) += (b); }
#define II(a, b, c, d, x, s, ac) \
    { (a) += I((b), (c), (d)) + (x) + (uint32_t)(ac); \
      (a) = ROTATE_LEFT((a), (s)); \
      (a) += (b); }

// v41.2 修复警告：将block参数改为指针，修复-Wstringop-overread警告
static void MD5_TransformEx1(uint32_t state[4], const uint8_t* block) {
	uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
	// v41.2 修复：从指针正确读取64字节
	const uint8_t* p = (const uint8_t*)block;
	for (int i = 0; i < 16; i++) {
		x[i] = (uint32_t)p[0] | ((uint32_t)p[1] << 8) |
		       ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
		p += 4;
	}
	FF(a, b, c, d, x[0], 7, 0xD76AA478);
	FF(d, a, b, c, x[1], 12, 0xE8C7B756);
	FF(c, d, a, b, x[2], 17, 0x242070DB);
	FF(b, c, d, a, x[3], 22, 0xC1BDCEEE);
	FF(a, b, c, d, x[4], 7, 0xF57C0FAF);
	FF(d, a, b, c, x[5], 12, 0x4787C62A);
	FF(c, d, a, b, x[6], 17, 0xA8304613);
	FF(b, c, d, a, x[7], 22, 0xFD469501);
	FF(a, b, c, d, x[8], 7, 0x698098D8);
	FF(d, a, b, c, x[9], 12, 0x8B44F7AF);
	FF(c, d, a, b, x[10], 17, 0xFFFF5BB1);
	FF(b, c, d, a, x[11], 22, 0x895CD7BE);
	FF(a, b, c, d, x[12], 7, 0x6B901122);
	FF(d, a, b, c, x[13], 12, 0xFD987193);
	FF(c, d, a, b, x[14], 17, 0xA679438E);
	FF(b, c, d, a, x[15], 22, 0x49B40821);
	GG(a, b, c, d, x[1], 5, 0xF61E2562);
	GG(d, a, b, c, x[6], 9, 0xC040B340);
	GG(c, d, a, b, x[11], 14, 0x265E5A51);
	GG(b, c, d, a, x[0], 20, 0xE9B6C7AA);
	GG(a, b, c, d, x[5], 5, 0xD62F105D);
	GG(d, a, b, c, x[10], 9, 0x02441453);
	GG(c, d, a, b, x[15], 14, 0xD8A1E681);
	GG(b, c, d, a, x[4], 20, 0xE7D3FBC8);
	GG(a, b, c, d, x[9], 5, 0x21E1CDE6);
	GG(d, a, b, c, x[14], 9, 0xC33707D6);
	GG(c, d, a, b, x[3], 14, 0xF4D50D87);
	GG(b, c, d, a, x[8], 20, 0x455A14ED);
	GG(a, b, c, d, x[13], 5, 0xA9E3E905);
	GG(d, a, b, c, x[2], 9, 0xFCEFA3F8);
	GG(c, d, a, b, x[7], 14, 0x676F02D9);
	GG(b, c, d, a, x[12], 20, 0x8D2A4C8A);
	HH(a, b, c, d, x[5], 4, 0xFFFA3942);
	HH(d, a, b, c, x[8], 11, 0x8771F681);
	HH(c, d, a, b, x[11], 16, 0x6D9D6122);
	HH(b, c, d, a, x[14], 23, 0xFDE5380C);
	HH(a, b, c, d, x[1], 4, 0xA4BEEA44);
	HH(d, a, b, c, x[4], 11, 0x4BDECFA9);
	HH(c, d, a, b, x[7], 16, 0xF6BB4B60);
	HH(b, c, d, a, x[10], 23, 0xBEBFBC70);
	HH(a, b, c, d, x[13], 4, 0x289B7EC6);
	HH(d, a, b, c, x[0], 11, 0xEAA127FA);
	HH(c, d, a, b, x[3], 16, 0xD4EF3085);
	HH(b, c, d, a, x[6], 23, 0x04881D05);
	HH(a, b, c, d, x[9], 4, 0xD9D4D039);
	HH(d, a, b, c, x[12], 11, 0xE6DB99E5);
	HH(c, d, a, b, x[15], 16, 0x1FA27CF8);
	HH(b, c, d, a, x[2], 23, 0xC4AC5665);
	II(a, b, c, d, x[0], 6, 0xF4292244);
	II(d, a, b, c, x[7], 10, 0x432AFF97);
	II(c, d, a, b, x[14], 15, 0xAB9423A7);
	II(b, c, d, a, x[5], 21, 0xFC93A039);
	II(a, b, c, d, x[12], 6, 0x655B59C3);
	II(d, a, b, c, x[3], 10, 0x8F0CCC92);
	II(c, d, a, b, x[10], 15, 0xFFEFF47D);
	II(b, c, d, a, x[1], 21, 0x85845DD1);
	II(a, b, c, d, x[8], 6, 0x6FA87E4F);
	II(d, a, b, c, x[15], 10, 0xFE2CE6E0);
	II(c, d, a, b, x[6], 15, 0xA3014314);
	II(b, c, d, a, x[13], 21, 0x4E0811A1);
	II(a, b, c, d, x[4], 6, 0xF7537E82);
	II(d, a, b, c, x[11], 10, 0xBD3AF235);
	II(c, d, a, b, x[2], 15, 0x2AD7D2BB);
	II(b, c, d, a, x[9], 21, 0xEB86D391);
	state[0] += a;
	state[1] += b;
	state[2] += c;
	state[3] += d;
}

void MD5_InitEx1(MD5_CTXEx1* ctx) {
	ctx->count[0] = ctx->count[1] = 0;
	ctx->state[0] = 0x67452301;
	ctx->state[1] = 0xEFCDAB89;
	ctx->state[2] = 0x98BADCFE;
	ctx->state[3] = 0x10325476;
}

void MD5_UpdateEx1(MD5_CTXEx1* ctx, const uint8_t* input, size_t len) {
	size_t i, index, partLen;
	index = (ctx->count[0] >> 3) & 0x3F;
	ctx->count[0] += (uint32_t)(len << 3);
	if (ctx->count[0] < (len << 3)) ctx->count[1]++;
	ctx->count[1] += (uint32_t)(len >> 29);
	partLen = MD5_BLOCK_SIZE - index;
	
	if (len >= partLen) {
		memcpy(&ctx->buffer[index], input, partLen);
		MD5_TransformEx1(ctx->state, ctx->buffer);
		
		// v41.2 修复警告：使用临时缓冲区确保64字节对齐
		uint8_t block[MD5_BLOCK_SIZE];
		for (i = partLen; i + MD5_BLOCK_SIZE <= len; i += MD5_BLOCK_SIZE) {
			memcpy(block, &input[i], MD5_BLOCK_SIZE);
			MD5_TransformEx1(ctx->state, block);
		}
		index = 0;
	}
	else {
		i = 0;
	}
	memcpy(&ctx->buffer[index], &input[i], len - i);
}

void MD5_FinalEx1(uint8_t digest[MD5_DIGEST_SIZE], MD5_CTXEx1* ctx) {
	uint8_t bits[8];
	size_t index, padLen;
	static const uint8_t PADDING[MD5_BLOCK_SIZE] = { 0x80 };
	
	for (int i = 0; i < 8; i++)
		bits[i] = (ctx->count[i >> 2] >> ((i & 3) << 3)) & 0xFF;
	
	index = (ctx->count[0] >> 3) & 0x3F;
	padLen = (index < 56) ? (56 - index) : (120 - index);
	MD5_UpdateEx1(ctx, PADDING, padLen);
	MD5_UpdateEx1(ctx, bits, 8);
	
	for (int i = 0; i < MD5_DIGEST_SIZE; i++)
		digest[i] = (ctx->state[i >> 2] >> ((i & 3) << 3)) & 0xFF;
}

// 字节数组转16进制字符串
void bytes_to_hexEx1(const uint8_t* bytes, size_t len, char* hex_str) {
	const char hex_chars[] = "0123456789abcdef";
	for (size_t i = 0; i < len; i++) {
		hex_str[i * 2] = hex_chars[(bytes[i] >> 4) & 0xF];
		hex_str[i * 2 + 1] = hex_chars[bytes[i] & 0xF];
	}
	hex_str[len * 2] = '\0';
}

// MD5 哈希字符串，输出16进制
void md5_hexEx1(const char* input, char* output) {
	MD5_CTXEx1 ctx;
	uint8_t digest[MD5_DIGEST_SIZE];
	MD5_InitEx1(&ctx);
	MD5_UpdateEx1(&ctx, (const uint8_t*)input, strlen(input));
	MD5_FinalEx1(digest, &ctx);
	bytes_to_hexEx1(digest, MD5_DIGEST_SIZE, output);
}

// MD5 哈希字节数组，输出16进制
void md5_bytesEx1(const uint8_t* input, size_t len, char* output) {
	MD5_CTXEx1 ctx;
	uint8_t digest[MD5_DIGEST_SIZE];
	MD5_InitEx1(&ctx);
	MD5_UpdateEx1(&ctx, input, len);
	MD5_FinalEx1(digest, &ctx);
	bytes_to_hexEx1(digest, MD5_DIGEST_SIZE, output);
}

// 三次 MD5 加密（只返回最终结果）
void md5_tripleEx1(const char* input, char* output) {
	char temp[33];
	md5_hexEx1(input, temp);           // 第一次
	md5_hexEx1(temp, output);          // 第二次
	strcpy(temp, output);
	md5_hexEx1(temp, output);          // 第三次
}