package main

import (
	"crypto/ed25519"
	"crypto/rand"
	"encoding/base64"
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

func testManifest() *releaseManifest {
	return &releaseManifest{
		Schema:      1,
		GeneratedAt: time.Now().UTC(),
		Channels: map[string]releaseEntry{
			"edge": {
				Version: "abc1234",
				URL:     "https://github.com/elevenmessenger/releases/releases/download/server-abc1234/lchat-linux-amd64",
				SHA256:  strings.Repeat("ab", 32),
				Size:    123,
			},
			"stable": {
				Version: "def5678",
				URL:     "https://github.com/elevenmessenger/releases/releases/download/server-def5678/lchat-linux-amd64",
				SHA256:  strings.Repeat("cd", 32),
			},
		},
	}
}

func TestReleaseManifestSignVerifyRoundTrip(t *testing.T) {
	pub, priv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatal(err)
	}
	wrapper, err := signReleaseManifest(priv, testManifest())
	if err != nil {
		t.Fatalf("sign: %v", err)
	}
	m, err := verifyReleaseManifest(pub, wrapper)
	if err != nil {
		t.Fatalf("verify: %v", err)
	}
	if m.Channels["edge"].Version != "abc1234" || m.Channels["stable"].Version != "def5678" {
		t.Fatalf("channels didn't round-trip: %+v", m.Channels)
	}
	if m.GeneratedAt.IsZero() {
		t.Fatal("generated_at not stamped")
	}
	// beta is legitimately unset — a channel may lag behind.
	if _, ok := m.Channels["beta"]; ok {
		t.Fatal("unexpected beta channel")
	}
}

func TestReleaseManifestRejectsTamperAndWrongKey(t *testing.T) {
	pub, priv, _ := ed25519.GenerateKey(rand.Reader)
	otherPub, _, _ := ed25519.GenerateKey(rand.Reader)
	wrapper, err := signReleaseManifest(priv, testManifest())
	if err != nil {
		t.Fatal(err)
	}

	if _, err := verifyReleaseManifest(otherPub, wrapper); err == nil {
		t.Fatal("verified with the wrong public key")
	}

	// Flip the channel pointer inside the payload; the signature must not survive.
	var sm signedManifest
	if err := json.Unmarshal(wrapper, &sm); err != nil {
		t.Fatal(err)
	}
	payload, _ := base64.StdEncoding.DecodeString(sm.Payload)
	tampered := strings.Replace(string(payload), "abc1234", "eee6666", 1)
	sm.Payload = base64.StdEncoding.EncodeToString([]byte(tampered))
	rewrapped, _ := json.Marshal(sm)
	if _, err := verifyReleaseManifest(pub, rewrapped); err == nil {
		t.Fatal("verified a tampered payload")
	}

	if _, err := verifyReleaseManifest(pub, []byte(`{"payload":"","sig":""}`)); err == nil {
		t.Fatal("verified an empty wrapper")
	}
}

func TestValidateManifestRejectsBadEntries(t *testing.T) {
	cases := map[string]func(*releaseManifest){
		"unknown channel": func(m *releaseManifest) { m.Channels["nightly"] = m.Channels["edge"] },
		"bad version":     func(m *releaseManifest) { e := m.Channels["edge"]; e.Version = "../evil"; m.Channels["edge"] = e },
		"dev version":     func(m *releaseManifest) { e := m.Channels["edge"]; e.Version = "dev"; m.Channels["edge"] = e },
		"http url":        func(m *releaseManifest) { e := m.Channels["edge"]; e.URL = "http://x/lchat"; m.Channels["edge"] = e },
		"short sha256":    func(m *releaseManifest) { e := m.Channels["edge"]; e.SHA256 = "abcd"; m.Channels["edge"] = e },
		"non-hex sha256": func(m *releaseManifest) {
			e := m.Channels["edge"]
			e.SHA256 = strings.Repeat("zz", 32)
			m.Channels["edge"] = e
		},
		"unknown schema":   func(m *releaseManifest) { m.Schema = 2 },
		"zero generatedAt": func(m *releaseManifest) { m.GeneratedAt = time.Time{} },
	}
	for name, mutate := range cases {
		m := testManifest()
		mutate(m)
		if err := validateManifest(m); err == nil {
			t.Errorf("%s: validateManifest accepted it", name)
		}
	}
	if err := validateManifest(testManifest()); err != nil {
		t.Errorf("good manifest rejected: %v", err)
	}
}

func TestReleaseEntryForArch(t *testing.T) {
	both := releaseEntry{
		URL: "https://x/amd64", SHA256: strings.Repeat("aa", 32),
		ARM64URL: "https://x/arm64", ARM64SHA256: strings.Repeat("bb", 32),
	}
	if u, s, ok := both.forArch("amd64"); !ok || u != "https://x/amd64" || s != strings.Repeat("aa", 32) {
		t.Fatalf("amd64 = %q %q %v", u, s, ok)
	}
	if u, s, ok := both.forArch("arm64"); !ok || u != "https://x/arm64" || s != strings.Repeat("bb", 32) {
		t.Fatalf("arm64 = %q %q %v", u, s, ok)
	}
	// A pre-arm64 entry: amd64 resolves, arm64 says "no build".
	amdOnly := releaseEntry{URL: "https://x/amd64", SHA256: strings.Repeat("aa", 32)}
	if _, _, ok := amdOnly.forArch("arm64"); ok {
		t.Fatal("arm64 resolved on an amd64-only entry")
	}
	if _, _, ok := amdOnly.forArch("riscv64"); ok {
		t.Fatal("unknown arch resolved")
	}
}

func TestValidateManifestChecksARM64Fields(t *testing.T) {
	m := testManifest()
	e := m.Channels["edge"]
	e.ARM64URL = "http://insecure.example/lchat"
	e.ARM64SHA256 = strings.Repeat("cd", 32)
	m.Channels["edge"] = e
	if err := validateManifest(m); err == nil {
		t.Fatal("http arm64 URL accepted")
	}
	e.ARM64URL = "https://ok.example/lchat"
	e.ARM64SHA256 = "short"
	m.Channels["edge"] = e
	if err := validateManifest(m); err == nil {
		t.Fatal("bad arm64 sha accepted")
	}
	e.ARM64SHA256 = strings.Repeat("cd", 32)
	m.Channels["edge"] = e
	if err := validateManifest(m); err != nil {
		t.Fatalf("good arm64 entry rejected: %v", err)
	}
}

func TestReadReleaseKeyRoundTrip(t *testing.T) {
	pub, priv, _ := ed25519.GenerateKey(rand.Reader)
	path := filepath.Join(t.TempDir(), "key.b64")
	// keygen writes base64(seed) + newline; mirror that.
	if err := os.WriteFile(path, []byte(base64.StdEncoding.EncodeToString(priv.Seed())+"\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	got, err := readReleaseKey(path)
	if err != nil {
		t.Fatal(err)
	}
	if !got.Public().(ed25519.PublicKey).Equal(pub) {
		t.Fatal("key didn't round-trip through the seed file")
	}

	bad := filepath.Join(t.TempDir(), "bad.b64")
	os.WriteFile(bad, []byte("not-a-key\n"), 0o600)
	if _, err := readReleaseKey(bad); err == nil {
		t.Fatal("accepted a malformed key file")
	}
}

// The no-disk path: the seed value itself (as LCHAT_RELEASE_KEY carries it)
// parses straight from a string, tolerating the whitespace a shell fetch
// picks up, and rejects everything that isn't a 32-byte seed.
func TestParseReleaseSeedFromValue(t *testing.T) {
	pub, priv, _ := ed25519.GenerateKey(rand.Reader)
	got, err := parseReleaseSeed(base64.StdEncoding.EncodeToString(priv.Seed())+"\n", "LCHAT_RELEASE_KEY")
	if err != nil {
		t.Fatal(err)
	}
	if !got.Public().(ed25519.PublicKey).Equal(pub) {
		t.Fatal("key didn't round-trip through the env value")
	}
	for _, bad := range []string{"", "not-a-key", base64.StdEncoding.EncodeToString([]byte("short"))} {
		if _, err := parseReleaseSeed(bad, "LCHAT_RELEASE_KEY"); err == nil {
			t.Fatalf("accepted %q as a seed", bad)
		}
	}
}

func TestBakedReleasePubKeyParses(t *testing.T) {
	if _, err := releasePubKey(); err != nil {
		t.Fatalf("baked public key is invalid: %v", err)
	}
}