package commandkit

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"strings"
	"testing"
)

func TestHiddenSimpleDeferredMessagesDoNotAccumulate(t *testing.T) {
	for _, mode := range []reportingMode{modeOrdinary, modeQuiet} {
		t.Run(fmt.Sprint(mode), func(t *testing.T) {
			reporter := newReporter(Streams{})
			reporter.setVisibility(mode, false, false)
			for index := 0; index < 256; index++ {
				if err := reporter.AtEnd().Debug(fmt.Sprintf("hidden %d", index), nil); err != nil {
					t.Fatal(err)
				}
				if err := reporter.AtEnd().Warn("hidden warning"); err != nil {
					t.Fatal(err)
				}
			}
			// This assertion owns the storage optimization, not a public queue API.
			if len(reporter.state.deferred) != 0 {
				t.Fatalf("retained %d renderer-free hidden messages", len(reporter.state.deferred))
			}
			got := reporter.finalize(Success(), nil)
			if got.Status != 0 || got.Presentation.Diagnostics.State != DeliverySuppressed {
				t.Fatalf("outcome=%#v", got)
			}
			if err := reporter.AtEnd().Debug("late"); !errors.Is(err, ErrReporterClosed) {
				t.Fatalf("closed hidden submission=%v", err)
			}
		})
	}
	noContent := newReporter(Streams{})
	_ = noContent.AtEnd().Warn("", nil)
	if got := noContent.finalize(Success(), nil); got.Presentation.Diagnostics.State != DeliveryNone {
		t.Fatalf("empty deferred submission became content: %#v", got)
	}
}

func TestHiddenDeferredDetailsRemainDeferredAndCaptured(t *testing.T) {
	var diagnostics bytes.Buffer
	reporter := newReporter(Streams{Err: &diagnostics})
	reporter.setVisibility(modeQuiet, false, false)
	failure := errors.New("hidden rendering failed")
	var order []string
	details := []Detail{func(w io.Writer) error {
		order = append(order, "first")
		_, _ = io.WriteString(w, "hidden detail")
		return failure
	}}
	_ = reporter.AtEnd().Warn("hidden", details...)
	details[0] = func(io.Writer) error { t.Error("caller changed captured callback"); return nil }
	_ = reporter.AtEnd().Info("", func(io.Writer) error { order = append(order, "second"); return nil })
	if len(order) != 0 {
		t.Fatal("details ran at submission")
	}
	got := reporter.finalize(Success(), nil)
	if strings.Join(order, ",") != "first,second" || !errors.Is(got.Presentation.Diagnostics.RenderError, failure) || got.Status != 1 {
		t.Fatalf("order=%v outcome=%#v", order, got)
	}
	if strings.Contains(diagnostics.String(), "hidden") || len(reporter.state.deferred) != 0 {
		t.Fatalf("hidden content leaked or queue retained: %q", diagnostics.String())
	}
}