package cryptostore_test

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	cmn "github.com/tendermint/tmlibs/common"

	crypto "github.com/tendermint/go-crypto"
	"github.com/tendermint/go-crypto/keys"
	"github.com/tendermint/go-crypto/keys/cryptostore"
	"github.com/tendermint/go-crypto/keys/storage/memstorage"
)

// TestKeyManagement makes sure we can manipulate these keys well
func TestKeyManagement(t *testing.T) {
	assert, require := assert.New(t), require.New(t)

	// make the storage with reasonable defaults
	cstore := cryptostore.New(
		cryptostore.SecretBox,
		memstorage.New(),
		keys.MustLoadCodec("english"),
	)

	algo := crypto.NameEd25519
	n1, n2, n3 := "personal", "business", "other"
	p1, p2 := "1234", "really-secure!@#$"

	// Check empty state
	l, err := cstore.List()
	require.Nil(err)
	assert.Empty(l)

	// create some keys
	_, err = cstore.Get(n1)
	assert.NotNil(err)
	i, _, err := cstore.Create(n1, p1, algo)
	require.Equal(n1, i.Name)
	require.Nil(err)
	_, _, err = cstore.Create(n2, p2, algo)
	require.Nil(err)

	// we can get these keys
	i2, err := cstore.Get(n2)
	assert.Nil(err)
	_, err = cstore.Get(n3)
	assert.NotNil(err)

	// list shows them in order
	keys, err := cstore.List()
	require.Nil(err)
	require.Equal(2, len(keys))
	// note these are in alphabetical order
	assert.Equal(n2, keys[0].Name)
	assert.Equal(n1, keys[1].Name)
	assert.Equal(i2.PubKey, keys[0].PubKey)

	// deleting a key removes it
	err = cstore.Delete("bad name", "foo")
	require.NotNil(err)
	err = cstore.Delete(n1, p1)
	require.Nil(err)
	keys, err = cstore.List()
	require.Nil(err)
	assert.Equal(1, len(keys))
	_, err = cstore.Get(n1)
	assert.NotNil(err)

	// make sure that it only signs with the right password
	// tx := mock.NewSig([]byte("mytransactiondata"))
	// err = cstore.Sign(n2, p1, tx)
	// assert.NotNil(err)
	// err = cstore.Sign(n2, p2, tx)
	// assert.Nil(err, "%+v", err)
	// sigs, err := tx.Signers()
	// assert.Nil(err, "%+v", err)
	// if assert.Equal(1, len(sigs)) {
	// 	assert.Equal(i2.PubKey, sigs[0])
	// }
}

// TestSignVerify does some detailed checks on how we sign and validate
// signatures
// func TestSignVerify(t *testing.T) {
// 	assert, require := assert.New(t), require.New(t)

// 	// make the storage with reasonable defaults
// 	cstore := cryptostore.New(
// 		cryptostore.GenSecp256k1,
// 		cryptostore.SecretBox,
// 		memstorage.New(),
// 	)

// 	n1, n2 := "some dude", "a dudette"
// 	p1, p2 := "1234", "foobar"

// 	// create two users and get their info
// 	err := cstore.Create(n1, p1)
// 	require.Nil(err)
// 	i1, err := cstore.Get(n1)
// 	require.Nil(err)

// 	err = cstore.Create(n2, p2)
// 	require.Nil(err)
// 	i2, err := cstore.Get(n2)
// 	require.Nil(err)

// 	// let's try to sign some messages
// 	d1 := []byte("my first message")
// 	d2 := []byte("some other important info!")

// 	// try signing both data with both keys...
// 	s11, err := cstore.Signature(n1, p1, d1)
// 	require.Nil(err)
// 	s12, err := cstore.Signature(n1, p1, d2)
// 	require.Nil(err)
// 	s21, err := cstore.Signature(n2, p2, d1)
// 	require.Nil(err)
// 	s22, err := cstore.Signature(n2, p2, d2)
// 	require.Nil(err)

// 	// let's try to validate and make sure it only works when everything is proper
// 	keys := [][]byte{i1.PubKey, i2.PubKey}
// 	data := [][]byte{d1, d2}
// 	sigs := [][]byte{s11, s12, s21, s22}

// 	// loop over keys and data
// 	for k := 0; k < 2; k++ {
// 		for d := 0; d < 2; d++ {
// 			// make sure only the proper sig works
// 			good := 2*k + d
// 			for s := 0; s < 4; s++ {
// 				err = cstore.Verify(data[d], sigs[s], keys[k])
// 				if s == good {
// 					assert.Nil(err, "%+v", err)
// 				} else {
// 					assert.NotNil(err)
// 				}
// 			}
// 		}
// 	}
// }

func assertPassword(assert *assert.Assertions, cstore cryptostore.Manager, name, pass, badpass string) {
	err := cstore.Update(name, badpass, pass)
	assert.NotNil(err)
	err = cstore.Update(name, pass, pass)
	assert.Nil(err, "%+v", err)
}

// TestImportUnencrypted tests accepting raw priv keys bytes as input
func TestImportUnencrypted(t *testing.T) {
	require := require.New(t)

	// make the storage with reasonable defaults
	cstore := cryptostore.New(
		cryptostore.SecretBox,
		memstorage.New(),
		keys.MustLoadCodec("english"),
	)

	key := cryptostore.GenEd25519.Generate(cmn.RandBytes(16))
	addr := key.PubKey().Address()
	name := "john"
	pass := "top-secret"

	// import raw bytes
	err := cstore.Import(name, pass, "", key.Bytes())
	require.Nil(err, "%+v", err)

	// make sure the address matches
	info, err := cstore.Get(name)
	require.Nil(err, "%+v", err)
	require.EqualValues(addr, info.Address)
}

// TestAdvancedKeyManagement verifies update, import, export functionality
func TestAdvancedKeyManagement(t *testing.T) {
	assert, require := assert.New(t), require.New(t)

	// make the storage with reasonable defaults
	cstore := cryptostore.New(
		cryptostore.SecretBox,
		memstorage.New(),
		keys.MustLoadCodec("english"),
	)

	algo := crypto.NameSecp256k1
	n1, n2 := "old-name", "new name"
	p1, p2, p3, pt := "1234", "foobar", "ding booms!", "really-secure!@#$"

	// make sure key works with initial password
	_, _, err := cstore.Create(n1, p1, algo)
	require.Nil(err, "%+v", err)
	assertPassword(assert, cstore, n1, p1, p2)

	// update password requires the existing password
	err = cstore.Update(n1, "jkkgkg", p2)
	assert.NotNil(err)
	assertPassword(assert, cstore, n1, p1, p2)

	// then it changes the password when correct
	err = cstore.Update(n1, p1, p2)
	assert.Nil(err)
	// p2 is now the proper one!
	assertPassword(assert, cstore, n1, p2, p1)

	// exporting requires the proper name and passphrase
	_, err = cstore.Export(n2, p2, pt)
	assert.NotNil(err)
	_, err = cstore.Export(n1, p1, pt)
	assert.NotNil(err)
	exported, err := cstore.Export(n1, p2, pt)
	require.Nil(err, "%+v", err)

	// import fails on bad transfer pass
	err = cstore.Import(n2, p3, p2, exported)
	assert.NotNil(err)
}

// TestSeedPhrase verifies restoring from a seed phrase
func TestSeedPhrase(t *testing.T) {
	assert, require := assert.New(t), require.New(t)

	// make the storage with reasonable defaults
	cstore := cryptostore.New(
		cryptostore.SecretBox,
		memstorage.New(),
		keys.MustLoadCodec("english"),
	)

	algo := crypto.NameEd25519
	n1, n2 := "lost-key", "found-again"
	p1, p2 := "1234", "foobar"

	// make sure key works with initial password
	info, seed, err := cstore.Create(n1, p1, algo)
	require.Nil(err, "%+v", err)
	assert.Equal(n1, info.Name)
	assert.NotEmpty(seed)

	// now, let us delete this key
	err = cstore.Delete(n1, p1)
	require.Nil(err, "%+v", err)
	_, err = cstore.Get(n1)
	require.NotNil(err)

	// let us re-create it from the seed-phrase
	newInfo, err := cstore.Recover(n2, p2, seed)
	require.Nil(err, "%+v", err)
	assert.Equal(n2, newInfo.Name)
	assert.Equal(info.Address, newInfo.Address)
	assert.Equal(info.PubKey, newInfo.PubKey)
}

// func ExampleStore() {
// 	// Select the encryption and storage for your cryptostore
// 	cstore := cryptostore.New(
// 		cryptostore.GenEd25519,
// 		cryptostore.SecretBox,
// 		// Note: use filestorage.New(dir) for real data
// 		memstorage.New(),
// 	)

// 	// Add keys and see they return in alphabetical order
// 	cstore.Create("Bob", "friend")
// 	cstore.Create("Alice", "secret")
// 	cstore.Create("Carl", "mitm")
// 	info, _ := cstore.List()
// 	for _, i := range info {
// 		fmt.Println(i.Name)
// 	}

// 	// We need to use passphrase to generate a signature
// 	tx := mock.NewSig([]byte("deadbeef"))
// 	err := cstore.Sign("Bob", "friend", tx)
// 	if err != nil {
// 		fmt.Println("don't accept real passphrase")
// 	}

// 	// and we can validate the signature with publically available info
// 	binfo, _ := cstore.Get("Bob")
// 	sigs, err := tx.Signers()
// 	if err != nil {
// 		fmt.Println("badly signed")
// 	} else if bytes.Equal(sigs[0].Bytes(), binfo.PubKey.Bytes()) {
// 		fmt.Println("signed by Bob")
// 	} else {
// 		fmt.Println("signed by someone else")
// 	}

// 	// Output:
// 	// Alice
// 	// Bob
// 	// Carl
// 	// signed by Bob
// }