package goxifrat

import (
	"bytes"
	"crypto/rand"
	"testing"
)

func TestKeyAgreement(t *testing.T) {
	ka, err := NewKeyAgreement(rand.Reader)
	if err != nil {
		t.Error(err)
	}
	kb, err := NewKeyAgreement(rand.Reader)
	if err != nil {
		t.Error(err)
	}
	i, err := ka.InitPhase(rand.Reader)
	if err != nil {
		t.Error(err)
	}
	sb, a, err := kb.SharedSecret(i)
	if err != nil {
		t.Error(err)
	}
	sa, _, err := ka.SharedSecret(a)
	if err != nil {
		t.Error(err)
	}
	if !bytes.Equal(sa, sb) {
		t.Error("shared secrets are not equal")
	}
}

func TestSign(t *testing.T) {
	h, err := randomArray(rand.Reader)
	if err != nil {
		t.Error(err)
	}
	hash := encode(h)
	priv, err := GenerateKey(rand.Reader)
	if err != nil {
		t.Error(err)
	}
	_, err = priv.Sign(rand.Reader, hash)
	if err != nil {
		t.Error(err)
	}
}

func TestVerify(t *testing.T) {
	h, err := randomArray(rand.Reader)
	if err != nil {
		t.Error(err)
	}
	hash := encode(h)
	priv, err := GenerateKey(rand.Reader)
	if err != nil {
		t.Error(err)
	}
	s, err := priv.Sign(rand.Reader, hash)
	if err != nil {
		t.Error(err)
	}
	if !Verify(&priv.PublicKey, hash, s) {
		t.Error("verify failed")
	}
}

func BenchmarkM(b *testing.B) {
	b.ReportAllocs()
	tc, _ := randomArray(rand.Reader)
	tk, _ := randomArray(rand.Reader)
	for i := 0; i < b.N; i++ {
		m(tc, tk)
	}
}

func BenchmarkSign(b *testing.B) {
	b.ReportAllocs()
	h, err := randomArray(rand.Reader)
	if err != nil {
		b.Error(err)
	}
	hash := encode(h)
	priv, err := GenerateKey(rand.Reader)
	if err != nil {
		b.Error(err)
	}
	for i := 0; i < b.N; i++ {
		_, err := priv.Sign(rand.Reader, hash)
		if err != nil {
			b.Error(err)
		}
	}
}

func BenchmarkVerify(b *testing.B) {
	b.ReportAllocs()
	h, err := randomArray(rand.Reader)
	if err != nil {
		b.Error(err)
	}
	hash := encode(h)
	priv, err := GenerateKey(rand.Reader)
	if err != nil {
		b.Error(err)
	}
	s, err := priv.Sign(rand.Reader, hash)
	if err != nil {
		b.Error(err)
	}
	for i := 0; i < b.N; i++ {
		Verify(&priv.PublicKey, hash, s)
	}
}

func BenchmarkEncode(b *testing.B) {
	b.ReportAllocs()
	h, err := randomArray(rand.Reader)
	if err != nil {
		b.Error(err)
	}
	for i := 0; i < b.N; i++ {
		encode(h)
	}
}

func BenchmarkDecode(b *testing.B) {
	b.ReportAllocs()
	h, err := randomArray(rand.Reader)
	if err != nil {
		b.Error(err)
	}
	e := encode(h)
	for i := 0; i < b.N; i++ {
		decode(e)
	}
}