package workerruntime

import (
	"crypto/sha256"
	"errors"
	"testing"
	"time"
)

func TestNormalizeLabelsClonesAndBoundsValues(t *testing.T) {
	source := map[string]string{"region": "cn-north"}
	labels, err := NormalizeLabels(source)
	if err != nil {
		t.Fatalf("NormalizeLabels(): %v", err)
	}
	labels["region"] = "changed"
	if source["region"] != "cn-north" {
		t.Fatal("NormalizeLabels() aliases the source map")
	}
	if !ValidIdentifier("worker-a:1") || ValidIdentifier("worker a") || ValidIdentifier("") {
		t.Fatal("ValidIdentifier() accepted or rejected an invalid value")
	}
	if _, err := NormalizeLabels(map[string]string{" region": "cn"}); !errors.Is(err, ErrInvalidSession) {
		t.Fatalf("NormalizeLabels(invalid key) error = %v", err)
	}
}

func TestNormalizeReportUsesStableCounterOrdering(t *testing.T) {
	now := time.Date(2026, 7, 31, 9, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60))
	base := Report{
		WorkerID: "worker-a", SessionID: "session-a", Sequence: 1, SnapshotVersion: 7, OwnershipEpoch: 3,
		ObservedAt: now, Counters: []Counter{{ProxyID: "proxy-b", Active: 2}, {ProxyID: "proxy-a", Reserved: 1}},
	}
	normalized, digest, err := NormalizeReport(base)
	if err != nil || normalized.ObservedAt.Location() != time.UTC || normalized.Counters[0].ProxyID != "proxy-a" {
		t.Fatalf("NormalizeReport() = %+v, %x, %v", normalized, digest, err)
	}
	base.Counters[0], base.Counters[1] = base.Counters[1], base.Counters[0]
	_, replayDigest, err := NormalizeReport(base)
	if err != nil || digest != replayDigest {
		t.Fatalf("NormalizeReport(reordered) digest = %x, %v; want %x", replayDigest, err, digest)
	}
	if _, _, err := NormalizeReport(Report{}); !errors.Is(err, ErrInvalidReport) {
		t.Fatalf("NormalizeReport(invalid) error = %v", err)
	}
}

func TestNormalizeSnapshotReferenceAndAcknowledgement(t *testing.T) {
	reference := SnapshotReference{
		WorkerID: "worker-a", Version: 7, OwnershipEpoch: 3, Checksum: sha256.Sum256([]byte("snapshot")),
	}
	if _, err := NormalizeSnapshotReference(reference); err != nil {
		t.Fatalf("NormalizeSnapshotReference(): %v", err)
	}
	acknowledgement := SnapshotAcknowledgement{WorkerID: "worker-a", SessionID: "session-a", Reference: reference, ErrorCode: "apply_failed"}
	if _, err := NormalizeAcknowledgement(acknowledgement); err != nil {
		t.Fatalf("NormalizeAcknowledgement(): %v", err)
	}
	acknowledgement.Reference.WorkerID = "worker-b"
	if _, err := NormalizeAcknowledgement(acknowledgement); !errors.Is(err, ErrInvalidAcknowledgement) {
		t.Fatalf("NormalizeAcknowledgement(worker mismatch) error = %v", err)
	}
}