package vision

import (
	"bytes"
	"context"
	"encoding/base64"
	"errors"
	"image"
	"image/color"
	"image/jpeg"
	"strings"
	"testing"
)

// jpegBytes 返回一张真实的 JPEG（1x1），与 mime_test.go 的 pngBytes 同用途：
// 让「内容嗅探」在测试里有真实依据，而不是手写常量。
func jpegBytes(t *testing.T) []byte {
	t.Helper()
	img := image.NewRGBA(image.Rect(0, 0, 2, 2))
	img.Set(0, 0, color.RGBA{R: 0xcc, G: 0x33, B: 0x33, A: 0xff})
	var buf bytes.Buffer
	if err := jpeg.Encode(&buf, img, nil); err != nil {
		t.Fatalf("encode jpeg: %v", err)
	}
	return buf.Bytes()
}

// htmlDataURI 构造「把网页当图片传」的入参：声明 text/html，载荷是一段 HTML。
func htmlDataURI() string {
	return "data:text/html;base64," + base64.StdEncoding.EncodeToString(htmlBytes())
}

// TestResolve_DataURIImagesDecode 钉住本缺陷的主用例：带完整 base64 载荷的
// data: URI（jpeg / png）必须照常解出字节与声明的 MIME —— 也就是 2026-10-07
// 那次失败里「本该成立的形状」。MIME 取前缀声明，字节逐字节不变。
func TestResolve_DataURIImagesDecode(t *testing.T) {
	t.Parallel()
	cases := []struct {
		name string
		mime string
		data []byte
	}{
		{name: "jpeg", mime: "image/jpeg", data: jpegBytes(t)},
		{name: "png", mime: "image/png", data: pngBytes(t)},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			src := DataURI(tc.mime, tc.data)
			ref, err := ParseImageRef(src)
			if err != nil {
				t.Fatalf("ParseImageRef: %v", err)
			}
			mime, data, err := Resolve(context.Background(), ref, nil)
			if err != nil {
				t.Fatalf("Resolve(%s): %v", tc.mime, err)
			}
			if mime != tc.mime {
				t.Errorf("mime = %q, want %q", mime, tc.mime)
			}
			if !bytes.Equal(data, tc.data) {
				t.Errorf("bytes = %d, want the %d decoded bytes", len(data), len(tc.data))
			}
		})
	}
}

// TestResolve_EmptyDataURIPayloadRejected 是本缺陷的回归用例（2026-10-07
// 18:32:51 实测）：模型传的是 `data:image/png;base64,` —— **只有前缀、没有载荷**。
// 旧代码解出零字节却照样报 image/png，空载荷被当成图片发给上游，换回一句
// 「You have uploaded an unsupported image」。现在必须在本地就明确否决，
// 并且说清病因（载荷为空）而不是甩一句 upstream 400。
func TestResolve_EmptyDataURIPayloadRejected(t *testing.T) {
	t.Parallel()
	ref, err := ParseImageRef("data:image/png;base64,")
	if err != nil {
		t.Fatalf("ParseImageRef: %v", err)
	}
	mime, data, err := Resolve(context.Background(), ref, nil)
	if err == nil {
		t.Fatalf("空载荷被接受（mime=%q, %d bytes），want 明确报错", mime, len(data))
	}
	if !errors.Is(err, ErrNotImage) {
		t.Fatalf("error = %v, want ErrNotImage", err)
	}
	if !strings.Contains(err.Error(), "empty") {
		t.Errorf("错误文案没点出「载荷为空」：%v", err)
	}
	if !strings.Contains(err.Error(), "http(s) URL") {
		t.Errorf("错误文案没给可行动提示：%v", err)
	}
}

// TestResolve_NonImageDataURIRejected 钉住「这不是图片」：声明 text/html 的
// data: URI 必须报明确错误，写清嗅探到的类型与支持的格式，且**不得回显正文**。
func TestResolve_NonImageDataURIRejected(t *testing.T) {
	t.Parallel()
	ref, err := ParseImageRef(htmlDataURI())
	if err != nil {
		t.Fatalf("ParseImageRef: %v", err)
	}
	if _, _, err := Resolve(context.Background(), ref, nil); err == nil {
		t.Fatal("text/html 载荷被接受，want ErrNotImage")
	} else {
		if !errors.Is(err, ErrNotImage) {
			t.Fatalf("error = %v, want ErrNotImage", err)
		}
		msg := err.Error()
		if strings.Contains(msg, "502 Bad Gateway") || strings.Contains(msg, "<!DOCTYPE") {
			t.Fatalf("错误文案回显了正文：%v", msg)
		}
		for _, want := range []string{"text/html", "png", "jpeg", "gif", "webp"} {
			if !strings.Contains(msg, want) {
				t.Errorf("错误文案缺少 %q：%v", want, msg)
			}
		}
	}
}

// TestResolve_MalformedDataURI 钉住畸形 data: URI 不 panic、报可行动错误：
// 缺逗号分隔符、缺 ;base64 段、非法 base64 三种都要落到明确的说法上。
func TestResolve_MalformedDataURI(t *testing.T) {
	t.Parallel()
	cases := []struct {
		name string
		src  string
	}{
		{name: "no comma", src: "data:image/jpeg;base64"},
		{name: "no base64 marker", src: "data:image/png,plaintext"},
		// 这一条专治「漏了 ;base64 段、但载荷恰好是合法 base64 字符表」：
		// 旧 splitDataURI 会把它当 base64 解出 3 个零字节，还挂着 image/png
		// 的假声明放行（百分号编码的 data: URI 从来不是本包的输入）。
		{name: "no base64 marker with base64-shaped payload", src: "data:image/png,AAAA"},
		{name: "illegal base64", src: "data:image/png;base64,!!!!"},
		{name: "empty after prefix", src: "data:image/jpeg;base64,"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			ref, err := ParseImageRef(tc.src)
			if err != nil {
				t.Fatalf("ParseImageRef: %v", err)
			}
			if _, _, err := Resolve(context.Background(), ref, nil); err == nil {
				t.Fatalf("%q 被接受，want 报错", tc.src)
			}
		})
	}
}

// TestResolve_BareBase64Unchanged 钉住「裸 base64 路径一个字不改」：它没有声明
// 可对照，包内契约定的是按 image/png 处理（见 Resolve 的文档）。合法的 png 与
// jpeg 裸载荷都必须照原样解出、MIME 仍是 image/png。
func TestResolve_BareBase64Unchanged(t *testing.T) {
	t.Parallel()
	for _, raw := range [][]byte{pngBytes(t), jpegBytes(t)} {
		src := base64.StdEncoding.EncodeToString(raw)
		ref, err := ParseImageRef(src)
		if err != nil {
			t.Fatalf("ParseImageRef: %v", err)
		}
		if ref.Source != SourceBase64 {
			t.Fatalf("Source = %q, want base64", ref.Source)
		}
		mime, data, err := Resolve(context.Background(), ref, nil)
		if err != nil {
			t.Fatalf("裸 base64 被拒：%v", err)
		}
		if mime != "image/png" {
			t.Errorf("mime = %q, want image/png（裸 base64 的既有契约）", mime)
		}
		if !bytes.Equal(data, raw) {
			t.Errorf("裸 base64 解码结果变了：%d bytes", len(data))
		}
	}
}

// TestVisionTool_DataURIReachesUpstreamIntact 是端到端的那一条（工具 → 适配器
// → 上游桩）：合法的 data:image/jpeg;base64,... 必须原样成为线上 image_url 里的
// 合法 image 块 —— 上游收到的就是一张真 JPEG，所以不会再有 400。
func TestVisionTool_DataURIReachesUpstreamIntact(t *testing.T) {
	t.Parallel()
	jpg := jpegBytes(t)
	src := DataURI("image/jpeg", jpg)
	upSrv, rec := newImageURLRecorderServer(t)
	tool := NewVisionTool("vision", newAdapter(upSrv.URL))

	res, err := tool.Execute(context.Background(), map[string]any{"image": src, "prompt": "what is this"})
	if err != nil {
		t.Fatalf("Execute: %v", err)
	}
	if m, _ := res.(map[string]any); m["description"] == nil {
		t.Fatalf("tool result = %#v, want a description", res)
	}
	calls, urls := rec.seen()
	if calls != 1 || len(urls) != 1 {
		t.Fatalf("upstream calls = %d urls = %d, want exactly one image block", calls, len(urls))
	}
	if urls[0] != src {
		t.Fatalf("upstream image_url = %.40q..., want the input data URI byte for byte", urls[0])
	}
	payload := urls[0][strings.IndexByte(urls[0], ',')+1:]
	raw, err := base64.StdEncoding.DecodeString(payload)
	if err != nil {
		t.Fatalf("上游收到的载荷不是合法 base64：%v", err)
	}
	if _, err := jpeg.Decode(bytes.NewReader(raw)); err != nil {
		t.Fatalf("上游收到的载荷解不出 JPEG（就是那句 unsupported image 的成因）：%v", err)
	}
}

// TestVisionTool_EmptyPayloadNeverReachesUpstream 钉住失败发生在**本地**：
// 空载荷的 data: URI 必须在调用上游之前就被拒（旧行为是照发空图，换回 400）。
func TestVisionTool_EmptyPayloadNeverReachesUpstream(t *testing.T) {
	t.Parallel()
	upSrv, rec := newImageURLRecorderServer(t)
	tool := NewVisionTool("vision", newAdapter(upSrv.URL))

	_, err := tool.Execute(context.Background(), map[string]any{"image": "data:image/png;base64,"})
	if err == nil {
		t.Fatal("空载荷被接受，want 报错")
	}
	if !errors.Is(err, ErrNotImage) {
		t.Fatalf("error = %v, want ErrNotImage", err)
	}
	if calls, _ := rec.seen(); calls != 0 {
		t.Fatalf("上游被调用了 %d 次，want 0（缺陷正是「空图照发」）", calls)
	}
}

// TestResolve_ErrorMessageLeaksNoPayload 钉住错误文案的边界：给模型的提示只含
// 类型级信息与固定建议，不含 base64 载荷或图片正文（载荷可能很大也可能敏感）。
func TestResolve_ErrorMessageLeaksNoPayload(t *testing.T) {
	t.Parallel()
	payload := base64.StdEncoding.EncodeToString(htmlBytes())
	ref, err := ParseImageRef("data:image/png;base64," + payload)
	if err != nil {
		t.Fatalf("ParseImageRef: %v", err)
	}
	mime, data, err := Resolve(context.Background(), ref, nil)
	if err == nil {
		t.Fatalf("谎报 image/png 的 HTML 载荷被接受（mime=%q, %d bytes）", mime, len(data))
	}
	if strings.Contains(err.Error(), payload) {
		t.Fatalf("错误文案回显了 base64 载荷：%v", err)
	}
	if !strings.Contains(err.Error(), "text/html") {
		t.Errorf("错误文案没点出嗅探到的真实类型：%v", err)
	}
}