package main

import (
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"

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

// TestProbeLogHasTheSyntheticMix checks that the generated log has readable
// ASCII text with the mix of kinds and sizes of the synthetic log. When
// ONECHAT_PROBE_LOG names a file, the test also writes the log there, one
// message {kind, text} per line, for "onechat probe".
func TestProbeLogHasTheSyntheticMix(t *testing.T) {
	messages := probeLog(probeMessages)
	require.Len(t, messages, probeMessages)

	counts := make(map[string]int)
	long := 0
	for _, message := range messages {
		counts[message.Kind]++
		require.True(t, logKinds[message.Kind], message.Kind)
		require.NotEmpty(t, message.Text)

		for _, char := range message.Text {
			require.True(t, char == '\n' || (char >= ' ' && char <= '~'), "character %q", char)
		}

		if len(message.Text) >= 30000 {
			long++
		}

		if message.Kind == "work" {
			require.True(t, strings.HasPrefix(message.Text, "["), message.Text)
		}
	}

	require.Greater(t, counts["user"], 20)
	require.Greater(t, counts["tool"], 300)
	require.Greater(t, counts["echo"], 300)
	require.Greater(t, long, 2)
	require.Equal(t, messages, probeLog(probeMessages))

	path := os.Getenv("ONECHAT_PROBE_LOG")
	if path == "" {
		return
	}

	var data strings.Builder

	for _, message := range messages {
		line, err := json.Marshal(message)
		require.NoError(t, err)

		data.Write(line)
		data.WriteByte('\n')
	}

	require.NoError(t, os.WriteFile(path, []byte(data.String()), 0o600))
}

func TestProbeReadIgnoresSourceDates(t *testing.T) {
	path := filepath.Join(t.TempDir(), "probe.jsonl")
	require.NoError(t, os.WriteFile(path, []byte(`{"kind":"user","text":"A probe message","date":"2025-01-01T00:00:00Z"}`+"\n"), 0o600))

	entries, err := probeReadLog(path, 1)
	require.NoError(t, err)
	require.Len(t, entries, 1)
	require.Empty(t, entries[0].Date)
}

func TestSlotSummarizerLimitsTheBuildsAtOnce(t *testing.T) {
	inner := newFakeSummarizer()
	inner.gate = make(chan struct{})
	summarizer := ProbeSlotSummarizer{
		inner: inner,
		slots: make(chan struct{}, 2),
	}

	var group sync.WaitGroup

	for n := range 6 {
		group.Go(func() {
			_, err := summarizer.Summarize(t.Context(), Task{
				Level: 0,
				Index: n,
				Input: []string{"user: " + strings.Repeat("x", 600)},
			})
			require.NoError(t, err)
		})
	}

	require.Eventually(t, func() bool {
		return inner.Active() == 2
	}, 10*time.Second, time.Millisecond)

	close(inner.gate)
	group.Wait()
	require.Equal(t, 2, inner.peak)
}