package release

import (
	"context"
	"errors"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/credentials"
	awss3 "github.com/aws/aws-sdk-go-v2/service/s3"
)

func TestGetIfChangedDirStore(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	d := NewDirStore(t.TempDir())
	const key = "apps/bab/shop/instances/h.json"
	if _, err := d.Put(ctx, key, []byte("one"), ""); err != nil {
		t.Fatal(err)
	}
	var cg ConditionalGetter = d
	body, e, changed, err := cg.GetIfChanged(ctx, key, "")
	if err != nil || !changed || string(body) != "one" || e == "" {
		t.Fatalf("empty etag: %q %q %v %v", body, e, changed, err)
	}
	_, ge, err := d.Get(ctx, key)
	if err != nil || ge != e {
		t.Fatalf("GetIfChanged etag %q, Get etag %q (%v)", e, ge, err)
	}
	body, e2, changed, err := cg.GetIfChanged(ctx, key, e)
	if err != nil || changed || body != nil || e2 != e {
		t.Fatalf("unchanged: %q %q %v %v", body, e2, changed, err)
	}
	if _, err := d.Put(ctx, key, []byte("two"), e); err != nil {
		t.Fatal(err)
	}
	body, e3, changed, err := cg.GetIfChanged(ctx, key, e)
	if err != nil || !changed || string(body) != "two" || e3 == e {
		t.Fatalf("rewritten: %q %q %v %v", body, e3, changed, err)
	}
}

func TestGetIfChangedAbsent(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	d := NewDirStore(t.TempDir())
	for _, etag := range []string{"", "some-etag"} {
		_, _, changed, err := d.GetIfChanged(ctx, "apps/bab/shop/absent.json", etag)
		if !errors.Is(err, os.ErrNotExist) || changed {
			t.Fatalf("etag %q: changed=%v err=%v", etag, changed, err)
		}
	}
}

func TestListETagsMatchesGet(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	d := NewDirStore(t.TempDir())
	keys := []string{"apps/bab/shop/b.json", "apps/bab/shop/a.json", "apps/bab/other/c.json", "accounts/bab/x.json"}
	for i, k := range keys {
		if _, err := d.Put(ctx, k, []byte{byte('a' + i)}, ""); err != nil {
			t.Fatal(err)
		}
	}
	var el ETagLister = d
	got, err := el.ListETags(ctx, "apps/bab/")
	if err != nil {
		t.Fatal(err)
	}
	want := []string{"apps/bab/other/c.json", "apps/bab/shop/a.json", "apps/bab/shop/b.json"}
	if len(got) != len(want) {
		t.Fatalf("listed %v, want keys %v", got, want)
	}
	for i, ke := range got {
		if ke.Key != want[i] {
			t.Fatalf("entry %d: %q, want %q (sorted by key)", i, ke.Key, want[i])
		}
		_, e, err := d.Get(ctx, ke.Key)
		if err != nil || e != ke.ETag {
			t.Fatalf("%s: listed etag %q, Get etag %q (%v)", ke.Key, ke.ETag, e, err)
		}
	}
	none, err := d.ListETags(ctx, "nothing/")
	if err != nil || len(none) != 0 {
		t.Fatalf("empty prefix: %v %v", none, err)
	}
}

func TestPrefixStoreForwardsReadExtensions(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	inner := NewDirStore(t.TempDir())
	if _, err := inner.Put(ctx, "fleets/f/apps/bab/shop/x.json", []byte("x"), ""); err != nil {
		t.Fatal(err)
	}
	if _, err := inner.Put(ctx, "fleets/g/apps/bab/shop/y.json", []byte("y"), ""); err != nil {
		t.Fatal(err)
	}
	s := NewPrefixStore(inner, "fleets/f/")
	cg, ok := s.(ConditionalGetter)
	if !ok {
		t.Fatal("prefix store does not forward ConditionalGetter")
	}
	el, ok := s.(ETagLister)
	if !ok {
		t.Fatal("prefix store does not forward ETagLister")
	}
	body, e, changed, err := cg.GetIfChanged(ctx, "apps/bab/shop/x.json", "")
	if err != nil || !changed || string(body) != "x" {
		t.Fatalf("GetIfChanged: %q %v %v", body, changed, err)
	}
	if _, _, changed, err = cg.GetIfChanged(ctx, "apps/bab/shop/x.json", e); err != nil || changed {
		t.Fatalf("unchanged through prefix: %v %v", changed, err)
	}
	if _, _, _, err = cg.GetIfChanged(ctx, "apps/bab/shop/y.json", ""); !errors.Is(err, os.ErrNotExist) {
		t.Fatalf("other fleet's key must be absent: %v", err)
	}
	got, err := el.ListETags(ctx, "apps/")
	if err != nil || len(got) != 1 || got[0].Key != "apps/bab/shop/x.json" || got[0].ETag != e {
		t.Fatalf("ListETags: %v %v", got, err)
	}
}

// bareStore has none of the optional extensions.
type bareStore struct{ Store }

func TestPrefixStoreWithoutExtensionsRefuses(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	s := NewPrefixStore(bareStore{NewDirStore(t.TempDir())}, "fleets/f/")
	if _, _, _, err := s.(ConditionalGetter).GetIfChanged(ctx, "k", ""); !errors.Is(err, errors.ErrUnsupported) {
		t.Fatalf("GetIfChanged: %v", err)
	}
	if _, err := s.(ETagLister).ListETags(ctx, "k"); !errors.Is(err, errors.ErrUnsupported) {
		t.Fatalf("ListETags: %v", err)
	}
}

// The SDK reports a 304 from GetObject as an error; GetIfChanged must read it
// as "unchanged". A loopback server stands in for the 304 so the mapping runs
// here, not only against MinIO in CI.
func TestS3GetIfChangedMaps304(t *testing.T) {
	t.Parallel()
	const etag = `"abc123"`
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get("If-None-Match") == etag {
			w.WriteHeader(http.StatusNotModified)
			return
		}
		w.Header().Set("ETag", etag)
		_, _ = w.Write([]byte("body"))
	}))
	defer srv.Close()
	client := awss3.New(awss3.Options{
		Region:       "us-east-1",
		Credentials:  credentials.NewStaticCredentialsProvider("k", "s", ""),
		BaseEndpoint: aws.String(srv.URL),
		UsePathStyle: true,
		Retryer:      aws.NopRetryer{},
	})
	s := &S3Store{Client: client, Bucket: "b"}
	ctx := context.Background()
	body, e, changed, err := s.GetIfChanged(ctx, "k", "")
	if err != nil || !changed || string(body) != "body" || e != etag {
		t.Fatalf("empty etag: %q %q %v %v", body, e, changed, err)
	}
	body, e, changed, err = s.GetIfChanged(ctx, "k", etag)
	if err != nil || changed || body != nil || e != etag {
		t.Fatalf("304: %q %q %v %v", body, e, changed, err)
	}
	body, e, changed, err = s.GetIfChanged(ctx, "k", `"other"`)
	if err != nil || !changed || string(body) != "body" {
		t.Fatalf("stale etag: %q %q %v %v", body, e, changed, err)
	}
}