package imports

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"math/rand"
	"net/http"
	"strings"
	"time"
)

// 使用OpenAI兼容格式
type ChatCompletionRequest struct {
	Model           string        `json:"model"`
	Messages        []ChatMessage `json:"messages"`
	MaxTokens       int           `json:"max_tokens,omitempty"`
	Temperature     float64       `json:"temperature,omitempty"`
	TopP            float64       `json:"top_p,omitempty"`
	TopK            float64       `json:"top_k,omitempty"`
	PresencePenalty float64       `json:"presence_penalty,omitempty"`
	Seed            int           `json:"seed,omitempty"`
}

type ChatMessage struct {
	Role    string    `json:"role"`
	Content []Content `json:"content"`
}

type Content struct {
	Type     string `json:"type"`
	Text     string `json:"text,omitempty"`
	ImageURL struct {
		URL string `json:"url"`
	} `json:"image_url,omitempty"`
}

type ChatCompletionResponse struct {
	Choices []struct {
		Message struct {
			Content string `json:"content"`
		} `json:"message"`
	} `json:"choices"`
	Error struct {
		Message string `json:"message"`
	} `json:"error,omitempty"`
}

// 图生文：根据图片生成标题和内容
func (g *AiGenerator) GenerateTitleAndContentFromImage(imageURL, titleRequire, contentRequire string) (string, string, error) {
	// 构建提示词
	prompt := fmt.Sprintf(`请分析这张图片并生成内容：

图片分析要求：
1. 标题要求：%s
2. 内容要求：%s

请严格按照以下格式返回，不要有任何额外文字：
标题：{生成的标题}
内容：{生成的内容}`, titleRequire, contentRequire)

	// 发送聊天请求
	response, err := g.chatWithImage(imageURL, prompt)
	if err != nil {
		return "", "", err
	}

	// 解析响应
	title, content := parseTitleAndContent(response)
	return title, content, nil
}

func (g *AiGenerator) chatWithImage(imageURL, prompt string) (string, error) {
	reqBody := ChatCompletionRequest{
		Model: "qwen3-vl-plus",
		Messages: []ChatMessage{
			{
				Role: "user",
				Content: []Content{
					{
						Type: "image_url",
						ImageURL: struct {
							URL string `json:"url"`
						}{
							URL: imageURL,
						},
					},
					{
						Type: "text",
						Text: prompt,
					},
				},
			},
		},
		MaxTokens:       2000,
		Temperature:     1.5,
		TopP:            0.9,
		TopK:            99,
		PresencePenalty: 1.5,
		Seed:            generateSeed(),
	}

	// 使用兼容模式接口
	url := g.cfg.BaseURL + "/compatible-mode/v1/chat/completions"

	jsonData, err := json.Marshal(reqBody)
	if err != nil {
		return "", fmt.Errorf("JSON序列化失败: %v", err)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return "", fmt.Errorf("创建请求失败: %v", err)
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+g.cfg.APIKey)
	req.Header.Set("X-DashScope-Session-Id", fmt.Sprintf("session-%d", time.Now().UnixNano()))

	resp, err := g.client.Do(req)
	if err != nil {
		return "", fmt.Errorf("API请求失败: %v", err)
	}
	defer resp.Body.Close()

	// 读取响应体
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("读取响应失败: %v", err)
	}

	if resp.StatusCode != http.StatusOK {
		return "", fmt.Errorf("API错误: %d, 响应: %s", resp.StatusCode, string(body))
	}

	var result ChatCompletionResponse
	if err := json.Unmarshal(body, &result); err != nil {
		return "", fmt.Errorf("JSON解析失败: %v, 响应: %s", err, string(body))
	}

	// 检查API错误
	if result.Error.Message != "" {
		return "", fmt.Errorf("API返回错误: %s", result.Error.Message)
	}

	if len(result.Choices) == 0 {
		return "", errors.New("AI未生成有效响应")
	}

	response := strings.TrimSpace(result.Choices[0].Message.Content)
	return response, nil
}

func generateSeed() int {
	rand.Seed(time.Now().UnixNano()) // 使用当前时间戳作为种子
	return rand.Intn(2147483647)     // 生成一个在 [0, 231-1] 范围内的随机数
}

// 解析标题和内容
func parseTitleAndContent(response string) (string, string) {
	var title, content string

	lines := strings.Split(response, "\n")
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "标题：") {
			title = strings.TrimPrefix(line, "标题：")
		} else if strings.HasPrefix(line, "内容：") {
			content = strings.TrimPrefix(line, "内容：")
		}
	}

	return strings.TrimSpace(title), strings.TrimSpace(content)
}

// 文本生成文本（聊天模式）
func (g *AiGenerator) GenerateTitleAndContentFromText(titleRequire, contentRequire string) (string, string, error) {
	// 构建提示词
	prompt := fmt.Sprintf(`请根据以下要求生成内容：

生成要求：
1. 标题要求：%s
2. 内容要求：%s

请严格按照以下格式返回，不要有任何额外文字：
标题：{生成的标题}
内容：{生成的内容}`,
		titleRequire,
		contentRequire,
	)

	// 发送聊天请求
	response, err := g.chatWithText(prompt)
	if err != nil {
		return "", "", err
	}

	// 解析响应
	title, content := parseTitleAndContent(response)
	return title, content, nil
}

// 文本聊天（纯文本生成）
func (g *AiGenerator) chatWithText(prompt string) (string, error) {
	reqBody := ChatCompletionRequest{
		Model: "qwen-max", // 使用文本模型
		Messages: []ChatMessage{
			{
				Role: "user",
				Content: []Content{
					{
						Type: "text",
						Text: prompt,
					},
				},
			},
		},
		MaxTokens:       2000,
		Temperature:     1.9,
		TopP:            1.0,
		TopK:            99,
		PresencePenalty: 1.0,
		Seed:            generateSeed(),
	}

	url := g.cfg.BaseURL + "/compatible-mode/v1/chat/completions"
	jsonData, err := json.Marshal(reqBody)
	if err != nil {
		return "", fmt.Errorf("JSON序列化失败: %v", err)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return "", fmt.Errorf("创建请求失败: %v", err)
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+g.cfg.APIKey)
	req.Header.Set("X-DashScope-Session-Id", fmt.Sprintf("session-%d", time.Now().UnixNano()))

	resp, err := g.client.Do(req)
	if err != nil {
		return "", fmt.Errorf("API请求失败: %v", err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("读取响应失败: %v", err)
	}

	if resp.StatusCode != http.StatusOK {
		return "", fmt.Errorf("API错误: %d, 响应: %s", resp.StatusCode, string(body))
	}

	var result ChatCompletionResponse
	if err := json.Unmarshal(body, &result); err != nil {
		return "", fmt.Errorf("JSON解析失败: %v, 响应: %s", err, string(body))
	}

	if result.Error.Message != "" {
		return "", fmt.Errorf("API返回错误: %s", result.Error.Message)
	}

	if len(result.Choices) == 0 {
		return "", errors.New("AI未生成有效响应")
	}
	response := strings.TrimSpace(result.Choices[0].Message.Content)
	return response, nil
}

//func (g *AiGenerator) GenerateImageFromText(prompt, size string, n int) (string, error) {
//	// 构建图片生成提示词
//	imagePrompt := fmt.Sprintf(`请根据以下描述生成图片：
//
//图片描述：%s
//生成数量：%d张
//图片尺寸：%s
//
//请直接生成图片，不要返回任何文字描述。`,
//		prompt, n, size)
//
//	// 使用文生图API
//	result, err := g.TextToImage(imagePrompt, size, n)
//	if err != nil {
//		return "", err
//	}
//
//	return result.Output.TaskID, nil
//}

// 文本生成图像
//func (g *AiGenerator) TextToImage(prompt, size string, n int) (ImageGenerationResponse, error) {
//	// 构建图像生成请求
//	reqBody := map[string]interface{}{
//		"prompt":          prompt,
//		"n":               n,
//		"size":            size,
//		"response_format": "url", // 假设返回的格式为图像 URL，可以根据实际 API 调整
//	}
//
//	// 使用图像生成接口
//	url := g.cfg.BaseURL + "/v1/images/generations"
//	jsonData, err := json.Marshal(reqBody)
//	if err != nil {
//		return ImageGenerationResponse{}, fmt.Errorf("JSON序列化失败: %v", err)
//	}
//
//	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
//	if err != nil {
//		return ImageGenerationResponse{}, fmt.Errorf("创建请求失败: %v", err)
//	}
//
//	req.Header.Set("Content-Type", "application/json")
//	req.Header.Set("Authorization", "Bearer "+g.cfg.APIKey)
//
//	resp, err := g.client.Do(req)
//	if err != nil {
//		return ImageGenerationResponse{}, fmt.Errorf("API请求失败: %v", err)
//	}
//	defer resp.Body.Close()
//
//	// 读取响应体
//	body, err := io.ReadAll(resp.Body)
//	if err != nil {
//		return ImageGenerationResponse{}, fmt.Errorf("读取响应失败: %v", err)
//	}
//
//	if resp.StatusCode != http.StatusOK {
//		return ImageGenerationResponse{}, fmt.Errorf("API错误: %d, 响应: %s", resp.StatusCode, string(body))
//	}
//
//	// 解析图像生成响应
//	var result ImageGenerationResponse
//	if err := json.Unmarshal(body, &result); err != nil {
//		return ImageGenerationResponse{}, fmt.Errorf("JSON解析失败: %v, 响应: %s", err, string(body))
//	}
//
//	if len(result.Data) == 0 {
//		return ImageGenerationResponse{}, errors.New("未生成任何图像")
//	}
//
//	return result, nil
//}
