package openaichat

import (
	"encoding/base64"
	"encoding/json"
	"strings"
	"testing"
)

func TestEffectiveModelDropsSpark(t *testing.T) {
	if EffectiveModel("") != "gpt-5.3-chat" || EffectiveModel("generalv3.5") != "gpt-5.3-chat" {
		t.Fatal(EffectiveModel("generalv3.5"))
	}
	if EffectiveModel("gpt-5.4") != "gpt-5.4" {
		t.Fatal(EffectiveModel("gpt-5.4"))
	}
}

func TestEnvelopeUsesOpenAIModelNotSpark(t *testing.T) {
	c, err := New("app", "key", "secret", "spark-api.xf-yun.com", "generalv3.5")
	if err != nil {
		t.Fatal(err)
	}
	if c.Host != defaultHost {
		t.Fatalf("星火主机必须丢掉，得到 %s", c.Host)
	}
	if c.Model != defaultModel {
		t.Fatalf("星火 domain 不能当模型，得到 %s", c.Model)
	}
	raw, err := c.envelope([]Message{{Role: "user", Content: "1+1等于几"}})
	if err != nil {
		t.Fatal(err)
	}
	var outer struct {
		Header struct {
			AppID  string `json:"app_id"`
			Status int    `json:"status"`
		} `json:"header"`
		Payload struct {
			Input struct {
				Status int    `json:"status"`
				Text   string `json:"text"`
			} `json:"input"`
		} `json:"payload"`
	}
	if err := json.Unmarshal(raw, &outer); err != nil {
		t.Fatal(err)
	}
	if outer.Header.AppID != "app" || outer.Header.Status != 3 || outer.Payload.Input.Status != 3 {
		t.Fatalf("信封不对: %+v", outer.Header)
	}
	inner, err := base64.StdEncoding.DecodeString(outer.Payload.Input.Text)
	if err != nil {
		t.Fatal(err)
	}
	if strings.Contains(string(inner), "generalv3") || strings.Contains(string(inner), "spark") {
		t.Fatalf("内层还带着星火: %s", inner)
	}
	var chat struct {
		Model    string    `json:"model"`
		Stream   bool      `json:"stream"`
		Messages []Message `json:"messages"`
	}
	if err := json.Unmarshal(inner, &chat); err != nil {
		t.Fatal(err)
	}
	if chat.Model != "gpt-5.3-chat" || chat.Stream || chat.Messages[0].Content != "1+1等于几" {
		t.Fatalf("内层不对: %+v", chat)
	}
}

func TestParseChatCompletion(t *testing.T) {
	inner, _ := json.Marshal(map[string]any{
		"object": "chat.completion",
		"choices": []any{
			map[string]any{"message": map[string]any{"content": "1+1等于2。"}},
		},
	})
	outer, _ := json.Marshal(map[string]any{
		"header": map[string]any{"code": 0, "message": "success"},
		"payload": map[string]any{
			"output": map[string]any{"text": base64.StdEncoding.EncodeToString(inner)},
		},
	})
	got, err := parseOuter(outer)
	if err != nil || got != "1+1等于2。" {
		t.Fatalf("got %q err %v", got, err)
	}
}

func TestParseGatewayError(t *testing.T) {
	outer, _ := json.Marshal(map[string]any{
		"header": map[string]any{"code": 11200, "message": "授权错误"},
	})
	_, err := parseOuter(outer)
	if err == nil || !strings.Contains(err.Error(), "11200") {
		t.Fatalf("err=%v", err)
	}
}