package proxy

import (
	"context"
	"errors"
	"net/http"
	"net/http/httptest"
	"sync/atomic"
	"testing"
	"time"

	_ "git.unkin.net/unkin/artifactapi/internal/provider/rpm"
	"git.unkin.net/unkin/artifactapi/pkg/models"
)

// changingUpstream serves every path with the current revision, as a mirror
// does after a sync replaces its repodata. It answers 304 to a matching
// If-None-Match and counts conditional requests.
func changingUpstream(t *testing.T) (*httptest.Server, *atomic.Value, *atomic.Int32) {
	t.Helper()
	var rev atomic.Value
	var conditional atomic.Int32
	rev.Store("rev1")
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		v := rev.Load().(string)
		etag := `"` + v + `"`
		w.Header().Set("ETag", etag)
		if inm := r.Header.Get("If-None-Match"); inm != "" {
			conditional.Add(1)
			if inm == etag {
				w.WriteHeader(http.StatusNotModified)
				return
			}
		}
		_, _ = w.Write([]byte(v + ":" + r.URL.Path))
	}))
	t.Cleanup(srv.Close)
	return srv, &rev, &conditional
}

func fetchBody(t *testing.T, r models.Remote, path string) string {
	t.Helper()
	res, err := testEngine.Fetch(context.Background(), r, path, prov(t, models.PackageRPM))
	if err != nil {
		t.Fatalf("fetch %s: %v", path, err)
	}
	return readAll(t, res)
}

func rpmRemote(t *testing.T, name, baseURL string) models.Remote {
	return seed(t, models.Remote{Name: name, PackageType: models.PackageRPM, RepoType: models.RepoTypeRemote, BaseURL: baseURL, MutableTTL: 7200, CheckMutable: true})
}

func TestEvictMutableIndexRefetches(t *testing.T) {
	requireStack(t)
	srv, rev, conditional := changingUpstream(t)
	r := rpmRemote(t, "evict-idx", srv.URL)
	const path = "8/Everything/x86_64/repodata/repomd.xml"

	if got := fetchBody(t, r, path); got != "rev1:/"+path {
		t.Fatalf("initial fetch = %q", got)
	}
	rev.Store("rev2")
	if got := fetchBody(t, r, path); got != "rev1:/"+path {
		t.Fatalf("within TTL = %q, want cached rev1", got)
	}
	if err := testEngine.Evict(context.Background(), r.Name, path); err != nil {
		t.Fatalf("evict: %v", err)
	}
	conditional.Store(0)
	if got := fetchBody(t, r, path); got != "rev2:/"+path {
		t.Fatalf("after evict = %q, want rev2", got)
	}
	if n := conditional.Load(); n != 0 {
		t.Errorf("post-evict fetch revalidated with the evicted ETag (%d conditional requests)", n)
	}
}

func TestEvictRejectsBareWildcard(t *testing.T) {
	requireStack(t)
	srv, _, _ := changingUpstream(t)
	r := rpmRemote(t, "evict-bare", srv.URL)
	const path = "8/Everything/x86_64/repodata/repomd.xml"
	fetchBody(t, r, path)

	var pe *ProxyError
	if err := testEngine.Evict(context.Background(), r.Name, "*"); !errors.As(err, &pe) || pe.Status != http.StatusBadRequest {
		t.Fatalf("evict * = %v, want 400", err)
	}
	if fresh, _ := testEngine.cache.CheckTTL(context.Background(), r.Name, path); !fresh {
		t.Error("bare * evicted cached keys")
	}
}

func TestEvictUnknownRemote(t *testing.T) {
	requireStack(t)
	var pe *ProxyError
	if err := testEngine.Evict(context.Background(), "evict-no-such-remote", "a/b"); !errors.As(err, &pe) || pe.Status != http.StatusNotFound {
		t.Fatalf("evict unknown remote = %v, want 404", err)
	}
}

func TestEvictWaitsForFetchLock(t *testing.T) {
	requireStack(t)
	srv, _, _ := changingUpstream(t)
	r := rpmRemote(t, "evict-lock", srv.URL)
	ctx := context.Background()
	const path = "8/Everything/x86_64/repodata/repomd.xml"
	if ok, err := testEngine.cache.AcquireLock(ctx, r.Name, path, time.Minute); !ok || err != nil {
		t.Fatalf("acquire: %v %v", ok, err)
	}
	done := make(chan error, 1)
	go func() { done <- testEngine.Evict(ctx, r.Name, path) }()
	select {
	case err := <-done:
		t.Fatalf("evict returned while fetch lock held: %v", err)
	case <-time.After(200 * time.Millisecond):
	}
	_ = testEngine.cache.ReleaseLock(ctx, r.Name, path)
	if err := <-done; err != nil {
		t.Fatalf("evict: %v", err)
	}
}

func TestEvictWildcardClearsPrefixOnly(t *testing.T) {
	requireStack(t)
	srv, rev, _ := changingUpstream(t)
	r := rpmRemote(t, "evict-wild", srv.URL)
	const (
		repomd = "8/Everything/x86_64/repodata/repomd.xml"
		rpm    = "8/Everything/x86_64/Packages/a/a-1.0-1.el8.x86_64.rpm"
		other  = "9/Everything/x86_64/repodata/repomd.xml"
	)
	for _, p := range []string{repomd, rpm, other} {
		fetchBody(t, r, p)
	}
	rev.Store("rev2")

	if err := testEngine.Evict(context.Background(), r.Name, "8/Everything/x86_64/*"); err != nil {
		t.Fatalf("evict: %v", err)
	}
	if got := fetchBody(t, r, repomd); got != "rev2:/"+repomd {
		t.Errorf("index under prefix = %q, want rev2", got)
	}
	if got := fetchBody(t, r, rpm); got != "rev2:/"+rpm {
		t.Errorf("artifact under prefix = %q, want rev2", got)
	}
	if got := fetchBody(t, r, other); got != "rev1:/"+other {
		t.Errorf("path outside prefix = %q, want cached rev1", got)
	}
}