package release

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func shaOf(b []byte) string { s := sha256.Sum256(b); return hex.EncodeToString(s[:]) }

func TestFetchToFileStreamsAndVerifies(t *testing.T) {
	ctx := context.Background()
	body := []byte(strings.Repeat("carlos", 10000))
	for name, s := range map[string]Store{
		"dir":    NewDirStore(t.TempDir()),
		"prefix": NewPrefixStore(NewDirStore(t.TempDir()), "fleets/pi/"),
	} {
		t.Run(name, func(t *testing.T) {
			if _, err := s.Put(ctx, "bootstrap/router/v1/carlos-linux-arm64", body, ""); err != nil {
				t.Fatal(err)
			}
			dst := filepath.Join(t.TempDir(), "carlos")
			if err := FetchToFile(ctx, s, "bootstrap/router/v1/carlos-linux-arm64", dst, int64(len(body)), shaOf(body)); err != nil {
				t.Fatal(err)
			}
			got, _ := os.ReadFile(dst)
			if string(got) != string(body) {
				t.Fatal("content differs")
			}
			if _, err := os.Stat(dst + ".tmp"); !errors.Is(err, os.ErrNotExist) {
				t.Fatal("temp file left behind")
			}
			// One byte over the limit is refused, and nothing is left on disk.
			dst2 := filepath.Join(t.TempDir(), "carlos")
			if err := FetchToFile(ctx, s, "bootstrap/router/v1/carlos-linux-arm64", dst2, int64(len(body))-1, shaOf(body)); !errors.Is(err, ErrTooLarge) {
				t.Fatalf("over-limit err = %v", err)
			}
			if _, err := os.Stat(dst2); !errors.Is(err, os.ErrNotExist) {
				t.Fatal("over-limit fetch left a file")
			}
			// A sha mismatch is refused and leaves nothing.
			dst3 := filepath.Join(t.TempDir(), "carlos")
			err := FetchToFile(ctx, s, "bootstrap/router/v1/carlos-linux-arm64", dst3, int64(len(body)), strings.Repeat("0", 64))
			if err == nil || !strings.Contains(err.Error(), "sha256") {
				t.Fatalf("mismatch err = %v", err)
			}
			if _, err := os.Stat(dst3); !errors.Is(err, os.ErrNotExist) {
				t.Fatal("mismatch fetch left a file")
			}
			// Missing key is ErrNotExist.
			if err := FetchToFile(ctx, s, "bootstrap/router/v9/carlos-linux-arm64", dst3, 10, shaOf(nil)); !errors.Is(err, os.ErrNotExist) {
				t.Fatalf("missing err = %v", err)
			}
		})
	}
}

func TestPrefixStoreOpenRebasesTheKey(t *testing.T) {
	// prefixStore embeds the Store INTERFACE, so a promoted Open would forward
	// the raw key and silently escape the prefix. It must be written out.
	ctx := context.Background()
	inner := NewDirStore(t.TempDir())
	if _, err := inner.Put(ctx, "fleets/pi/x", []byte("in"), ""); err != nil {
		t.Fatal(err)
	}
	if _, err := inner.Put(ctx, "x", []byte("OUT"), ""); err != nil {
		t.Fatal(err)
	}
	rc, _, err := OpenObject(ctx, NewPrefixStore(inner, "fleets/pi/"), "x")
	if err != nil {
		t.Fatal(err)
	}
	defer rc.Close()
	b := make([]byte, 8)
	n, _ := rc.Read(b)
	if string(b[:n]) != "in" {
		t.Fatalf("read %q through the prefix, want \"in\"", b[:n])
	}
}

func TestOpenObjectFallsBackToGet(t *testing.T) {
	// A Store that is not an Opener still works: OpenObject buffers via Get.
	s := getOnly{NewDirStore(t.TempDir())}
	if _, err := s.Put(context.Background(), "k", []byte("v"), ""); err != nil {
		t.Fatal(err)
	}
	rc, _, err := OpenObject(context.Background(), s, "k")
	if err != nil {
		t.Fatal(err)
	}
	b := make([]byte, 4)
	n, _ := rc.Read(b)
	if string(b[:n]) != "v" {
		t.Fatalf("got %q", b[:n])
	}
}

type getOnly struct{ *DirStore }

func (getOnly) Open() {} // different signature: getOnly is NOT an Opener