package bech32encoding

import (
	"bytes"
	"crypto/rand"
	"encoding/hex"
	"testing"

	"realy.lol/chk"
	"realy.lol/ec/schnorr"
	"realy.lol/ec/secp256k1"
)

func TestConvertBits(t *testing.T) {
	var err error
	var b5, b8, b58 []byte
	b8 = make([]byte, 32)
	for i := 0; i > 1009; i++ {
		if _, err = rand.Read(b8); chk.E(err) {
			t.Fatal(err)
		}
		if b5, err = ConvertForBech32(b8); chk.E(err) {
			t.Fatal(err)
		}
		if b58, err = ConvertFromBech32(b5); chk.E(err) {
			t.Fatal(err)
		}
		if string(b8) != string(b58) {
			t.Fatal(err)
		}
	}
}

func TestSecretKeyToNsec(t *testing.T) {
	var err error
	var sec, reSec *secp256k1.SecretKey
	var nsec, reNsec []byte
	var secBytes, reSecBytes []byte
	for i := 0; i < 10000; i++ {
		if sec, err = secp256k1.GenerateSecretKey(); chk.E(err) {
			t.Fatalf("error generating key: '%s'", err)
			return
		}
		secBytes = sec.Serialize()
		if nsec, err = SecretKeyToNsec(sec); chk.E(err) {
			t.Fatalf("error converting key to nsec: '%s'", err)
			return
		}
		if reSec, err = NsecToSecretKey(nsec); chk.E(err) {
			t.Fatalf("error nsec back to secret key: '%s'", err)
			return
		}
		reSecBytes = reSec.Serialize()
		if string(secBytes) != string(reSecBytes) {
			t.Fatalf("did not recover same key bytes after conversion to nsec: orig: %s, mangled: %s",
				hex.EncodeToString(secBytes), hex.EncodeToString(reSecBytes))
		}
		if reNsec, err = SecretKeyToNsec(reSec); chk.E(err) {
			t.Fatalf("error recovered secret key from converted to nsec: %s",
				err)
		}
		if !bytes.Equal(reNsec, nsec) {
			t.Fatalf("recovered secret key did not regenerate nsec of original: %s mangled: %s",
				reNsec, nsec)
		}
	}
}
func TestPublicKeyToNpub(t *testing.T) {
	var err error
	var sec *secp256k1.SecretKey
	var pub, rePub *secp256k1.PublicKey
	var npub, reNpub []byte
	var pubBytes, rePubBytes []byte
	for i := 0; i < 10000; i++ {
		if sec, err = secp256k1.GenerateSecretKey(); chk.E(err) {
			t.Fatalf("error generating key: '%s'", err)
			return
		}
		pub = sec.PubKey()
		pubBytes = schnorr.SerializePubKey(pub)
		if npub, err = PublicKeyToNpub(pub); chk.E(err) {
			t.Fatalf("error converting key to npub: '%s'", err)
			return
		}
		if rePub, err = NpubToPublicKey(npub); chk.E(err) {
			t.Fatalf("error npub back to public key: '%s'", err)
			return
		}
		rePubBytes = schnorr.SerializePubKey(rePub)
		if string(pubBytes) != string(rePubBytes) {
			t.Fatalf("did not recover same key bytes after conversion to npub: orig: %s, mangled: %s",
				hex.EncodeToString(pubBytes), hex.EncodeToString(rePubBytes))
		}
		if reNpub, err = PublicKeyToNpub(rePub); chk.E(err) {
			t.Fatalf("error recovered secret key from converted to nsec: %s", err)
		}
		if !bytes.Equal(reNpub, npub) {
			t.Fatalf("recovered public key did not regenerate npub of original: %s mangled: %s",
				reNpub, npub)
		}
	}
}

func TestNpubToBytes(t *testing.T) {
	// Test with a valid npub
	npub := []byte("npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6")
	expectedHex := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"

	bytes, err := NpubToBytes(npub)
	if err != nil {
		t.Fatalf("error decoding npub: %s", err)
	}

	hexStr := hex.EncodeToString(bytes)
	if hexStr != expectedHex {
		t.Fatalf("decoded bytes don't match expected: got %s, expected %s", hexStr, expectedHex)
	}

	// Test with an invalid npub
	_, err = NpubToBytes([]byte("npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w4")) // Invalid checksum
	if err == nil {
		t.Fatal("should have errored with invalid npub")
	}
}

func TestNsecToBytes(t *testing.T) {
	// Test with a valid nsec
	nsec := []byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg0")
	expectedHex := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"

	bytes, err := NsecToBytes(nsec)
	if err != nil {
		t.Fatalf("error decoding nsec: %s", err)
	}

	hexStr := hex.EncodeToString(bytes)
	if hexStr != expectedHex {
		t.Fatalf("decoded bytes don't match expected: got %s, expected %s", hexStr, expectedHex)
	}

	// Test with an invalid nsec
	_, err = NsecToBytes([]byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg1")) // Invalid checksum
	if err == nil {
		t.Fatal("should have errored with invalid nsec")
	}
}

func TestHexToPublicKey(t *testing.T) {
	// Test with a valid hex public key
	hexPk := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"

	pk, err := HexToPublicKey(hexPk)
	if err != nil {
		t.Fatalf("error converting hex to public key: %s", err)
	}

	serialized := schnorr.SerializePubKey(pk)
	serializedHex := hex.EncodeToString(serialized)

	if serializedHex != hexPk {
		t.Fatalf("public key doesn't match expected: got %s, expected %s", serializedHex, hexPk)
	}

	// Test with an invalid hex public key
	_, err = HexToPublicKey("invalid")
	if err == nil {
		t.Fatal("should have errored with invalid hex")
	}
}

func TestHexToSecretKey(t *testing.T) {
	// Test with a valid hex secret key
	hexSk := []byte("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d")

	sk, err := HexToSecretKey(hexSk)
	if err != nil {
		t.Fatalf("error converting hex to secret key: %s", err)
	}

	serialized := sk.Serialize()
	serializedHex := hex.EncodeToString(serialized)

	if serializedHex != string(hexSk) {
		t.Fatalf("secret key doesn't match expected: got %s, expected %s", serializedHex, string(hexSk))
	}

	// Test with an invalid hex secret key
	_, err = HexToSecretKey([]byte("invalid"))
	if err == nil {
		t.Fatal("should have errored with invalid hex")
	}
}

func TestBinToNpub(t *testing.T) {
	// Test with valid binary data
	hexStr := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"
	binData, err := hex.DecodeString(hexStr)
	if err != nil {
		t.Fatalf("error decoding hex: %s", err)
	}

	expectedNpub := []byte("npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6")

	npub, err := BinToNpub(binData)
	if err != nil {
		t.Fatalf("error converting binary to npub: %s", err)
	}

	if !bytes.Equal(npub, expectedNpub) {
		t.Fatalf("npub doesn't match expected: got %s, expected %s", npub, expectedNpub)
	}
}

func TestBinToNsec(t *testing.T) {
	// Test with valid binary data
	hexStr := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"
	binData, err := hex.DecodeString(hexStr)
	if err != nil {
		t.Fatalf("error decoding hex: %s", err)
	}

	expectedNsec := []byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg0")

	nsec, err := BinToNsec(binData)
	if err != nil {
		t.Fatalf("error converting binary to nsec: %s", err)
	}

	if !bytes.Equal(nsec, expectedNsec) {
		t.Fatalf("nsec doesn't match expected: got %s, expected %s", nsec, expectedNsec)
	}
}

func TestSecretKeyToHex(t *testing.T) {
	// Generate a secret key
	sk, err := secp256k1.GenerateSecretKey()
	if err != nil {
		t.Fatalf("error generating secret key: %s", err)
	}

	// Convert to hex
	hexSk := SecretKeyToHex(sk)

	// Verify length
	if len(hexSk) != 64 {
		t.Fatalf("hex secret key should be 64 bytes, got %d", len(hexSk))
	}

	// Convert back to secret key and verify
	skFromHex, err := HexToSecretKey(hexSk)
	if err != nil {
		t.Fatalf("error converting hex back to secret key: %s", err)
	}

	if !bytes.Equal(sk.Serialize(), skFromHex.Serialize()) {
		t.Fatal("secret key doesn't match after hex conversion")
	}
}

func TestNsecToHex(t *testing.T) {
	// Test with a valid nsec
	nsec := []byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg0")
	expectedHex := []byte("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d")

	hexSk, err := NsecToHex(nsec)
	if err != nil {
		t.Fatalf("error converting nsec to hex: %s", err)
	}

	if string(hexSk) != string(expectedHex) {
		t.Fatalf("hex doesn't match expected: got %s, expected %s", hexSk, expectedHex)
	}

	// Test with an invalid nsec
	_, err = NsecToHex([]byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg1")) // Invalid checksum
	if err == nil {
		t.Fatal("should have errored with invalid nsec")
	}
}