package loop

import (
	"bytes"
	"context"
	"encoding/json"
	"strings"
	"sync"
	"testing"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/trace"
)

// 本文件钉住 M40 的工具侧写盘边界，分两层各钉一遍：
//
//   - **循环层**：真跑一次循环，按 writer 收到的**原始 SpanRecord**断言 —— tool
//     span 里根本没有 `result` 原文（曾经是原样落盘的工具结果全文，M38 排查出的
//     最严重一条），只有 result_summary（已脱敏、已截断，供回看面读）与
//     result_digest（字节/rune/sha256 前缀）；
//   - **写侧**：同一份记录的 stderr JSONL 字节里搜不到正文。
//
// 两层分开断言是刻意的：只测 JSONL 的话，写侧白名单会替循环层的漏做遮挡，把
// 「span 里曾经存着正文」这件事测不出来（反过来也一样）。
//
// 口径：工具结果正文留在会话库，span 只留摘要与指纹 —— 于是「成功还是失败、
// 输出多大、两次是不是同一份」仍可分辨，脱敏不该把 span 变得没用。

// captureWriter 收下每个 span 的**原始**记录（未经写侧投影），供测试按 span 层断言。
type captureWriter struct {
	mu   sync.Mutex
	recs []trace.SpanRecord
}

// WriteSpan 记录一份 span。
func (c *captureWriter) WriteSpan(rec trace.SpanRecord) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.recs = append(c.recs, rec)
	return nil
}

// snapshot 返回已收集记录的副本。
func (c *captureWriter) snapshot() []trace.SpanRecord {
	c.mu.Lock()
	defer c.mu.Unlock()
	out := make([]trace.SpanRecord, len(c.recs))
	copy(out, c.recs)
	return out
}

// teeWriter 把同一份 span 同时交给「原始记录捕获器」与 JSONL 记录器，使两层
// 断言落在同一次运行上。
type teeWriter []trace.Writer

// WriteSpan 依次写入每个出口，返回第一个错误。
func (t teeWriter) WriteSpan(rec trace.SpanRecord) error {
	var firstErr error
	for _, w := range t {
		if err := w.WriteSpan(rec); err != nil && firstErr == nil {
			firstErr = err
		}
	}
	return firstErr
}

// runToolTurnTraced 跑一个「一次工具调用 + 收尾」的回合，返回原始 span 记录与
// stderr JSONL 的原始字节。
func runToolTurnTraced(t *testing.T, toolResult any, toolErr error) ([]trace.SpanRecord, string) {
	t.Helper()
	call := `{"tool_calls":[{"name":"echo","args":{"q":"hi"}}]}`
	ad := &mockAdapter{chat: []mgResp{
		{resp: model.Response{Content: call}},
		{resp: model.Response{Content: "done"}},
	}}
	td := dispatcherWith(t, &mockTool{name: "echo", result: toolResult, err: toolErr})
	a := newTestAgent(t, ad, td)
	var buf bytes.Buffer
	capture := &captureWriter{}
	writer := teeWriter{capture, trace.NewJSONRecorder(&buf)}
	l := New(Options{Agent: a, Tracer: trace.New(writer), MaxRounds: 8})
	if _, err := l.Run(context.Background(), "sess", []model.Message{model.TextMessage(model.RoleUser, "go")}); err != nil {
		t.Fatalf("Run: %v", err)
	}
	return capture.snapshot(), buf.String()
}

// TestRun_ToolResultNeverEntersSpan 是循环层的泄漏钉：工具结果里有一段哨兵正文，
// span 的 props 与 stderr JSONL 里都搜不到它。
//
// 哨兵刻意放在**摘要窗口之外**：结果摘要（result_summary，回看面要读的那份）按
// 设计就是结果的有界前缀（80 rune），它是摘要、不是正文 —— 本测试钉的是「整段
// 结果不再落盘」，因此不能把断言的前提设成「连摘要都不许有」。
func TestRun_ToolResultNeverEntersSpan(t *testing.T) {
	t.Parallel()
	const sentinel = "SENTINEL-TOOL-BODY-3b7d-工具结果的后半段"
	result := strings.Repeat("拿到的报表行：", 40) + sentinel
	recs, raw := runToolTurnTraced(t, result, nil)

	span := toolSpanOf(t, recs)
	if _, ok := span.Props["result"]; ok {
		t.Fatalf("tool span 仍带着 result 原文：%+v", span.Props)
	}
	if _, ok := span.Props["text"]; ok {
		t.Fatalf("tool span 带着 text 原文：%+v", span.Props)
	}
	propsBlob := mustMarshal(t, span.Props)
	if strings.Contains(propsBlob, sentinel) {
		t.Fatalf("tool span 的 props 带着正文：%s", propsBlob)
	}
	digest, ok := span.Props["result_digest"].(trace.Digest)
	if !ok {
		t.Fatalf("tool span 没有 result_digest：%+v", span.Props)
	}
	if digest.Bytes != len(result) {
		t.Fatalf("result_digest.Bytes = %d, want %d（输出大小必须仍可读）", digest.Bytes, len(result))
	}
	summary, _ := span.Props["result_summary"].(string)
	if summary == "" {
		t.Fatalf("result_summary 缺席：回看面会失去结果摘要：%+v", span.Props)
	}
	if n := len([]rune(summary)); n > 81 {
		t.Fatalf("result_summary 长度 = %d rune，want 有界（摘要不是正文）", n)
	}

	// 写侧：同一份记录落盘后仍搜不到正文，也不含任何结果原文的长尾。
	if strings.Contains(raw, sentinel) {
		t.Fatalf("工具结果正文落进了 JSONL：%s", raw)
	}
	if strings.Contains(raw, strings.Repeat("拿到的报表行：", 16)) {
		t.Fatalf("JSONL 里出现了超出一份摘要的结果原文：%s", raw)
	}
	// 归属标识反而必须原文可读（主人 2026-10-26 裁定：session 是业务标识，不是
	// 正文；排障要把一条 stderr 日志对回某个会话）。它可读与正文不可见并不矛盾，
	// 这一条与上一条同时成立才是这一片的验收口径。
	if !strings.Contains(raw, `"session":"sess"`) {
		t.Fatalf("JSONL 里 session 不可读：%s", raw)
	}
}

// TestRun_ToolSpanStillTellsOKFromError 是「脱敏不能把 span 变得没用」的验收钉：
// 成功与失败在落盘上仍可分辨 —— 终态不同、失败的带已脱敏的 error、输出体积可读。
func TestRun_ToolSpanStillTellsOKFromError(t *testing.T) {
	t.Parallel()
	const secret = "abcdef1234567890"
	small := "ok"
	large := strings.Repeat("失", 500)

	okRecs, okRaw := runToolTurnTraced(t, small, nil)
	badRecs, badRaw := runToolTurnTraced(t, nil, &toolFailErr{msg: "boom: token=" + secret + " " + large})
	okSpan, badSpan := toolSpanOf(t, okRecs), toolSpanOf(t, badRecs)

	if okSpan.Status != trace.SpanStatusOK || badSpan.Status != trace.SpanStatusError {
		t.Fatalf("status = %q / %q，成功与失败必须仍可分辨", okSpan.Status, badSpan.Status)
	}
	okDigest, _ := okSpan.Props["result_digest"].(trace.Digest)
	if okDigest.Bytes != len(small) {
		t.Fatalf("成功调用的 result_digest.Bytes = %d, want %d", okDigest.Bytes, len(small))
	}
	// 失败侧写盘面：错误原因仍可读（"boom"），凭据已打码，长度有界。
	for _, surface := range []string{okRaw, badRaw} {
		if strings.Contains(surface, secret) {
			t.Fatalf("JSONL 带着凭据原文：%s", surface)
		}
	}
	if !strings.Contains(badRaw, "boom") {
		t.Fatalf("失败落盘里没有可诊断的原因：%s", badRaw)
	}
	if strings.Contains(badRaw, large) {
		t.Fatalf("失败落盘里带着整段错误文本：%s", badRaw)
	}
}

// toolFailErr 是一个只提供 Error() 的工具失败（模拟工具自己拼的错误文本）。
type toolFailErr struct{ msg string }

func (e *toolFailErr) Error() string { return e.msg }

// toolSpanOf 在记录里取那条工具 span。
func toolSpanOf(t *testing.T, recs []trace.SpanRecord) trace.SpanRecord {
	t.Helper()
	for _, rec := range recs {
		if rec.Name == "tool.echo" {
			return rec
		}
	}
	t.Fatalf("记录里没有 tool.echo span：%+v", recs)
	return trace.SpanRecord{}
}

// mustMarshal 把一段东西序列化成 JSON 文本，用于「搜不到正文」的断言。
func mustMarshal(t *testing.T, v any) string {
	t.Helper()
	b, err := json.Marshal(v)
	if err != nil {
		t.Fatalf("marshal: %v", err)
	}
	return string(b)
}