package blobgen

import (
	"bytes"
	"crypto/rand"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// testRecipient is a static age recipient for tests.
const testRecipient = "age1cplgrwj77ta54dnmydvvmzn64ltk83ankxl5sww04mrtmu62kv3s89gmvv"

// TestCompressStreamNoDoubleClose is a regression test for issue #28.
// It verifies that CompressStream does not panic or return an error due to
// double-closing the underlying blobgen.Writer. Before the fix in PR #33,
// the explicit Close() on the happy path combined with defer Close() would
// cause a double close.
func TestCompressStreamNoDoubleClose(t *testing.T) {
	input := []byte("regression test data for issue #28 double-close fix")
	var buf bytes.Buffer

	written, hash, err := CompressStream(&buf, bytes.NewReader(input), 3, []string{testRecipient})
	require.NoError(t, err, "CompressStream should not return an error")
	assert.True(t, written > 0, "expected bytes written > 0")
	assert.NotEmpty(t, hash, "expected non-empty hash")
	assert.True(t, buf.Len() > 0, "expected non-empty output")
}

// TestCompressStreamLargeInput exercises CompressStream with a larger payload
// to ensure no double-close issues surface under heavier I/O.
func TestCompressStreamLargeInput(t *testing.T) {
	data := make([]byte, 512*1024) // 512 KB
	_, err := rand.Read(data)
	require.NoError(t, err)

	var buf bytes.Buffer
	written, hash, err := CompressStream(&buf, bytes.NewReader(data), 3, []string{testRecipient})
	require.NoError(t, err)
	assert.True(t, written > 0)
	assert.NotEmpty(t, hash)
}

// TestCompressStreamEmptyInput verifies CompressStream handles empty input
// without double-close issues.
func TestCompressStreamEmptyInput(t *testing.T) {
	var buf bytes.Buffer
	_, hash, err := CompressStream(&buf, strings.NewReader(""), 3, []string{testRecipient})
	require.NoError(t, err)
	assert.NotEmpty(t, hash)
}

// TestCompressDataNoDoubleClose mirrors the stream test for CompressData,
// ensuring the explicit Close + error-path Close pattern is also safe.
func TestCompressDataNoDoubleClose(t *testing.T) {
	input := []byte("CompressData regression test for double-close")
	result, err := CompressData(input, 3, []string{testRecipient})
	require.NoError(t, err)
	assert.True(t, result.CompressedSize > 0)
	assert.True(t, result.UncompressedSize == int64(len(input)))
	assert.NotEmpty(t, result.SHA256)
}