package common

import (
	"encoding/hex"
	"math/big"
	"testing"

	ethCommon "github.com/ethereum/go-ethereum/common"
	"github.com/iden3/go-iden3-crypto/babyjub"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestNewPoolL2Tx(t *testing.T) {
	poolL2Tx := &PoolL2Tx{
		FromIdx: 87654,
		ToIdx:   300,
		Amount:  big.NewInt(4),
		TokenID: 5,
		Nonce:   144,
	}
	poolL2Tx, err := NewPoolL2Tx(poolL2Tx)
	assert.NoError(t, err)
	assert.Equal(t, "0x022669acda59b827d20ef5354a3eebd1dffb3972b0a6bf89d18bfd2efa0ab9f41e",
		poolL2Tx.TxID.String())
}

func TestTxCompressedDataAndTxCompressedDataV2JSVectors(t *testing.T) {
	// test vectors values generated from javascript implementation
	var skPositive babyjub.PrivateKey // 'Positive' refers to the sign
	_, err := hex.Decode(skPositive[:],
		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
	assert.NoError(t, err)

	var skNegative babyjub.PrivateKey // 'Negative' refers to the sign
	_, err = hex.Decode(skNegative[:],
		[]byte("0001020304050607080900010203040506070809000102030405060708090002"))
	assert.NoError(t, err)

	amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
	require.True(t, ok)
	tx := PoolL2Tx{
		FromIdx: (1 << 48) - 1,
		ToIdx:   (1 << 48) - 1,
		Amount:  amount,
		TokenID: (1 << 32) - 1,
		Nonce:   (1 << 40) - 1,
		Fee:     (1 << 3) - 1,
		ToBJJ:   skPositive.Public().Compress(),
	}
	txCompressedData, err := tx.TxCompressedData(uint16((1 << 16) - 1))
	require.NoError(t, err)
	expectedStr := "0107ffffffffffffffffffffffffffffffffffffffffffffffc60be60f"
	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))

	txCompressedDataV2, err := tx.TxCompressedDataV2()
	require.NoError(t, err)
	expectedStr = "0107ffffffffffffffffffffffffffffffffffffffffffffffffffff"
	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedDataV2.Bytes()))

	tx = PoolL2Tx{
		FromIdx: 0,
		ToIdx:   0,
		Amount:  big.NewInt(0),
		TokenID: 0,
		Nonce:   0,
		Fee:     0,
		ToBJJ:   skNegative.Public().Compress(),
	}
	txCompressedData, err = tx.TxCompressedData(uint16(0))
	require.NoError(t, err)
	expectedStr = "c60be60f"
	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))

	txCompressedDataV2, err = tx.TxCompressedDataV2()
	require.NoError(t, err)
	assert.Equal(t, "0", txCompressedDataV2.String())

	amount, ok = new(big.Int).SetString("63000000000000000", 10)
	require.True(t, ok)
	tx = PoolL2Tx{
		FromIdx: 324,
		ToIdx:   256,
		Amount:  amount,
		TokenID: 123,
		Nonce:   76,
		Fee:     214,
		ToBJJ:   skNegative.Public().Compress(),
	}
	txCompressedData, err = tx.TxCompressedData(uint16(1))
	require.NoError(t, err)
	expectedStr = "d6000000004c0000007b0000000001000000000001440001c60be60f"
	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))

	txCompressedDataV2, err = tx.TxCompressedDataV2()
	require.NoError(t, err)
	expectedStr = "d6000000004c0000007b3977825f00000000000100000000000144"
	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedDataV2.Bytes()))

	tx = PoolL2Tx{
		FromIdx: 1,
		ToIdx:   2,
		TokenID: 3,
		Nonce:   4,
		Fee:     5,
		ToBJJ:   skNegative.Public().Compress(),
	}
	txCompressedData, err = tx.TxCompressedData(uint16(0))
	require.NoError(t, err)
	expectedStr = "050000000004000000030000000000020000000000010000c60be60f"
	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))

	tx = PoolL2Tx{
		FromIdx: 2,
		ToIdx:   3,
		TokenID: 4,
		Nonce:   5,
		Fee:     6,
		ToBJJ:   skPositive.Public().Compress(),
	}
	txCompressedData, err = tx.TxCompressedData(uint16(0))
	require.NoError(t, err)
	expectedStr = "01060000000005000000040000000000030000000000020000c60be60f"
	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
}

func TestRqTxCompressedDataV2(t *testing.T) {
	var sk babyjub.PrivateKey
	_, err := hex.Decode(sk[:],
		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
	assert.NoError(t, err)
	tx := PoolL2Tx{
		RqFromIdx: 7,
		RqToIdx:   8,
		RqAmount:  big.NewInt(9),
		RqTokenID: 10,
		RqNonce:   11,
		RqFee:     12,
		RqToBJJ:   sk.Public().Compress(),
	}
	txCompressedData, err := tx.RqTxCompressedDataV2()
	assert.NoError(t, err)
	// test vector value generated from javascript implementation
	expectedStr := "110248805340524920412994530176819463725852160917809517418728390663"
	assert.Equal(t, expectedStr, txCompressedData.String())
	expected, ok := new(big.Int).SetString(expectedStr, 10)
	assert.True(t, ok)
	assert.Equal(t, expected.Bytes(), txCompressedData.Bytes())
	assert.Equal(t, "010c000000000b0000000a0000000009000000000008000000000007",
		hex.EncodeToString(txCompressedData.Bytes()))
}

func TestHashToSign(t *testing.T) {
	chainID := uint16(0)
	tx := PoolL2Tx{
		FromIdx:   2,
		ToIdx:     3,
		Amount:    big.NewInt(4),
		TokenID:   5,
		Nonce:     6,
		ToEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
	}
	toSign, err := tx.HashToSign(chainID)
	assert.NoError(t, err)
	assert.Equal(t, "0b8abaf6b7933464e4450df2514da8b72606c02bf7f89bf6e54816fbda9d9d57",
		hex.EncodeToString(toSign.Bytes()))
}

func TestVerifyTxSignature(t *testing.T) {
	chainID := uint16(0)
	var sk babyjub.PrivateKey
	_, err := hex.Decode(sk[:],
		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
	assert.NoError(t, err)
	tx := PoolL2Tx{
		FromIdx:     2,
		ToIdx:       3,
		Amount:      big.NewInt(4),
		TokenID:     5,
		Nonce:       6,
		ToBJJ:       sk.Public().Compress(),
		RqToEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
		RqToBJJ:     sk.Public().Compress(),
	}
	toSign, err := tx.HashToSign(chainID)
	assert.NoError(t, err)
	assert.Equal(t,
		"3144939470626721092564692894890580265754250231349521601298746071096761507003",
		toSign.String())

	sig := sk.SignPoseidon(toSign)
	tx.Signature = sig.Compress()
	assert.True(t, tx.VerifySignature(chainID, sk.Public().Compress()))
}

func TestVerifyTxSignatureEthAddrWith0(t *testing.T) {
	chainID := uint16(5)
	var sk babyjub.PrivateKey
	_, err := hex.Decode(sk[:],
		[]byte("02f0b4f87065af3797aaaf934e8b5c31563c17f2272fa71bd0146535bfbb4184"))
	assert.NoError(t, err)
	tx := PoolL2Tx{
		FromIdx:   10659,
		ToIdx:     0,
		ToEthAddr: ethCommon.HexToAddress("0x0004308BD15Ead4F1173624dC289DBdcC806a309"),
		Amount:    big.NewInt(5000),
		TokenID:   0,
		Nonce:     946,
		Fee:       231,
	}
	toSign, err := tx.HashToSign(chainID)
	assert.NoError(t, err)

	sig := sk.SignPoseidon(toSign)
	assert.Equal(t,
		"f208b8298d5f37148ac3c0c03703272ea47b9f836851bcf8dd5f7e4e3b336ca1d2f6e92ad85dc25f174daf7a0abfd5f71dead3f059b783f4c4b2f56a18a47000",
		sig.Compress().String(),
	)
	tx.Signature = sig.Compress()
	assert.True(t, tx.VerifySignature(chainID, sk.Public().Compress()))
}

func TestDecompressEmptyBJJComp(t *testing.T) {
	pkComp := EmptyBJJComp
	pk, err := pkComp.Decompress()
	require.NoError(t, err)
	assert.Equal(t,
		"2957874849018779266517920829765869116077630550401372566248359756137677864698",
		pk.X.String())
	assert.Equal(t, "0", pk.Y.String())
}

func TestPoolL2TxID(t *testing.T) {
	tx0 := PoolL2Tx{
		FromIdx: 5,
		ToIdx:   5,
		Amount:  big.NewInt(5),
		Fee:     126,
		TokenID: 5,
		Nonce:   5,
	}
	err := tx0.SetID()
	require.NoError(t, err)

	// differ TokenID
	tx1 := PoolL2Tx{
		FromIdx: 5,
		ToIdx:   5,
		Amount:  big.NewInt(5),
		Fee:     126,
		TokenID: 4,
		Nonce:   5,
	}
	err = tx1.SetID()
	require.NoError(t, err)
	assert.NotEqual(t, tx0.TxID, tx1.TxID)
	// differ Nonce
	tx1 = PoolL2Tx{
		FromIdx: 5,
		ToIdx:   5,
		Amount:  big.NewInt(5),
		Fee:     126,
		TokenID: 5,
		Nonce:   4,
	}
	err = tx1.SetID()
	require.NoError(t, err)
	assert.NotEqual(t, tx0.TxID, tx1.TxID)
	// differ Fee
	tx1 = PoolL2Tx{
		FromIdx: 5,
		ToIdx:   5,
		Amount:  big.NewInt(5),
		Fee:     124,
		TokenID: 5,
		Nonce:   5,
	}
	err = tx1.SetID()
	require.NoError(t, err)
	assert.NotEqual(t, tx0.TxID, tx1.TxID)
}