package backend

import (
    "context"
    "fmt"
    "log"
)

// CreateRequest 创作请求（前端传入）
type CreateRequest struct {
    Topic      string `json:"topic"`
    PetType    string `json:"pet_type"`
    Style      string `json:"style"`
    Keywords   string `json:"keywords"`
    WordCount  int    `json:"word_count"`
    ImageCount int    `json:"image_count"`
}

// CreateResponse 创作响应
type CreateResponse struct {
    Title    string        `json:"title"`
    Content  string        `json:"content"`
    Photos   []PexelsPhoto `json:"photos"`
    WordPath string        `json:"word_path"`
    Error    string        `json:"error,omitempty"`
}

// CreatorService 创作编排服务（统一入口）
type CreatorService struct {
    agentService  *AgentService
    pexelsService *PexelsService
    wordService   *WordService
}

// NewCreatorService 创建编排服务
func NewCreatorService(as *AgentService, ps *PexelsService, ws *WordService) *CreatorService {
    return &CreatorService{
        agentService:  as,
        pexelsService: ps,
        wordService:   ws,
    }
}

// Create 一键创作（前端调用）
// 流程：AI 生成文章 → AI 提取关键词 → 搜索配图 → 下载图片 → 生成 Word
func (cs *CreatorService) Create(ctx context.Context, req CreateRequest) (*CreateResponse, error) {
    // ========== 步骤 1：AI 生成文章 ==========
    artReq := ArtRequest{
        Topic:      req.Topic,
        PetType:    req.PetType,
        Style:      req.Style,
        Keywords:   req.Keywords,
        WordCount:  req.WordCount,
        ImageCount: req.ImageCount,
    }

    article, err := cs.agentService.GenerateArticle(ctx, artReq)
    if err != nil {
        return nil, fmt.Errorf("AI 生成文章失败: %w", err)
    }

    // ========== 步骤 2：多关键词搜索配图 ==========
    imageCount := req.ImageCount
    if imageCount <= 0 {
        imageCount = 3
    }
    if imageCount > 10 {
        imageCount = 10
    }

    var allPhotos []PexelsPhoto
    for _, tag := range article.SearchTags {
        if len(allPhotos) >= imageCount {
            break  // 已收集足够图片
        }
        photos, err := cs.pexelsService.SearchImages(tag, imageCount)
        if err != nil {
            // 某个关键词搜图失败不影响整体流程
            log.Printf("搜索图片失败 (tag=%s): %v", tag, err)
            continue
        }
        for _, p := range photos {
            if len(allPhotos) >= imageCount {
                break
            }
            allPhotos = append(allPhotos, p)
        }
    }

    // ========== 步骤 3：下载图片 ==========
    var imageData [][]byte
    for _, photo := range allPhotos {
        data, err := cs.pexelsService.DownloadImage(photo.Src.Medium)
        if err != nil {
            log.Printf("下载图片失败 (%s): %v", photo.Src.Medium, err)
            continue
        }
        imageData = append(imageData, data)
    }

    // ========== 步骤 4：生成 Word 文档 ==========
    var imageURLs []string
    for _, p := range allPhotos {
        imageURLs = append(imageURLs, p.Src.Medium)
    }

    wordPath, err := cs.wordService.GenerateDocx(DocxData{
        Title:     article.Title,
        Content:   article.Content,
        ImageURLs: imageURLs,
    }, imageData)
    if err != nil {
        return nil, fmt.Errorf("生成 Word 文档失败: %w", err)
    }

    return &CreateResponse{
        Title:    article.Title,
        Content:  article.Content,
        Photos:   allPhotos,
        WordPath: wordPath,
    }, nil
}

imageCount := req.ImageCount
if imageCount <= 0 {
    imageCount = 3      // 默认 3 张
}
if imageCount > 10 {
    imageCount = 10     // 最多 10 张
}

func main() {
    // 创建配置服务（共享）
    configService := backend.NewConfigService()

    // 创建业务服务
    agentService := backend.NewAgentService(configService)
    pexelsService := backend.NewPexelsService(configService)
    wordService := backend.NewWordService()

    // 创建编排服务（统一入口）
    creatorService := backend.NewCreatorService(agentService, pexelsService, wordService)

    // 创建 Wails 应用
    app := application.New(application.Options{
        Name:        "pet-content-creator",
        Description: "AI驱动的今日头条宠物内容创作工具",
        Services: []application.Service{
            application.NewService(configService),
            application.NewService(creatorService),
            application.NewService(pexelsService),
        },
        Assets: application.AssetOptions{
            Handler: application.AssetFileServerFS(assets),
        },
        Mac: application.MacOptions{
            ApplicationShouldTerminateAfterLastWindowClosed: true,
        },
    })

    // 创建主窗口
    app.Window.NewWithOptions(application.WebviewWindowOptions{
        Title:  "今日头条宠物内容创作工具",
        Width:  1200,
        Height: 800,
        URL:    "/",
    })

    // 运行
    err := app.Run()
    if err != nil {
        log.Fatal(err)
    }
}

import { CreatorService } from "../bindings/pet-content-creator/backend";

const handleCreate = async () => {
    setAppState("creating");

    const result = await CreatorService.Create({
        topic: "如何训练狗狗上厕所",
        pet_type: "狗",
        style: "指南",
        keywords: "",
        word_count: 800,
        image_count: 3,
    });

    setResponse(result as unknown as CreateResponse);
    setAppState("done");
};