/*
 * .============.
 * // M A K E / \
 * // C++ DEV / \
 * // E A S Y / \/ \
 * ++ ----------. \/\ .
 * \\ \ \ /\ /
 * \\ \ \ /
 * \\ \ \ /
 * -============'
 *
 * Copyright (c) 2025 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include "sha1.h"

#include <cstring>

namespace tbox {
namespace crypto {

namespace {

//! SHA-1 常量
constexpr uint32_t K0 = 0x5A827999; //!< 0~19
constexpr uint32_t K1 = 0x6ED9EBA1; //!< 20~39
constexpr uint32_t K2 = 0x8F1BBCDC; //!< 40~59
constexpr uint32_t K3 = 0xCA62C1D6; //!< 60~79

inline uint32_t RotLeft(uint32_t x, uint32_t n) { return (x << n) | (x >> (32 - n)); }
inline uint32_t Ch(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (~x & z); }
inline uint32_t Parity(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; }
inline uint32_t Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (x & z) ^ (y & z); }

}

SHA1::SHA1()
{
 state_[0] = 0x67452301;
 state_[1] = 0xEFCDAB89;
 state_[2] = 0x98BADCFE;
 state_[3] = 0x10325476;
 state_[4] = 0xC3D2E1F0;
 count_ = 0;
 buffer_index_ = 0;
}

void SHA1::update(const void *data_ptr, size_t data_len)
{
 if (is_finished_ || data_ptr == nullptr || data_len == 0)
 return;

 const uint8_t *p = static_cast<const uint8_t*>(data_ptr);

 while (data_len > 0) {
 size_t copy_len = 64 - buffer_index_;
 if (copy_len > data_len)
 copy_len = data_len;

 memcpy(buffer_ + buffer_index_, p, copy_len);
 buffer_index_ += copy_len;
 p += copy_len;
 data_len -= copy_len;
 count_ += copy_len;

 if (buffer_index_ == 64) {
 transform(buffer_);
 buffer_index_ = 0;
 }
 }
}

void SHA1::finish(uint8_t digest[20])
{
 if (is_finished_)
 return;

 //! 填充:1 bit of 1 + 0 bits + 64 bit length
 uint64_t total_bits = count_ * 8;

 buffer_[buffer_index_++] = 0x80;

 if (buffer_index_ > 56) {
 //! 需要额外一个块
 while (buffer_index_ < 64)
 buffer_[buffer_index_++] = 0;
 transform(buffer_);
 buffer_index_ = 0;
 }

 //! 填0直到56字节位置
 while (buffer_index_ < 56)
 buffer_[buffer_index_++] = 0;

 //! 写入总长度(大端序)
 buffer_[56] = static_cast<uint8_t>((total_bits >> 56) & 0xFF);
 buffer_[57] = static_cast<uint8_t>((total_bits >> 48) & 0xFF);
 buffer_[58] = static_cast<uint8_t>((total_bits >> 40) & 0xFF);
 buffer_[59] = static_cast<uint8_t>((total_bits >> 32) & 0xFF);
 buffer_[60] = static_cast<uint8_t>((total_bits >> 24) & 0xFF);
 buffer_[61] = static_cast<uint8_t>((total_bits >> 16) & 0xFF);
 buffer_[62] = static_cast<uint8_t>((total_bits >> 8) & 0xFF);
 buffer_[63] = static_cast<uint8_t>((total_bits >> 0) & 0xFF);

 transform(buffer_);

 //! 输出摘要(大端序)
 for (int i = 0; i < 5; ++i) {
 digest[i * 4 + 0] = static_cast<uint8_t>((state_[i] >> 24) & 0xFF);
 digest[i * 4 + 1] = static_cast<uint8_t>((state_[i] >> 16) & 0xFF);
 digest[i * 4 + 2] = static_cast<uint8_t>((state_[i] >> 8) & 0xFF);
 digest[i * 4 + 3] = static_cast<uint8_t>((state_[i] >> 0) & 0xFF);
 }

 is_finished_ = true;
}

void SHA1::transform(const uint8_t block[64])
{
 uint32_t w[80];

 //! 将64字节块扩展为80个32位字(大端序)
 for (int i = 0; i < 16; ++i)
 w[i] = (static_cast<uint32_t>(block[i * 4 + 0]) << 24)
 | (static_cast<uint32_t>(block[i * 4 + 1]) << 16)
 | (static_cast<uint32_t>(block[i * 4 + 2]) << 8)
 | (static_cast<uint32_t>(block[i * 4 + 3]) << 0);

 for (int i = 16; i < 80; ++i)
 w[i] = RotLeft(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);

 uint32_t a = state_[0];
 uint32_t b = state_[1];
 uint32_t c = state_[2];
 uint32_t d = state_[3];
 uint32_t e = state_[4];

 for (int i = 0; i < 20; ++i) {
 uint32_t temp = RotLeft(a, 5) + Ch(b, c, d) + e + K0 + w[i];
 e = d; d = c; c = RotLeft(b, 30); b = a; a = temp;
 }

 for (int i = 20; i < 40; ++i) {
 uint32_t temp = RotLeft(a, 5) + Parity(b, c, d) + e + K1 + w[i];
 e = d; d = c; c = RotLeft(b, 30); b = a; a = temp;
 }

 for (int i = 40; i < 60; ++i) {
 uint32_t temp = RotLeft(a, 5) + Maj(b, c, d) + e + K2 + w[i];
 e = d; d = c; c = RotLeft(b, 30); b = a; a = temp;
 }

 for (int i = 60; i < 80; ++i) {
 uint32_t temp = RotLeft(a, 5) + Parity(b, c, d) + e + K3 + w[i];
 e = d; d = c; c = RotLeft(b, 30); b = a; a = temp;
 }

 state_[0] += a;
 state_[1] += b;
 state_[2] += c;
 state_[3] += d;
 state_[4] += e;
}

void SHA1::Calc(const void *data_ptr, size_t data_len, uint8_t digest[20])
{
 SHA1 sha1;
 sha1.update(data_ptr, data_len);
 sha1.finish(digest);
}

}
}