package controllers

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"

	"server/models"
	"server/pkg/identity"

	"github.com/beego/beego/v2/client/orm"
	beego "github.com/beego/beego/v2/server/web"
)

// PlatformAiController 平台�?AI 管理（platform「AI管理」页�?
// 服务商配置存 yz_platform_ai_provider；OCR 配置暂存 yz_platform_site_setting 标签�?
type PlatformAiController struct {
	beego.Controller
}

func (c *PlatformAiController) jsonErr(httpStatus, bizCode int, msg string) {
	c.Ctx.Output.SetStatus(httpStatus)
	c.Data["json"] = map[string]any{"code": bizCode, "msg": msg}
	_ = c.ServeJSON()
}

func maskKey(key string) string {
	key = strings.TrimSpace(key)
	if len(key) <= 8 {
		if key == "" {
			return ""
		}
		return "***"
	}
	return key[:4] + "***" + key[len(key)-4:]
}

func fillProvider(m *models.PlatformAiProvider) {
	if m.Models != "" {
		// 兼容两种存储格式：[{"id","name"}] 对象数组 �?["model-id"] 字符串数�?
		var raw []json.RawMessage
		if err := json.Unmarshal([]byte(m.Models), &raw); err == nil {
			for _, r := range raw {
				var item models.AiModelItem
				if err := json.Unmarshal(r, &item); err == nil && item.ID != "" {
					m.ModelsList = append(m.ModelsList, item)
					continue
				}
				var s string
				if err := json.Unmarshal(r, &s); err == nil && s != "" {
					m.ModelsList = append(m.ModelsList, models.AiModelItem{ID: s, Name: s})
				}
			}
		}
	}
	m.ApiKeyMasked = maskKey(m.ApiKey)
	m.ApiKey = ""
}

// List GET /platform/ai/provider/list?provider_type=
func (c *PlatformAiController) List() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	ptype := strings.TrimSpace(c.GetString("provider_type"))
	qs := models.Orm.QueryTable(new(models.PlatformAiProvider)).
		Filter("delete_time__isnull", true)
	if ptype != "" {
		qs = qs.Filter("provider_type", ptype)
	}
	var rows []models.PlatformAiProvider
	_, _ = qs.OrderBy("-is_default", "-id").All(&rows)
	for i := range rows {
		fillProvider(&rows[i])
	}
	c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": rows}
	_ = c.ServeJSON()
}

type platformAiProviderPayload struct {
	ID           uint64   `json:"id"`
	ProviderType string   `json:"provider_type"`
	ApiType      string   `json:"api_type"`
	Name         string   `json:"name"`
	ApiBase      string   `json:"api_base"`
	ApiKey       string   `json:"api_key"`
	Models       []models.AiModelItem `json:"models"`
	DefaultModel string   `json:"default_model"`
	IsDefault    int8     `json:"is_default"`
	Status       int8     `json:"status"`
	Remark       string   `json:"remark"`
}

func readProviderPayload(c *PlatformAiController) (*platformAiProviderPayload, bool) {
	raw, err := io.ReadAll(c.Ctx.Request.Body)
	if err != nil {
		c.jsonErr(400, 400, "参数错误")
		return nil, false
	}
	var p platformAiProviderPayload
	if err := json.Unmarshal(raw, &p); err != nil {
		c.jsonErr(400, 400, "参数错误")
		return nil, false
	}
	p.ProviderType = strings.TrimSpace(p.ProviderType)
	p.ApiType = strings.TrimSpace(p.ApiType)
	if p.ApiType == "" {
		p.ApiType = "chat_completions"
	}
	switch p.ApiType {
	case "chat_completions", "responses", "anthropic":
	default:
		c.jsonErr(400, 400, "不支持的协议类型")
		return nil, false
	}
	p.Name = strings.TrimSpace(p.Name)
	p.ApiBase = strings.TrimRight(strings.TrimSpace(p.ApiBase), "/")
	if p.ProviderType == "" || p.Name == "" || p.ApiBase == "" {
		c.jsonErr(400, 400, "服务商类型、名称、API基址不能为空")
		return nil, false
	}
	return &p, true
}

func (p *platformAiProviderPayload) toModel() *models.PlatformAiProvider {
	modelsJSON, _ := json.Marshal(p.Models)
	return &models.PlatformAiProvider{
		ID: p.ID, ProviderType: p.ProviderType, ApiType: p.ApiType, Name: p.Name, ApiBase: p.ApiBase,
		ApiKey: p.ApiKey, Models: string(modelsJSON), DefaultModel: strings.TrimSpace(p.DefaultModel),
		IsDefault: p.IsDefault, Status: p.Status, Remark: strings.TrimSpace(p.Remark),
	}
}

// Create POST /platform/ai/provider
func (c *PlatformAiController) Create() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	p, ok := readProviderPayload(c)
	if !ok {
		return
	}
	m := p.toModel()
	if m.Status != 0 {
		m.Status = 1
	}
	if p.IsDefault == 1 {
		_, _ = models.Orm.QueryTable(new(models.PlatformAiProvider)).
			Filter("delete_time__isnull", true).Update(map[string]any{"is_default": 0})
	}
	id, err := models.Orm.Insert(m)
	if err != nil {
		c.jsonErr(500, 500, "保存失败: "+err.Error())
		return
	}
	c.Data["json"] = map[string]any{"code": 200, "msg": "保存成功", "data": map[string]any{"id": id}}
	_ = c.ServeJSON()
}

// Update PUT /platform/ai/provider/:id
func (c *PlatformAiController) Update() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	id, _ := c.GetInt64(":id", 0)
	if id <= 0 {
		c.jsonErr(400, 400, "无效ID")
		return
	}
	p, ok := readProviderPayload(c)
	if !ok {
		return
	}
	m := p.toModel()
	// api_key 传空表示不修�?
	update := map[string]any{
		"provider_type": m.ProviderType, "api_type": m.ApiType, "name": m.Name, "api_base": m.ApiBase,
		"models": m.Models, "default_model": m.DefaultModel,
		"is_default": m.IsDefault, "status": m.Status, "remark": m.Remark,
	}
	if strings.TrimSpace(p.ApiKey) != "" {
		update["api_key"] = p.ApiKey
	}
	if p.IsDefault == 1 {
		_, _ = models.Orm.QueryTable(new(models.PlatformAiProvider)).
			Filter("delete_time__isnull", true).Filter("id__ne", id).
			Update(map[string]any{"is_default": 0})
	}
	n, err := models.Orm.QueryTable(new(models.PlatformAiProvider)).
		Filter("id", id).Filter("delete_time__isnull", true).Update(update)
	if err != nil {
		c.jsonErr(500, 500, "保存失败: "+err.Error())
		return
	}
	if n == 0 {
		c.jsonErr(404, 404, "配置不存在")
		return
	}
	c.Data["json"] = map[string]any{"code": 200, "msg": "保存成功"}
	_ = c.ServeJSON()
}

// Delete DELETE /platform/ai/provider/:id
func (c *PlatformAiController) Delete() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	id, _ := c.GetInt64(":id", 0)
	n, err := models.Orm.QueryTable(new(models.PlatformAiProvider)).
		Filter("id", id).Filter("delete_time__isnull", true).
		Update(map[string]any{"delete_time": time.Now()})
	if err != nil {
		c.jsonErr(500, 500, "删除失败: "+err.Error())
		return
	}
	if n == 0 {
		c.jsonErr(404, 404, "配置不存在")
		return
	}
	c.Data["json"] = map[string]any{"code": 200, "msg": "删除成功"}
	_ = c.ServeJSON()
}

// loadProvider 取一条启用中的服务商配置（优先指�?id，否则平台默认）
func loadPlatformProvider(id uint64) (*models.PlatformAiProvider, error) {
	var m models.PlatformAiProvider
	qs := models.Orm.QueryTable(new(models.PlatformAiProvider)).
		Filter("delete_time__isnull", true).Filter("status", 1)
	if id > 0 {
		err := qs.Filter("id", id).One(&m)
		return &m, err
	}
	err := qs.Filter("is_default", 1).One(&m)
	if err != nil {
		err = models.Orm.QueryTable(new(models.PlatformAiProvider)).
			Filter("delete_time__isnull", true).Filter("status", 1).
			OrderBy("-id").One(&m)
	}
	return &m, err
}

// chatCompletion 按服务商协议类型分发调用，返回助手回复文�?
func chatCompletion(provider *models.PlatformAiProvider, model string, messages []map[string]string) (string, error) {
	switch provider.ApiType {
	case "responses":
		return chatResponses(provider, model, messages)
	case "anthropic":
		return chatAnthropic(provider, model, messages)
	default:
		return chatCompletions(provider, model, messages)
	}
}

func doAIRequest(req *http.Request, apiKey string) ([]byte, int, error) {
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)
	client := &http.Client{Timeout: 90 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return nil, 0, err
	}
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	return body, resp.StatusCode, nil
}

// chatCompletions OpenAI Chat Completions：POST {api_base}/chat/completions
func chatCompletions(provider *models.PlatformAiProvider, model string, messages []map[string]string) (string, error) {
	payload := map[string]any{"model": model, "messages": messages, "stream": false}
	body, _ := json.Marshal(payload)
	req, err := http.NewRequest("POST", provider.ApiBase+"/chat/completions", bytes.NewReader(body))
	if err != nil {
		return "", err
	}
	respBody, status, err := doAIRequest(req, provider.ApiKey)
	if err != nil {
		return "", err
	}
	if status != 200 {
		return "", errUpstream(string(respBody))
	}
	var out struct {
		Choices []struct {
			Message struct {
				Content string `json:"content"`
			} `json:"message"`
		} `json:"choices"`
		Error *struct {
			Message string `json:"message"`
		} `json:"error"`
	}
	if err := json.Unmarshal(respBody, &out); err != nil {
		return "", err
	}
	if out.Error != nil && out.Error.Message != "" {
		return "", errUpstream(out.Error.Message)
	}
	if len(out.Choices) == 0 {
		return "", errUpstream("上游返回为空")
	}
	return out.Choices[0].Message.Content, nil
}

// chatResponses OpenAI Responses：POST {api_base}/responses
// input 直接复用 messages 数组（role/content 结构兼容�?
func chatResponses(provider *models.PlatformAiProvider, model string, messages []map[string]string) (string, error) {
	payload := map[string]any{"model": model, "input": messages}
	body, _ := json.Marshal(payload)
	req, err := http.NewRequest("POST", provider.ApiBase+"/responses", bytes.NewReader(body))
	if err != nil {
		return "", err
	}
	respBody, status, err := doAIRequest(req, provider.ApiKey)
	if err != nil {
		return "", err
	}
	if status != 200 {
		return "", errUpstream(string(respBody))
	}
	var out struct {
		OutputText string `json:"output_text"`
		Output     []struct {
			Type    string `json:"type"`
			Content []struct {
				Type string `json:"type"`
				Text string `json:"text"`
			} `json:"content"`
		} `json:"output"`
		Error *struct {
			Message string `json:"message"`
		} `json:"error"`
	}
	if err := json.Unmarshal(respBody, &out); err != nil {
		return "", err
	}
	if out.Error != nil && out.Error.Message != "" {
		return "", errUpstream(out.Error.Message)
	}
	if out.OutputText != "" {
		return out.OutputText, nil
	}
	for _, item := range out.Output {
		for _, c := range item.Content {
			if c.Text != "" {
				return c.Text, nil
			}
		}
	}
	return "", errUpstream("上游返回为空")
}

// chatAnthropic Anthropic Messages：POST {api_base}/v1/messages
// system 消息提取到顶�?system 字段；x-api-key + anthropic-version 鉴权
func chatAnthropic(provider *models.PlatformAiProvider, model string, messages []map[string]string) (string, error) {
	var systemParts []string
	var msgs []map[string]string
	for _, m := range messages {
		role := m["role"]
		if role == "system" {
			systemParts = append(systemParts, m["content"])
			continue
		}
		if role == "assistant" {
			role = "assistant"
		} else {
			role = "user"
		}
		msgs = append(msgs, map[string]string{"role": role, "content": m["content"]})
	}
	payload := map[string]any{
		"model":      model,
		"max_tokens": 4096,
		"messages":   msgs,
	}
	if len(systemParts) > 0 {
		payload["system"] = strings.Join(systemParts, "\n")
	}
	body, _ := json.Marshal(payload)

	base := strings.TrimRight(provider.ApiBase, "/")
	if !strings.HasSuffix(base, "/v1") {
		base += "/v1"
	}
	req, err := http.NewRequest("POST", base+"/messages", bytes.NewReader(body))
	if err != nil {
		return "", err
	}
	req.Header.Set("x-api-key", provider.ApiKey)
	req.Header.Set("anthropic-version", "2023-06-01")
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{Timeout: 90 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	respBody, _ := io.ReadAll(resp.Body)
	if resp.StatusCode != 200 {
		return "", errUpstream(string(respBody))
	}
	var out struct {
		Content []struct {
			Type string `json:"type"`
			Text string `json:"text"`
		} `json:"content"`
		Error *struct {
			Message string `json:"message"`
		} `json:"error"`
	}
	if err := json.Unmarshal(respBody, &out); err != nil {
		return "", err
	}
	if out.Error != nil && out.Error.Message != "" {
		return "", errUpstream(out.Error.Message)
	}
	for _, c := range out.Content {
		if c.Text != "" {
			return c.Text, nil
		}
	}
	return "", errUpstream("上游返回为空")
}

type upstreamError string

func (e upstreamError) Error() string { return "AI服务调用失败: " + string(e) }
func errUpstream(msg string) error    { return upstreamError(msg) }

// Test POST /platform/ai/provider/test { id } �?{ provider_id, model }
// 用一�?ping 验证连通�?
func (c *PlatformAiController) Test() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	var req struct {
		ID    uint64 `json:"id"`
		Model string `json:"model"`
	}
	raw, _ := io.ReadAll(c.Ctx.Request.Body)
	_ = json.Unmarshal(raw, &req)

	provider, err := loadPlatformProvider(req.ID)
	if err != nil {
		c.jsonErr(400, 400, "服务商配置不存在或未启用")
		return
	}
	model := strings.TrimSpace(req.Model)
	if model == "" {
		model = provider.DefaultModel
	}
	if model == "" {
		var list []models.AiModelItem
		_ = json.Unmarshal([]byte(provider.Models), &list)
		if len(list) > 0 {
			model = list[0].ID
		}
	}
	if model == "" {
		c.jsonErr(400, 400, "未配置可用模型")
		return
	}
	start := time.Now()
	content, err := chatCompletion(provider, model, []map[string]string{
		{"role": "user", "content": "请只回复两个字：正常"},
	})
	if err != nil {
		c.jsonErr(502, 502, err.Error())
		return
	}
	c.Data["json"] = map[string]any{
		"code": 200, "msg": "连接成功",
		"data": map[string]any{
			"latency_ms": int(time.Since(start).Milliseconds()),
			"reply":      content,
			"model":      model,
		},
	}
	_ = c.ServeJSON()
}

// Chat POST /platform/ai/chat { provider_id, model, messages:[{role,content}] }
// Playground 对话代理：平台管理员�?AI管理页测试各服务�?
func (c *PlatformAiController) Chat() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	var req struct {
		ProviderID uint64              `json:"provider_id"`
		Model      string              `json:"model"`
		Messages   []map[string]string `json:"messages"`
	}
	raw, _ := io.ReadAll(c.Ctx.Request.Body)
	if err := json.Unmarshal(raw, &req); err != nil || len(req.Messages) == 0 {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	provider, err := loadPlatformProvider(req.ProviderID)
	if err != nil {
		c.jsonErr(400, 400, "服务商配置不存在或未启用")
		return
	}
	model := strings.TrimSpace(req.Model)
	if model == "" {
		model = provider.DefaultModel
	}
	if model == "" {
		c.jsonErr(400, 400, "未选择模型")
		return
	}
	// 只保�?role/content，避免把多余字段透传给上�?
	clean := make([]map[string]string, 0, len(req.Messages))
	for _, m := range req.Messages {
		role := strings.TrimSpace(m["role"])
		if role != "user" && role != "assistant" && role != "system" {
			continue
		}
		clean = append(clean, map[string]string{"role": role, "content": m["content"]})
	}
	if len(clean) == 0 {
		c.jsonErr(400, 400, "消息为空")
		return
	}
	content, err := chatCompletion(provider, model, clean)
	if err != nil {
		c.jsonErr(502, 502, err.Error())
		return
	}
	c.Data["json"] = map[string]any{
		"code": 200, "msg": "success",
		"data": map[string]any{"content": content, "model": model},
	}
	_ = c.ServeJSON()
}

// OCR 配置标签（存 yz_platform_site_setting，OCR 识别实现后续接入�?
var ocrConfigTags = []string{"ocr_enabled", "ocr_provider_id", "ocr_model", "ocr_prompt"}

// OcrConfig GET /platform/ai/ocrConfig
func (c *PlatformAiController) OcrConfig() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	all := models.GetPlatformSiteTagMap()
	data := make(map[string]string, len(ocrConfigTags))
	for _, tag := range ocrConfigTags {
		data[tag] = all[tag]
	}
	c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": data}
	_ = c.ServeJSON()
}

// SaveOcrConfig POST /platform/ai/ocrConfig { ocr_enabled, ocr_provider_id, ocr_model, ocr_prompt }
func (c *PlatformAiController) SaveOcrConfig() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	raw, err := io.ReadAll(c.Ctx.Request.Body)
	if err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	var payload map[string]string
	if err := json.Unmarshal(raw, &payload); err != nil {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	values := make(map[string]string, len(ocrConfigTags))
	for _, tag := range ocrConfigTags {
		if v, ok := payload[tag]; ok {
			values[tag] = strings.TrimSpace(v)
		}
	}
	if len(values) == 0 {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	if err := models.SavePlatformSiteSettings(values); err != nil {
		c.jsonErr(500, 500, "保存失败: "+err.Error())
		return
	}
	c.Data["json"] = map[string]any{"code": 200, "msg": "保存成功"}
	_ = c.ServeJSON()
}

// RecognizeOcr POST /platform/ai/ocr/recognize —�?OCR 识别占位接口
// 具体实现（视觉模�?/ 专用 OCR 服务）后续接入；当前返回配置状态供前端联调�?
func (c *PlatformAiController) RecognizeOcr() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	all := models.GetPlatformSiteTagMap()
	enabled := strings.TrimSpace(all["ocr_enabled"]) == "1"
	c.Data["json"] = map[string]any{
		"code": 200,
		"msg":  "success",
		"data": map[string]any{
			"enabled":       enabled,
			"provider_id":   all["ocr_provider_id"],
			"model":         all["ocr_model"],
			"recognized":    false,
			"message":       "OCR 识别服务待接入，配置已保存",
			"placeholder":   true,
		},
	}
	_ = c.ServeJSON()
}

// ==================== 流式对话（Playground 打字机效果）====================

// 归一�?SSE 事件：{"t":"delta"|"think"|"done"|"error","c":"..."}
func writeStreamEvent(w http.ResponseWriter, flusher http.Flusher, ev map[string]any) {
	b, _ := json.Marshal(ev)
	fmt.Fprintf(w, "data: %s\n\n", b)
	if flusher != nil {
		flusher.Flush()
	}
}

// streamHTTPRequest 构造带 stream:true 的上游请求，返回 *http.Request 与鉴权头已设置的 client 请求
// messages 的 content 支持字符串或多模态内容块数组（附件直传大模型，不落库）
func buildStreamRequest(provider *models.PlatformAiProvider, model string, messages []map[string]any) (*http.Request, error) {
	var url string
	var payload map[string]any

	switch provider.ApiType {
	case "responses":
		url = provider.ApiBase + "/responses"
		payload = map[string]any{"model": model, "input": messages, "stream": true}
	case "anthropic":
		base := strings.TrimRight(provider.ApiBase, "/")
		if !strings.HasSuffix(base, "/v1") {
			base += "/v1"
		}
		url = base + "/messages"
		var systemParts []string
		var msgs []map[string]any
		for _, m := range messages {
			role, _ := m["role"].(string)
			if role == "system" {
				if s, ok := m["content"].(string); ok {
					systemParts = append(systemParts, s)
				}
				continue
			}
			if role != "assistant" {
				role = "user"
			}
			msgs = append(msgs, map[string]any{"role": role, "content": anthropicContent(m["content"])})
		}
		payload = map[string]any{"model": model, "max_tokens": 4096, "messages": msgs, "stream": true}
		if len(systemParts) > 0 {
			payload["system"] = strings.Join(systemParts, "\n")
		}
	default:
		url = provider.ApiBase + "/chat/completions"
		payload = map[string]any{"model": model, "messages": messages, "stream": true}
	}

	body, _ := json.Marshal(payload)
	req, err := http.NewRequest("POST", url, bytes.NewReader(body))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	if provider.ApiType == "anthropic" {
		req.Header.Set("x-api-key", provider.ApiKey)
		req.Header.Set("anthropic-version", "2023-06-01")
	} else {
		req.Header.Set("Authorization", "Bearer "+provider.ApiKey)
	}
	return req, nil
}

// normalizeStreamData 把上�?SSE data 负载转成归一化事件列�?
// 返回 (events, isDone, isError)
// anthropicContent 把 OpenAI 风格的 message content 转成 Anthropic content blocks
// 字符串 → [{type:text}]；数组 → text 块 + base64 图片块（data URL 拆分）
func anthropicContent(content any) []map[string]any {
	if s, ok := content.(string); ok {
		return []map[string]any{{"type": "text", "text": s}}
	}
	arr, ok := content.([]any)
	if !ok {
		return []map[string]any{{"type": "text", "text": ""}}
	}
	var blocks []map[string]any
	for _, item := range arr {
		m, ok := item.(map[string]any)
		if !ok {
			continue
		}
		switch m["type"] {
		case "text":
			if t, ok := m["text"].(string); ok {
				blocks = append(blocks, map[string]any{"type": "text", "text": t})
			}
		case "image_url":
			if iu, ok := m["image_url"].(map[string]any); ok {
				if u, ok := iu["url"].(string); ok {
					if media, data, ok := parseDataURL(u); ok {
						blocks = append(blocks, map[string]any{
							"type": "image",
							"source": map[string]any{
								"type":       "base64",
								"media_type": media,
								"data":       data,
							},
						})
					}
				}
			}
		}
	}
	if len(blocks) == 0 {
		blocks = append(blocks, map[string]any{"type": "text", "text": ""})
	}
	return blocks
}

// parseDataURL 解析 data:[mediatype];base64,xxxx
func parseDataURL(u string) (media, data string, ok bool) {
	if !strings.HasPrefix(u, "data:") {
		return "", "", false
	}
	rest := strings.TrimPrefix(u, "data:")
	idx := strings.Index(rest, ";base64,")
	if idx < 0 {
		return "", "", false
	}
	return rest[:idx], rest[idx+len(";base64,"):], true
}

func normalizeStreamData(apiType string, data string) ([]map[string]any, bool) {
	data = strings.TrimSpace(data)
	if data == "" || data == "[DONE]" {
		return nil, data == "[DONE]"
	}
	var raw map[string]any
	if err := json.Unmarshal([]byte(data), &raw); err != nil {
		return nil, false
	}

	switch apiType {
	case "responses":
		typ, _ := raw["type"].(string)
		switch typ {
		case "response.output_text.delta":
			if d, ok := raw["delta"].(string); ok && d != "" {
				return []map[string]any{{"t": "delta", "c": d}}, false
			}
		case "response.reasoning_summary_text.delta", "response.reasoning_text.delta":
			if d, ok := raw["delta"].(string); ok && d != "" {
				return []map[string]any{{"t": "think", "c": d}}, false
			}
		case "response.completed":
			return nil, true
		case "response.failed", "error":
			msg := "上游返回错误"
			if e, ok := raw["error"].(map[string]any); ok {
				if m, ok := e["message"].(string); ok {
					msg = m
				}
			}
			if r, ok := raw["response"].(map[string]any); ok {
				if e, ok := r["error"].(map[string]any); ok {
					if m, ok := e["message"].(string); ok {
						msg = m
					}
				}
			}
			return []map[string]any{{"t": "error", "c": msg}}, true
		}
	case "anthropic":
		typ, _ := raw["type"].(string)
		switch typ {
		case "content_block_delta":
			if d, ok := raw["delta"].(map[string]any); ok {
				dt, _ := d["type"].(string)
				if dt == "text_delta" {
					if t, ok := d["text"].(string); ok && t != "" {
						return []map[string]any{{"t": "delta", "c": t}}, false
					}
				}
				if dt == "thinking_delta" {
					if t, ok := d["thinking"].(string); ok && t != "" {
						return []map[string]any{{"t": "think", "c": t}}, false
					}
				}
			}
		case "message_stop":
			return nil, true
		case "error":
			msg := "上游返回错误"
			if e, ok := raw["error"].(map[string]any); ok {
				if m, ok := e["message"].(string); ok {
					msg = m
				}
			}
			return []map[string]any{{"t": "error", "c": msg}}, true
		}
	default: // chat_completions
		choices, _ := raw["choices"].([]any)
		if len(choices) > 0 {
			if ch, ok := choices[0].(map[string]any); ok {
				if delta, ok := ch["delta"].(map[string]any); ok {
					var evs []map[string]any
					if t, ok := delta["reasoning_content"].(string); ok && t != "" {
						evs = append(evs, map[string]any{"t": "think", "c": t})
					}
					if t, ok := delta["content"].(string); ok && t != "" {
						evs = append(evs, map[string]any{"t": "delta", "c": t})
					}
					return evs, false
				}
			}
		}
		if e, ok := raw["error"].(map[string]any); ok {
			if m, ok := e["message"].(string); ok {
				return []map[string]any{{"t": "error", "c": m}}, true
			}
		}
	}
	return nil, false
}

// ChatStream POST /platform/ai/chat/stream
// SSE 代理：把三种上游协议的流式响应归一化为 {"t":"delta|think|done|error","c":"..."} 转发给前�?
func (c *PlatformAiController) ChatStream() {
	defer c.StopRun() // 阻止 Beego 在 handler 返回后继续模板渲染
	if _, err := requirePlatform(&c.Controller); err != nil {
		code := identity.Status(err)
		c.jsonErr(code, code, err.Error())
		return
	}
	var req struct {
		ProviderID uint64              `json:"provider_id"`
		Model      string              `json:"model"`
		Messages   []map[string]any    `json:"messages"`
		SessionID  uint64              `json:"session_id"`
	}
	raw, _ := io.ReadAll(c.Ctx.Request.Body)
	if err := json.Unmarshal(raw, &req); err != nil || len(req.Messages) == 0 {
		c.jsonErr(400, 400, "参数错误")
		return
	}
	// 落库用户消息（最后一条）
	if req.SessionID > 0 {
		persistUserMessage(req.SessionID, req.Messages[len(req.Messages)-1]["content"])
	}
	provider, err := loadPlatformProvider(req.ProviderID)
	if err != nil {
		c.jsonErr(400, 400, "服务商配置不存在或未启用")
		return
	}
	model := strings.TrimSpace(req.Model)
	if model == "" {
		model = provider.DefaultModel
	}
	if model == "" {
		c.jsonErr(400, 400, "未选择模型")
		return
	}
	clean := make([]map[string]any, 0, len(req.Messages))
	for _, m := range req.Messages {
		role, _ := m["role"].(string)
		role = strings.TrimSpace(role)
		if role != "user" && role != "assistant" && role != "system" {
			continue
		}
		clean = append(clean, map[string]any{"role": role, "content": m["content"]})
	}
	if len(clean) == 0 {
		c.jsonErr(400, 400, "消息为空")
		return
	}

	upReq, err := buildStreamRequest(provider, model, clean)
	if err != nil {
		c.jsonErr(500, 500, "构建请求失败")
		return
	}
	client := &http.Client{Timeout: 300 * time.Second}
	resp, err := client.Do(upReq)
	if err != nil {
		c.jsonErr(502, 502, "AI服务调用失败: "+err.Error())
		return
	}
	defer resp.Body.Close()

	// 切换为 SSE 响应（Beego ResponseWriter 是包装类型，取底层 http.ResponseWriter）
	rw := c.Ctx.ResponseWriter.ResponseWriter
	rw.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
	rw.Header().Set("Cache-Control", "no-cache")
	rw.Header().Set("Connection", "keep-alive")
	rw.Header().Set("X-Accel-Buffering", "no")
	rw.WriteHeader(200)
	flusher, _ := rw.(http.Flusher)

	if resp.StatusCode != 200 {
		body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
		writeStreamEvent(rw, flusher, map[string]any{"t": "error", "c": "AI服务调用失败: " + string(body)})
		writeStreamEvent(rw, flusher, map[string]any{"t": "done"})
		return
	}

	scanner := bufio.NewScanner(resp.Body)
	scanner.Buffer(make([]byte, 64*1024), 1024*1024)
	var accContent, accThink strings.Builder
	for scanner.Scan() {
		line := scanner.Text()
		if !strings.HasPrefix(line, "data:") {
			continue
		}
		payload := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
		events, isDone := normalizeStreamData(provider.ApiType, payload)
		for _, ev := range events {
			writeStreamEvent(rw, flusher, ev)
			if ev["t"] == "delta" {
				if s, ok := ev["c"].(string); ok {
					accContent.WriteString(s)
				}
			} else if ev["t"] == "think" {
				if s, ok := ev["c"].(string); ok {
					accThink.WriteString(s)
				}
			}
		}
		if isDone {
			break
		}
	}
	writeStreamEvent(rw, flusher, map[string]any{"t": "done"})
	persistStreamResult(req.SessionID, accContent.String(), accThink.String())
}

// persistStreamResult 流式结束后落库：assistant 消息 + 会话更新时间/标题
func persistStreamResult(sessionID uint64, content, think string) {
	if sessionID == 0 {
		return
	}
	var last models.PlatformAiChatMessage
	_ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
		Filter("session_id", sessionID).OrderBy("-seq").Limit(1).One(&last, "seq")
	_, _ = models.Orm.Insert(&models.PlatformAiChatMessage{
		SessionID: sessionID,
		Role:      "assistant",
		Content:   content,
		Think:     think,
		Seq:       last.Seq + 1,
		CreateTime: time.Now(),
	})
	_, _ = models.Orm.QueryTable(new(models.PlatformAiChatSession)).
		Filter("id", sessionID).
		Update(orm.Params{"update_time": time.Now()})
}

// persistUserMessage 流式开始前落库 user 消息（content 存原始 JSON，含附件）
func persistUserMessage(sessionID uint64, content any) {
	if sessionID == 0 {
		return
	}
	b, _ := json.Marshal(content)
	var last models.PlatformAiChatMessage
	_ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
		Filter("session_id", sessionID).OrderBy("-seq").Limit(1).One(&last, "seq")
	_, _ = models.Orm.Insert(&models.PlatformAiChatMessage{
		SessionID:  sessionID,
		Role:       "user",
		Content:    string(b),
		Seq:        last.Seq + 1,
		CreateTime: time.Now(),
	})
	// 首条消息时回填会话标题
	var cnt int64
	_, _ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
		Filter("session_id", sessionID).Count()
	if cnt == 1 {
		if s := userContentText(content); s != "" {
			if r := []rune(s); len(r) > 30 {
				s = string(r[:30]) + "..."
			}
			_, _ = models.Orm.QueryTable(new(models.PlatformAiChatSession)).
				Filter("id", sessionID).Update(orm.Params{"title": s})
		}
	}
	_, _ = models.Orm.QueryTable(new(models.PlatformAiChatSession)).
		Filter("id", sessionID).
		Update(orm.Params{"update_time": time.Now()})
}

// userContentText 从 user content（字符串或多模态数组）提取纯文本用于标题
func userContentText(content any) string {
	switch v := content.(type) {
	case string:
		return v
	case []any:
		var sb strings.Builder
		for _, item := range v {
			if m, ok := item.(map[string]any); ok && m["type"] == "text" {
				if t, ok := m["text"].(string); ok {
					sb.WriteString(t)
				}
			}
		}
		return sb.String()
	}
	return ""
}

// ==================== 会话管理 ====================

// ListChatSessions GET /platform/ai/chat/sessions
func (c *PlatformAiController) ListChatSessions() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		c.jsonErr(403, 403, "无权限")
		return
	}
	var list []models.PlatformAiChatSession
	_, err := models.Orm.QueryTable(new(models.PlatformAiChatSession)).
		Filter("delete_time__isnull", true).
		OrderBy("-is_top", "-update_time").Limit(100).All(&list)
	if err != nil {
		c.jsonErr(500, 500, "查询失败")
		return
	}
	c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": list}
	_ = c.ServeJSON()
}

// CreateChatSession POST /platform/ai/chat/session {provider_id, model}
func (c *PlatformAiController) CreateChatSession() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		c.jsonErr(403, 403, "无权限")
		return
	}
	var req struct {
		ProviderID uint64 `json:"provider_id"`
		Model      string `json:"model"`
	}
	_ = json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	s := models.PlatformAiChatSession{
		ProviderID: req.ProviderID,
		Model:      req.Model,
		CreateTime: time.Now(),
		UpdateTime: time.Now(),
	}
	id, err := models.Orm.Insert(&s)
	if err != nil {
		c.jsonErr(500, 500, "创建失败")
		return
	}
	s.ID = uint64(id)
	c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": s}
	_ = c.ServeJSON()
}

// GetChatSessionMessages GET /platform/ai/chat/session/:id/messages
func (c *PlatformAiController) GetChatSessionMessages() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		c.jsonErr(403, 403, "无权限")
		return
	}
	id, _ := c.GetInt64(":id")
	var msgs []models.PlatformAiChatMessage
	_, _ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
		Filter("session_id", id).OrderBy("seq").All(&msgs)
	c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": msgs}
	_ = c.ServeJSON()
}

// UpdateChatSession PUT /platform/ai/chat/session/:id {title?, is_top?}
func (c *PlatformAiController) UpdateChatSession() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		c.jsonErr(403, 403, "无权限")
		return
	}
	id, _ := c.GetInt64(":id")
	var req struct {
		Title *string `json:"title"`
		IsTop *int8   `json:"is_top"`
	}
	_ = json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	params := orm.Params{}
	if req.Title != nil {
		t := strings.TrimSpace(*req.Title)
		if t == "" {
			t = "新对话"
		}
		if r := []rune(t); len(r) > 100 {
			t = string(r[:100])
		}
		params["title"] = t
	}
	if req.IsTop != nil {
		params["is_top"] = *req.IsTop
	}
	if len(params) == 0 {
		c.jsonErr(400, 400, "无更新内容")
		return
	}
	_, err := models.Orm.QueryTable(new(models.PlatformAiChatSession)).
		Filter("id", id).Update(params)
	if err != nil {
		c.jsonErr(500, 500, "更新失败")
		return
	}
	c.Data["json"] = map[string]any{"code": 200, "msg": "success"}
	_ = c.ServeJSON()
}

// DeleteChatSession DELETE /platform/ai/chat/session/:id
func (c *PlatformAiController) DeleteChatSession() {
	if _, err := requirePlatform(&c.Controller); err != nil {
		c.jsonErr(403, 403, "无权限")
		return
	}
	id, _ := c.GetInt64(":id")
	now := time.Now()
	_, _ = models.Orm.QueryTable(new(models.PlatformAiChatSession)).
		Filter("id", id).Update(orm.Params{"delete_time": now})
	_, _ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
		Filter("session_id", id).Delete()
	c.Data["json"] = map[string]any{"code": 200, "msg": "success"}
	_ = c.ServeJSON()
}