package com.infendro.hash.sha2

import com.infendro.bytearray.toUByteArray
import com.infendro.bytearray.toUIntArray
import com.infendro.hash.HashFunction

object `SHA-256` : HashFunction() {
    override val bytes: Int
        get() = 32

    override val block: Int
        get() = 64

    private val initial = uintArrayOf(
        0x6a09e667U, 0xbb67ae85U,
        0x3c6ef372U, 0xa54ff53aU,
        0x510e527fU, 0x9b05688cU,
        0x1f83d9abU, 0x5be0cd19U,
    )

    private val c = uintArrayOf(
        0x428a2f98U, 0x71374491U, 0xb5c0fbcfU, 0xe9b5dba5U, 0x3956c25bU, 0x59f111f1U, 0x923f82a4U, 0xab1c5ed5U,
        0xd807aa98U, 0x12835b01U, 0x243185beU, 0x550c7dc3U, 0x72be5d74U, 0x80deb1feU, 0x9bdc06a7U, 0xc19bf174U,
        0xe49b69c1U, 0xefbe4786U, 0x0fc19dc6U, 0x240ca1ccU, 0x2de92c6fU, 0x4a7484aaU, 0x5cb0a9dcU, 0x76f988daU,
        0x983e5152U, 0xa831c66dU, 0xb00327c8U, 0xbf597fc7U, 0xc6e00bf3U, 0xd5a79147U, 0x06ca6351U, 0x14292967U,
        0x27b70a85U, 0x2e1b2138U, 0x4d2c6dfcU, 0x53380d13U, 0x650a7354U, 0x766a0abbU, 0x81c2c92eU, 0x92722c85U,
        0xa2bfe8a1U, 0xa81a664bU, 0xc24b8b70U, 0xc76c51a3U, 0xd192e819U, 0xd6990624U, 0xf40e3585U, 0x106aa070U,
        0x19a4c116U, 0x1e376c08U, 0x2748774cU, 0x34b0bcb5U, 0x391c0cb3U, 0x4ed8aa4aU, 0x5b9cca4fU, 0x682e6ff3U,
        0x748f82eeU, 0x78a5636fU, 0x84c87814U, 0x8cc70208U, 0x90befffaU, 0xa4506cebU, 0xbef9a3f7U, 0xc67178f2U,
    )

    override fun hash(
        value: UByteArray,
    ): UByteArray {
        val h = initial.copyOf()
        val l = value.size.toULong() * 8UL

        // padding
        val paddedValue = buildList {
            addAll(value)
            add(0x80U)
            while (size % 64 != 56) {
                add(0x00U)
            }
            addAll(l.toUByteArray())
        }

        // process
        val chunks = paddedValue
            .chunked(64) { it.toUByteArray() }
        for (chunk in chunks) {
            val w = buildList {
                addAll(chunk.toUIntArray())
                for (i in 16..<64) {
                    val s0 = get(i - 15).rotateRight(7) xor get(i - 15).rotateRight(18) xor (get(i - 15) shr 3)
                    val s1 = get(i - 2).rotateRight(17) xor get(i - 2).rotateRight(19) xor (get(i - 2) shr 10)
                    add(get(i - 16) + s0 + get(i - 7) + s1)
                }
            }.toUIntArray()
            process(h, w)
        }

        return h.toUByteArray()
    }

    private fun process(
        h: UIntArray,
        w: UIntArray,
    ) {
        val v = h.copyOf()

        for (i in 0..<64) {
            val s0 = v[0].rotateRight(2) xor v[0].rotateRight(13) xor v[0].rotateRight(22)
            val s1 = v[4].rotateRight(6) xor v[4].rotateRight(11) xor v[4].rotateRight(25)
            val ch = (v[4] and v[5]) xor (v[4].inv() and v[6])
            val temp1 = v[7] + s1 + ch + this.c[i] + w[i]
            val maj = (v[0] and v[1]) xor (v[0] and v[2]) xor (v[1] and v[2])
            val temp2 = s0 + maj

            v[7] = v[6]
            v[6] = v[5]
            v[5] = v[4]
            v[4] = v[3] + temp1
            v[3] = v[2]
            v[2] = v[1]
            v[1] = v[0]
            v[0] = temp1 + temp2
        }

        for (i in 0..7) {
            h[i] += v[i]
        }
    }
}