package accountKeys_test

import "seekia/internal/network/accountKeys"

import "seekia/internal/encoding"

import "testing"
import "bytes"

func TestAccountKeys(t *testing.T){

	testSeedPhraseHashHex := "2a66776f76662444f2cadbdb408485db11e58ef1f262c9afcc11ab8d07c0e762"

	testSeedPhraseHashBytes, err := encoding.DecodeHexStringToBytes(testSeedPhraseHashHex)
	if (err != nil){
		t.Fatalf("Invalid testSeedPhraseHash: Not Hex: " + err.Error())
	}

	if (len(testSeedPhraseHashBytes) != 32){
		t.Fatalf("Invalid testSeedPhraseHash: Invalid length.")
	}

	testSeedPhraseHashArray := [32]byte(testSeedPhraseHashBytes)

	expectedPublicKeyHex := "4819fbbac7d06bc21e3e55e7f0286465b72b5468814bf77b9feb38088de21f7c"

	expectedPublicKeyBytes, err := encoding.DecodeHexStringToBytes(expectedPublicKeyHex)
	if (err != nil){
		t.Fatalf("expectedPublicKeyHex is invalid: Not Hex: " + err.Error())
	}

	expectedPrivateKeyHex := "30832da4d36f9ec2fd1ce227cad6b3089683fb761fde7242b137cb5d659a48f74819fbbac7d06bc21e3e55e7f0286465b72b5468814bf77b9feb38088de21f7c"

	expectedPrivateKeyBytes, err := encoding.DecodeHexStringToBytes(expectedPrivateKeyHex)
	if (err != nil){
		t.Fatalf("expectedPrivateKeyBytes is invalid: Not Hex: " + err.Error())
	}

	publicKey, privateKey, err := accountKeys.GetCreditAccountPublicPrivateKeys(testSeedPhraseHashArray, 1, "Identifier", 1)
	if (err != nil){
		t.Fatalf("Failed to derive credit account public/private keys: " + err.Error())
	}

	areEqual := bytes.Equal(publicKey[:], expectedPublicKeyBytes)
	if (areEqual == false){
		publicKeyHex := encoding.EncodeBytesToHexString(publicKey[:])
		t.Fatalf("Account Identifier public key is not expected: " + publicKeyHex)
	}

	areEqual = bytes.Equal(privateKey[:], expectedPrivateKeyBytes)
	if (areEqual == false){
		privateKeyHex := encoding.EncodeBytesToHexString(privateKey[:])
		t.Fatalf("Account Identifier private key is not expected: " + privateKeyHex)
	}

	newIdentifier, err := accountKeys.GetAccountIdentifierFromAccountPublicKey(publicKey)
	if (err != nil){
		t.Fatalf("Failed to derive Identifier from account public key: " + err.Error())
	}

	if (newIdentifier != "d7d1458ee1ae30f530b6276b3e71"){
		t.Fatalf("Account Identifier is not expected: " + newIdentifier)
	}

	{
		expectedAccountPublicKeyHex := "4388ea42cce699c93f2d0f5a44846363620b933f2ccf4038e991aedf96b8ebba"

		expectedAccountPublicKeyBytes, err := encoding.DecodeHexStringToBytes(expectedAccountPublicKeyHex)
		if (err != nil){
			t.Fatalf("expectedAccountPublicKeyHex is invalid: Not Hex: " + err.Error())
		}

		expectedAccountPrivateKeyHex := "ecbc905488d03f2dc0ec5cd8b5cd9805ae7bd599cacd33d65de1558c4f8ac3be4388ea42cce699c93f2d0f5a44846363620b933f2ccf4038e991aedf96b8ebba"

		expectedAccountPrivateKeyBytes, err := encoding.DecodeHexStringToBytes(expectedAccountPrivateKeyHex)
		if (err != nil){
			t.Fatalf("expectedAccountPrivateKeyHex is invalid: Not Hex: " + err.Error())
		}

		accountPublicKey, accountPrivateKey, err := accountKeys.GetCreditAccountPublicPrivateKeys(testSeedPhraseHashArray, 2, "Ethereum", 1)
		if (err != nil){
			t.Fatalf("Failed to derive credit accout public/private keys: " + err.Error())
		}
		
		areEqual = bytes.Equal(accountPublicKey[:], expectedAccountPublicKeyBytes)
		if (areEqual == false){
			accountPublicKeyHex := encoding.EncodeBytesToHexString(accountPublicKey[:])
			t.Fatalf("Account Ethereum public key is not expected: " + accountPublicKeyHex)
		}
		
		areEqual = bytes.Equal(accountPrivateKey[:], expectedAccountPrivateKeyBytes)
		if (areEqual == false){
			accountPrivateKeyHex := encoding.EncodeBytesToHexString(accountPrivateKey[:])
			t.Fatalf("Account Ethereum private key is not expected: " + accountPrivateKeyHex)
		}

		newAddress, err := accountKeys.GetCryptocurrencyAddressFromAccountPublicKey("Ethereum", accountPublicKey)
		if (err != nil){
			t.Fatalf("Failed to derive Ethereum address from account public key: " + err.Error())
		}
		if (newAddress != "0x9470096c6a003F215D5F5497Ab14B9138D36eBAB"){
			t.Fatalf("Account Ethereum address is not expected: " + newAddress)
		}
	}

	{

		expectedAccountPublicKeyHex := "58af93381ab57eab44d087213737197b99706354f76c717cf10713175f759eff"

		expectedAccountPublicKeyBytes, err := encoding.DecodeHexStringToBytes(expectedAccountPublicKeyHex)
		if (err != nil){
			t.Fatalf("expectedAccountPublicKeyHex is invalid: Not Hex: " + err.Error())
		}

		expectedAccountPrivateKeyHex := "776583a8077c411b86ed7ebb431b1e34885020e701ee15d7e80b5919517b24ad58af93381ab57eab44d087213737197b99706354f76c717cf10713175f759eff"

		expectedAccountPrivateKeyBytes, err := encoding.DecodeHexStringToBytes(expectedAccountPrivateKeyHex)
		if (err != nil){
			t.Fatalf("expectedAccountPrivateKeyHex is invalid: Not Hex: " + err.Error())
		}

		accountPublicKey, accountPrivateKey, err := accountKeys.GetCreditAccountPublicPrivateKeys(testSeedPhraseHashArray, 2, "Cardano", 1)
		if (err != nil){
			t.Fatalf("Failed to derive credit accout public/private keys: " + err.Error())
		}
		
		areEqual = bytes.Equal(accountPublicKey[:], expectedAccountPublicKeyBytes)
		if (areEqual == false){
			accountPublicKeyHex := encoding.EncodeBytesToHexString(accountPublicKey[:])
			t.Fatalf("Account Cardano public key is not expected: " + accountPublicKeyHex)
		}
		
		areEqual = bytes.Equal(accountPrivateKey[:], expectedAccountPrivateKeyBytes)
		if (areEqual == false){
			accountPrivateKeyHex := encoding.EncodeBytesToHexString(accountPrivateKey[:])
			t.Fatalf("Account Cardano private key is not expected: " + accountPrivateKeyHex)
		}

		newAddress, err := accountKeys.GetCryptocurrencyAddressFromAccountPublicKey("Cardano", accountPublicKey)
		if (err != nil){
			t.Fatalf("Failed to derive Cardano address from account public key: " + err.Error())
		}
		if (newAddress != "addr1v9j3g9hlca5x9akv2vjm9sp33uu646narslp8pjnr5venuq5c705l"){
			t.Fatalf("Account Cardano address is not expected: " + newAddress)
		}
	}

	
}