package logging_test

import (
	"encoding/json"
	"log/slog"
	"slices"
	"sync"
	"testing"
	"testing/slogtest"

	"go.sudomsg.com/kit/logging"
)

type logRecorder struct {
	mu      sync.Mutex
	encoder logging.Encoder
	records []string
}

var _ logging.Sink = &logRecorder{}

func (h *logRecorder) Append(r slog.Record) error {
	h.mu.Lock()
	defer h.mu.Unlock()

	it := logging.RecordAll(r, nil)

	entry, err := h.encoder(it)
	if err != nil {
		return err
	}

	h.records = append(h.records, entry)
	return nil
}

func (h *logRecorder) Enabled(level slog.Level) bool {
	return true // Capture all logs
}

func (h *logRecorder) Records() []string {
	h.mu.Lock()
	defer h.mu.Unlock()
	return slices.Clone(h.records)
}

func TestJSONEncoder(t *testing.T) {
	var lastMock *logRecorder

	slogtest.Run(t,
		func(t *testing.T) slog.Handler {
			lastMock = &logRecorder{
				encoder: logging.JSONEncoder,
			}
			return logging.NewSinkHandler(lastMock)
		},
		func(t *testing.T) map[string]any {
			t.Helper()

			recs := lastMock.Records()
			if len(recs) == 0 {
				t.Fatalf("no records captured")
			}

			rec := recs[len(recs)-1]

			m := make(map[string]any)
			if err := json.Unmarshal([]byte(rec), &m); err != nil {
				t.Fatalf("%v", err)
			}

			return m
		},
	)
}