package storage

import (
	"errors"
	"io"
	"testing"
)

func TestOpenAfterWrite(t *testing.T) {
	s := newTestStore(t)
	data := []byte("readable blob content")
	digest := writeTestBlob(t, s, data)

	rc, err := s.Open(digest)
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	defer func() { _ = rc.Close() }()

	got, err := io.ReadAll(rc)
	if err != nil {
		t.Fatalf("ReadAll: %v", err)
	}
	if string(got) != string(data) {
		t.Fatalf("Open content: got %q, want %q", got, data)
	}
}

func TestStatAfterWrite(t *testing.T) {
	s := newTestStore(t)
	data := []byte("stat this blob")
	digest := writeTestBlob(t, s, data)

	size, err := s.Stat(digest)
	if err != nil {
		t.Fatalf("Stat: %v", err)
	}
	if size != int64(len(data)) {
		t.Fatalf("Stat size: got %d, want %d", size, len(data))
	}
}

func TestExists(t *testing.T) {
	s := newTestStore(t)
	data := []byte("existence check")
	digest := writeTestBlob(t, s, data)

	if !s.Exists(digest) {
		t.Fatal("Exists returned false for written blob")
	}

	nonexistent := "sha256:0000000000000000000000000000000000000000000000000000000000000000"
	if s.Exists(nonexistent) {
		t.Fatal("Exists returned true for nonexistent blob")
	}
}

func TestDelete(t *testing.T) {
	s := newTestStore(t)
	data := []byte("delete me")
	digest := writeTestBlob(t, s, data)

	if err := s.Delete(digest); err != nil {
		t.Fatalf("Delete: %v", err)
	}

	if s.Exists(digest) {
		t.Fatal("Exists returned true after Delete")
	}

	_, err := s.Open(digest)
	if !errors.Is(err, ErrBlobNotFound) {
		t.Fatalf("Open after Delete: got %v, want ErrBlobNotFound", err)
	}
}

func TestOpenNotFound(t *testing.T) {
	s := newTestStore(t)

	digest := "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	_, err := s.Open(digest)
	if !errors.Is(err, ErrBlobNotFound) {
		t.Fatalf("Open nonexistent: got %v, want ErrBlobNotFound", err)
	}
}

func TestInvalidDigestFormat(t *testing.T) {
	s := newTestStore(t)
	bad := "not-a-digest"

	if _, err := s.Open(bad); !errors.Is(err, ErrInvalidDigest) {
		t.Fatalf("Open with bad digest: got %v, want ErrInvalidDigest", err)
	}

	if _, err := s.Stat(bad); !errors.Is(err, ErrInvalidDigest) {
		t.Fatalf("Stat with bad digest: got %v, want ErrInvalidDigest", err)
	}

	if err := s.Delete(bad); !errors.Is(err, ErrInvalidDigest) {
		t.Fatalf("Delete with bad digest: got %v, want ErrInvalidDigest", err)
	}

	// Exists should return false for an invalid digest, not panic.
	if s.Exists(bad) {
		t.Fatal("Exists returned true for invalid digest")
	}
}