package common

import (
	"crypto/ed25519"
	"crypto/rand"
	"encoding/base64"
	"strings"
	"testing"
)

func TestVerifyEd25519Signature_RoundTrip(t *testing.T) {
	pub, priv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("generate key: %v", err)
	}
	msg := []byte("hello world")
	sig := ed25519.Sign(priv, msg)

	pubB64 := base64.StdEncoding.EncodeToString(pub)
	sigB64 := base64.StdEncoding.EncodeToString(sig)

	if err := VerifyEd25519Signature(pubB64, msg, sigB64); err != nil {
		t.Fatalf("expected verify to pass, got error: %v", err)
	}
}

func TestVerifyEd25519Signature_WrongMessage(t *testing.T) {
	pub, priv, _ := ed25519.GenerateKey(rand.Reader)
	sig := ed25519.Sign(priv, []byte("real"))

	err := VerifyEd25519Signature(
		base64.StdEncoding.EncodeToString(pub),
		[]byte("forged"),
		base64.StdEncoding.EncodeToString(sig),
	)
	if err == nil {
		t.Fatal("expected verify to fail on tampered message, got nil")
	}
}

func TestVerifyEd25519Signature_TamperedSignature(t *testing.T) {
	pub, priv, _ := ed25519.GenerateKey(rand.Reader)
	sig := ed25519.Sign(priv, []byte("hello"))
	sig[0] ^= 0xff

	err := VerifyEd25519Signature(
		base64.StdEncoding.EncodeToString(pub),
		[]byte("hello"),
		base64.StdEncoding.EncodeToString(sig),
	)
	if err == nil {
		t.Fatal("expected verify to fail on tampered signature, got nil")
	}
}

func TestVerifyEd25519Signature_MalformedInputs(t *testing.T) {
	cases := []struct {
		name    string
		pubkey  string
		message []byte
		sig     string
		wantSub string // substring that must appear in the error message
	}{
		{"empty_pubkey", "", []byte("x"), "AAAA", "empty public key"},
		{"empty_sig", base64Of32Zeros(), []byte("x"), "", "empty signature"},
		{"bad_pubkey_b64", "!!!not-base64!!!", []byte("x"), base64Of64Zeros(), "valid base64"},
		{"short_pubkey", base64.StdEncoding.EncodeToString([]byte("short")), []byte("x"), base64Of64Zeros(), "wrong length"},
		{"bad_sig_b64", base64Of32Zeros(), []byte("x"), "!!!not-base64!!!", "valid base64"},
		{"short_sig", base64Of32Zeros(), []byte("x"), base64.StdEncoding.EncodeToString([]byte("short")), "wrong length"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			err := VerifyEd25519Signature(tc.pubkey, tc.message, tc.sig)
			if err == nil {
				t.Fatalf("expected error containing %q, got nil", tc.wantSub)
			}
			if !strings.Contains(err.Error(), tc.wantSub) {
				t.Fatalf("expected error to contain %q, got %q", tc.wantSub, err.Error())
			}
		})
	}
}

func base64Of32Zeros() string {
	var b [32]byte
	return base64.StdEncoding.EncodeToString(b[:])
}

func base64Of64Zeros() string {
	var b [64]byte
	return base64.StdEncoding.EncodeToString(b[:])
}