// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ibe

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

func TestBB1Correctness(t *testing.T) {
	master, err := SetupBB1()
	if err != nil {
		t.Fatal(err)
	}
	const (
		alice = "alice"
		bob   = "bob"
	)
	// Extract
	aliceSK, err := master.Extract(alice)
	if err != nil {
		t.Fatal(err)
	}
	aliceSK2, err := master.Extract(alice)
	if err != nil {
		t.Fatal(err)
	} else if reflect.DeepEqual(aliceSK, aliceSK2) {
		t.Fatal("Two Extract operations yielded the same PrivateKey!")
	}
	bobSK, err := master.Extract(bob)
	if err != nil {
		t.Fatal(err)
	}

	// Encrypt
	var (
		m     Plaintext
		C, C2 Ciphertext
	)
	if n := copy(m[:], []byte("AThirtyTwoBytePieceOfTextThisIs!")); n != len(m) {
		t.Fatalf("Test string must be %d bytes, not %d", len(m), n)
	}
	if err := master.Params().Encrypt(alice, &m, &C); err != nil {
		t.Fatal(err)
	}
	if err := master.Params().Encrypt(alice, &m, &C2); err != nil {
		t.Fatal(err)
	}
	if bytes.Equal(C[:], C2[:]) {
		t.Errorf("Repeated encryptions of the identical plaintext should not produce identical ciphertext")
	}

	// Decrypt
	decrypt := func(sk PrivateKey) (*Plaintext, error) {
		var ret Plaintext
		if err := sk.Decrypt(&C, &ret); err != nil {
			return nil, err
		}
		return &ret, nil
	}
	if decrypted, err := decrypt(aliceSK); err != nil || !bytes.Equal(decrypted[:], m[:]) {
		t.Errorf("Got (%v, %v), want (%v, nil)", decrypted, err, m[:])
	}
	if decrypted, err := decrypt(aliceSK2); err != nil || !bytes.Equal(decrypted[:], m[:]) {
		t.Errorf("Got (%v, %v), want (%v, nil)", decrypted, err, m[:])
	}
	if decrypted, _ := decrypt(bobSK); bytes.Equal(decrypted[:], m[:]) {
		t.Errorf("Decrypted message with a different PrivateKey")
	}
}

var (
	bb1        Master
	bb1SK      PrivateKey
	benchmarkm Plaintext
	bb1C       Ciphertext
)

func init() {
	var err error
	if bb1, err = SetupBB1(); err != nil {
		panic(err)
	}
	if bb1SK, err = bb1.Extract("alice"); err != nil {
		panic(err)
	}
	if _, err := rand.Read(benchmarkm[:]); err != nil {
		panic(err)
	}
	if err := bb1.Params().Encrypt("alice", &benchmarkm, &bb1C); err != nil {
		panic(err)
	}
}

func BenchmarkExtractBB1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if _, err := bb1.Extract("alice"); err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkEncryptBB(b *testing.B) {
	p := bb1.Params()
	var C Ciphertext
	for i := 0; i < b.N; i++ {
		if err := p.Encrypt("alice", &benchmarkm, &C); err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkDecryptBB(b *testing.B) {
	var m Plaintext
	for i := 0; i < b.N; i++ {
		if err := bb1SK.Decrypt(&bb1C, &m); err != nil {
			b.Fatal(err)
		}
	}
}