/*
Package sm3 implements the SM3 Hash algorithms
*/
package sm3

import (
	"hash"

	"xdx.jelly/xgcl/sm"
)

func init() {
	// 注册sm.SM3、sm.SM3WithID到sm.hashs中去.
	sm.RegisterHash(sm.SM3, New)
	sm.RegisterHash(sm.SM3WithID, New)
}

type digest struct {
	h   [8]uint32
	x   [chunk]byte
	nx  int
	len uint64
}

// NewDigest return a new digest type, void change `digest` to `Digest`.
// 相比标准库，增加此函数。
// 在上下文明确使用sm3的时候，可以显示用这个函数来获取sm3的digest实例，
// 而不是通过New()得到Hash接口。
func NewDigest() *digest {
	d := new(digest)
	d.Reset()
	return d
}

// New returns a new hash.Hash computing the SM3 checksum. The Hash also
// implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler to
// marshal and unmarshal the internal state of the hash.
func New() hash.Hash {
	return NewDigest()
}

// Reset reset the states
func (d *digest) Reset() {
	d.h[0] = init0
	d.h[1] = init1
	d.h[2] = init2
	d.h[3] = init3
	d.h[4] = init4
	d.h[5] = init5
	d.h[6] = init6
	d.h[7] = init7
	d.nx = 0
	d.len = 0
}

/*
MarshalBinary和UnmarshalBinary实现了encoding.BinaryMarshaler和
encoding.BinaryMarshaler接口，可以对Sm3的中间状态转化为byte序列存储。
比如kdf函数要计算SM3(z||cnt)， cnt = 1,2,3,4...，可以先update(z),保存此时
状态。

用法：
dig := New()
io.WriteString(dig, "a")
// New 返回的是hash接口, 转换为BinaryMarshaler接口
state, _ := dig.(encoding.BinaryMarshaler).MarshalBinary()
// dig do something
dig.(encoding.BinaryUnmarshaler).UnmarshalBinary(state)

补充：我们增加了NewDigest(), 返回*digest，因此可以直接用赋值保存。
d1 := NewDigest()
// ...
*d2 := *d1
*/

// MarshalBinary implements the encoding.BinaryMarshaler interface
// marshal a digest to []byte to save
// no error return.
func (d *digest) MarshalBinary() ([]byte, error) {
	b := make([]byte, 0, marshaledSize)
	b = append(b, magic...)
	b = appendUint32(b, d.h[0])
	b = appendUint32(b, d.h[1])
	b = appendUint32(b, d.h[2])
	b = appendUint32(b, d.h[3])
	b = appendUint32(b, d.h[4])
	b = appendUint32(b, d.h[5])
	b = appendUint32(b, d.h[6])
	b = appendUint32(b, d.h[7])
	b = append(b, d.x[:]...)
	b = appendUint64(b, d.len)
	return b, nil
}

// UnmarshalBinary implements the encoding.BinaryMarshaler interface
// recover a digest from []byte
func (d *digest) UnmarshalBinary(b []byte) error {
	if len(b) < marshaledSize || string(b[:len(magic)]) != magic {
		return ErrInvalidInput
	}

	b = b[len(magic):]
	b, d.h[0] = consumeUint32(b)
	b, d.h[1] = consumeUint32(b)
	b, d.h[2] = consumeUint32(b)
	b, d.h[3] = consumeUint32(b)
	b, d.h[4] = consumeUint32(b)
	b, d.h[5] = consumeUint32(b)
	b, d.h[6] = consumeUint32(b)
	b, d.h[7] = consumeUint32(b)
	b = b[copy(d.x[:], b):]
	_, d.len = consumeUint64(b)
	d.nx = int(d.len) % chunk
	return nil
}

// Size returns the size of hash digest
func (d *digest) Size() int { return Size }

// BlockSize return the bytes of one block
func (d *digest) BlockSize() int { return BlockSize }

func (d *digest) Write(p []byte) (nn int, err error) {
	nn = len(p)
	d.len += uint64(nn)
	// try to clear d.x
	if d.nx > 0 {
		n := copy(d.x[d.nx:], p)
		d.nx += n
		if d.nx == chunk {
			block(d, d.x[:])
			d.nx = 0
		}
		p = p[n:]
	}

	if len(p) >= chunk {
		// n is multiple of chunk
		n := len(p) &^ (chunk - 1)
		block(d, p[:n])
		p = p[n:]
	}
	if len(p) > 0 {
		d.nx = copy(d.x[:], p)
	}
	return
}

// Sum returns the digest without change the intenal states
func (d *digest) Sum(in []byte) []byte {
	// make a copy
	d0 := *d
	hash := d0.checkSum()
	return append(in, hash[:]...)
}

// Sum returns the SM3 checksum of the data.
func Sum(data ...[]byte) [Size]byte {
	var d digest
	d.Reset()
	for _, x := range data {
		d.Write(x)
	}
	return d.checkSum()
}