package snapshot

import (
	"errors"
	"testing"

	proxyDomain "github.com/proxy-pool/proxy-pool/internal/domain/proxy"
)

func TestStoreAppliesCompleteSnapshotsInOrder(t *testing.T) {
	store := NewStore("cluster-a", "worker-a")
	first := Envelope{
		ClusterID: "cluster-a",
		WorkerID:  "worker-a",
		Epoch:     1,
		Version:   1,
		Full:      true,
		Proxies: []proxyDomain.Proxy{{
			ID:             "p1",
			Scheme:         proxyDomain.SchemeHTTP,
			Host:           "127.0.0.1",
			Port:           18080,
			MaxConcurrency: 2,
			State:          proxyDomain.StateAvailable,
		}},
	}
	first.Checksum = Checksum(first.Proxies)
	if err := store.Apply(first); err != nil {
		t.Fatalf("Apply(first): %v", err)
	}

	view := store.Current()
	if view == nil || view.Version != 1 || len(view.Entries) != 1 {
		t.Fatalf("Current() = %+v", view)
	}
	if view.Entries[0].Runtime == nil {
		t.Fatal("snapshot entry has no local runtime capacity")
	}

	second := first
	second.Version = 2
	second.Proxies = append([]proxyDomain.Proxy(nil), first.Proxies...)
	second.Proxies[0].Host = "localhost"
	second.Checksum = Checksum(second.Proxies)
	if err := store.Apply(second); err != nil {
		t.Fatalf("Apply(second): %v", err)
	}
	if got := store.Current().Entries[0].Proxy.Host; got != "localhost" {
		t.Fatalf("host = %q, want localhost", got)
	}
}

func TestStoreRejectsWrongWorkerVersionGapAndChecksum(t *testing.T) {
	store := NewStore("cluster-a", "worker-a")
	base := Envelope{ClusterID: "cluster-a", WorkerID: "worker-a", Epoch: 1, Version: 1, Full: true}
	base.Checksum = Checksum(base.Proxies)
	if err := store.Apply(base); err != nil {
		t.Fatalf("Apply(base): %v", err)
	}

	wrongWorker := base
	wrongWorker.Version = 2
	wrongWorker.WorkerID = "worker-b"
	if err := store.Apply(wrongWorker); !errors.Is(err, ErrWrongTarget) {
		t.Fatalf("wrong worker error = %v, want ErrWrongTarget", err)
	}

	gap := base
	gap.Version = 3
	if err := store.Apply(gap); !errors.Is(err, ErrResyncRequired) {
		t.Fatalf("version gap error = %v, want ErrResyncRequired", err)
	}

	badChecksum := base
	badChecksum.Version = 2
	badChecksum.Checksum = "bad"
	if err := store.Apply(badChecksum); !errors.Is(err, ErrChecksumMismatch) {
		t.Fatalf("checksum error = %v, want ErrChecksumMismatch", err)
	}
}