package main

import (
    "fmt"
    "encoding/binary"
)

var K = [...]uint32 {0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391}

var H = [...]uint32 { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476 }

var ROT = [...]uint8 {7,12,17,22,5,9,14,20,4,11,16,23,6,10,15,21}


func roll_left(w uint32, r uint8) uint32 {
    // w décalé tournée à gauche de r bits
	var mask uint32 = (1 << r) - 1
	return ((w >> (32 - r) & mask) | ((w << r) & ^mask))
}

func F(i uint8, b uint32, c uint32, d uint32) uint32 {
	if i < 16 {
        return (b & c)  | (^b & d)
    }
    if i < 32 {
        return (b & d) | (c & ^d);
    }
    if i < 48 {
        return b ^ c ^ d;
    }
    return c ^ (b | ^d);
}

func R(i uint8) uint8 {
    if i < 16 {
        return ROT[i%4]
    }
    if i < 32 {
        return ROT[i%4 + 4]
    }
    if i < 48 {
        return ROT[i%4 + 8]
    }
    return ROT[i%4 + 12]
}

func G(i uint8) uint8 {
    if i < 16 {
        return i
    }
    if i < 32 {
        return (5*i + 1)%16
    }
    if i < 48 {
        return (3*i + 5)%16
    }
    return (7*i)%16
}


func md5_bloc(bloc512 [16]uint32, h [4]uint32) {
    // Exéciton de md5 sur un bloc de 512 bits
    // bloc512 est un tableau de 16 mots unsigned long
    a := h[0]
    b := h[1]
    c := h[2]
    d := h[3]

    var i uint8
    for i=0; i<64; i++ {
        f := F(i, b, c, d)
        r := R(i)
        g := G(i)
        T := b + roll_left(a + f + K[i] + bloc512[g], r)
        a = d
        d = c
        c = b
        b = T
    }
    h[0] += a
    h[1] += b
    h[2] += c
    h[3] += d
}

func char_to_long(c []uint8) uint32 {
    // en little indian
    return binary.LittleEndian.Uint32(c)
}

func long_to_str(w uint32) string {
    return fmt.Sprintf("%0x08", w)
}

       
func getMD5String(message string) string {
    var mlen uint64 = uint64(len(message))
    var nblocs uint64 = 1 + (mlen +8) / 64
    
    var bloc [16]uint32

    bm := []uint8(message) // message en bytes
    bm = append(bm, 0x80)
    // bourrage avec des 0
    var z uint64 = nblocs*64 - mlen - 8 - 1
    for z > 0 {
        z -= 1
        bm = append(bm, 0x80)
    }
    // ajout des octets correspondant à la taille
    bmlen := make([]byte, 8)
    binary.LittleEndian.PutUint64(bmlen, mlen)
    for i:=0; i<8; i++ {
        bm = append(bm, bmlen[i])
    }    
    var h = [4]uint32 {H[0], H[1], H[1], H[2]}

    var ibloc uint64
    for ibloc=0; ibloc<nblocs; ibloc++ {
        // fabrication du bloc
        var i uint64
        for i=0; i<16; i++ {
            var j uint64 = ibloc*64 + i*4
            // j est l'adresse du premier des 4 octets à prendre
            var q uint64
            c := make([]uint8, 4)
            for q=0; q<4; q++ {
                c[q] = bm[j+q]
            }
            bloc[i] = char_to_long(c)
        }
        md5_bloc(bloc, h)
    }
    // reste à écrire les caractères de h en mode hexa
    str := ""
    for q :=0; q<4; q++ {
        // on travaillle sur h(q) qui produit 8 caractères
        sub_str := long_to_str(h[q])
        str = str + sub_str
    }
	return str;
}

func main() {
	texte := "jdfgsdhfsdfsd 156445dsfsd7fg/*/+bfjsdgf%$^"
    h := getMD5String(texte)
    fmt.Print(h)
}