package backend

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "time"
)

// PexelsPhoto Pexels 图片信息
type PexelsPhoto struct {
    ID              int    `json:"id"`
    Width           int    `json:"width"`
    Height          int    `json:"height"`
    URL             string `json:"url"`
    Photographer    string `json:"photographer"`
    PhotographerURL string `json:"photographer_url"`
    Src             struct {
        Original  string `json:"original"`
        Large     string `json:"large"`
        Medium    string `json:"medium"`
        Small     string `json:"small"`
        Portrait  string `json:"portrait"`
        Landscape string `json:"landscape"`
        Tiny      string `json:"tiny"`
    } `json:"src"`
    Alt string `json:"alt"`
}

// PexelsResponse Pexels API 响应
type PexelsResponse struct {
    TotalResults int           `json:"total_results"`
    Page         int           `json:"page"`
    PerPage      int           `json:"per_page"`
    Photos       []PexelsPhoto `json:"photos"`
    NextPage     string        `json:"next_page"`
}

// PexelsService Pexels 配图服务
type PexelsService struct {
    configService *ConfigService
    httpClient    *http.Client
}

// NewPexelsService 创建 Pexels 服务
func NewPexelsService(cs *ConfigService) *PexelsService {
    return &PexelsService{
        configService: cs,
        httpClient: &http.Client{
            Timeout: 30 * time.Second,
        },
    }
}

// SearchImages 搜索图片（前端调用）
// query: 搜索关键词
// perPage: 返回数量（最多 80）
func (ps *PexelsService) SearchImages(query string, perPage int) ([]PexelsPhoto, error) {
    cfg, err := ps.configService.Load()
    if err != nil {
        return nil, fmt.Errorf("加载配置失败: %w", err)
    }
    if cfg.PexelsAPIKey == "" {
        return nil, fmt.Errorf("请先配置 Pexels API Key")
    }

    if perPage <= 0 {
        perPage = 5
    }
    if perPage > 80 {
        perPage = 80
    }

    // 构建请求 URL
    apiURL := fmt.Sprintf("https://api.pexels.com/v1/search?query=%s&per_page=%d",
        url.QueryEscape(query), perPage)

    req, err := http.NewRequest("GET", apiURL, nil)
    if err != nil {
        return nil, fmt.Errorf("创建请求失败: %w", err)
    }
    req.Header.Set("Authorization", cfg.PexelsAPIKey)

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

    if resp.StatusCode != http.StatusOK {
        body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
        return nil, fmt.Errorf("Pexels API 返回错误 (状态码 %d): %s", 
            resp.StatusCode, string(body))
    }

    var result PexelsResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, fmt.Errorf("解析 Pexels 响应失败: %w", err)
    }

    return result.Photos, nil
}

// DownloadImage 下载图片（内部使用）
func (ps *PexelsService) DownloadImage(imageURL string) ([]byte, error) {
    resp, err := ps.httpClient.Get(imageURL)
    if err != nil {
        return nil, fmt.Errorf("下载图片失败: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("下载图片返回状态码 %d", resp.StatusCode)
    }

    // 限制最大 10MB，防止恶意或异常大文件
    data, err := io.ReadAll(io.LimitReader(resp.Body, 10*1024*1024))
    if err != nil {
        return nil, fmt.Errorf("读取图片数据失败: %w", err)
    }
    return data, nil
}

func main() {
    configService := backend.NewConfigService()
    agentService := backend.NewAgentService(configService)
    pexelsService := backend.NewPexelsService(configService)

    app := application.New(application.Options{
        Services: []application.Service{
            application.NewService(configService),
            application.NewService(agentService),
            application.NewService(pexelsService),
        },
        // ...
    })
}

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

// 搜索图片
const photos = await PexelsService.SearchImages("golden retriever puppy", 6);
photos.forEach(p => {
    console.log(p.src.medium, p.photographer);
});

// 搜索失败时不阻塞整体流程
photos, err := ps.SearchImages(tag, count)
if err != nil {
    log.Printf("搜索图片失败 (tag=%s): %v", tag, err)
    continue  // 尝试下一个关键词
}