# API 接口参考

所有接口统一规范：
- **Host**: `https://redfox.hk`
- **Method**: `POST`
- **Content-Type**: `application/json`
- **认证头**: `REDFOX-API-KEY` + `X-API-Key`（值均为 `$REDFOX_API_KEY`）
- **成功状态码**: `code: 2000`

---

## 1. 抖音（广域库）

**Path**: `/story/api/dy/data/searchWork`

**请求体**:
```json
{"keyword": "关键词", "pageNum": 1, "pageSize": 20}
```
- `keyword`: 搜索关键词（必填，匹配作品正文）
- `pageNum`: 页码，从1开始，默认1
- `pageSize`: 每页大小，默认10，最大50

**响应**: `data.list[]`，另有 `data.total`（总记录数）
| 字段 | 类型 | 说明 |
|------|------|------|
| videoId | String | 作品ID |
| content | String | 作品正文/描述 |
| videoType | String | 0=普通视频, 68=图集, 63=直播录屏等 |
| duration | Integer | 时长（毫秒） |
| publishTime | String | 发布时间 |
| coverUrl | String | 封面链接 |
| opusUrl | String | 作品链接 |
| imageUrlList | Array | 图片列表（图文作品） |
| tagList | Array | 话题列表 |
| likeCount | Integer | 点赞数 |
| commentCount | Integer | 评论数 |
| shareCount | Integer | 分享数 |
| collectCount | Integer | 收藏数 |
| authorUid | String | 作者ID |
| authorName | String | 作者昵称 |
| authorAvatarUrl | String | 作者头像 |
| authorShortId | String | 作者抖音short_id |
| authorUniqueId | String | 作者抖音unique_id |
| authorSecUid | String | 作者sec_uid |

**URL 构造**: `opusUrl` 即为完整链接

---

## 2. 小红书（优质库）

**Path**: `/story/api/xhsUser/searchArticle`

**请求体**:
```json
{"keyword": "关键词", "offset": 0, "sortType": "0"}
```
- `sortType`: `0`=默认, `2`=最新, `4`=最热
- `offset`: 从0开始，每页+20

**响应**: `data.list[]`
| 字段 | 类型 | 说明 |
|------|------|------|
| workId | String | 作品ID |
| workTitle | String | 标题 |
| workDesc | String | 内容 |
| coverUrl | String | 封面图 |
| workUrl | String | 作品链接 |
| workPublishTime | String | 发布时间 |
| accountNickname | String | 作者昵称 |
| accountUserid | String | 作者ID |
| workLikedCount | Integer | 点赞数 |
| workCommentsCount | Integer | 评论数 |
| workCollectedCount | Integer | 收藏数 |
| workSharedCount | Integer | 转发数 |
| workType | String | video/normal |

**URL 构造**: `workUrl` 即为完整链接

---

## 3. 公众号（广域库）

**Path**: `/story/api/gzh/data/searchArticle`

**请求体**:
```json
{"keyword": "关键词", "offset": 0, "sortType": "0"}
```
- `sortType`: `0`=默认, `2`=最新, `4`=最热
- `offset`: 从0开始，每页+20

**响应**: `data.list[]`
| 字段 | 类型 | 说明 |
|------|------|------|
| title | String | 标题 |
| summary | String | 摘要 |
| content | String | 正文HTML |
| workUrl | String | 文章链接 |
| coverUrl | String | 封面链接 |
| publishTime | String | 发布时间 |
| readCount | Integer | 阅读数 |
| likeCount | Integer | 点赞数 |
| watchCount | Integer | 在看数 |
| commentCount | Integer | 评论数 |
| collectCount | Integer | 收藏数 |
| shareCount | Integer | 分享数 |
| author | String | 账号昵称 |
| isOriginal | Integer | 1=原创 |
| orderNum | Integer | 0=头条 |
| originalAuthor | String | 原创作者 |
| authorAvatarUrl | String | 头像链接 |
| workUuid | String | 作品ID |

---

## 4. B站（优质库）

**Path**: `/story/api/bili/data/workSearch`

**请求体**:
```json
{"keyword": "关键词", "page": "1", "pageSize": 20, "order": "time"}
```
- `order`: `time`=最新, `play`=播放数, `like`=点赞, `comment`=评论, `favorite`=收藏

**响应**: `data.workList[]`
| 字段 | 类型 | 说明 |
|------|------|------|
| bvId | String | BV号 |
| title | String | 标题 |
| description | String | 描述 |
| duration | Integer | 时长（秒） |
| picUrl | String | 封面 |
| created | String | 发布时间 |
| author | String | 作者 |
| authorId | String | 作者ID |
| firstType | String | 一级分类 |
| secondType | String | 二级分类 |
| playCount | Integer | 播放数 |
| likeCount | Integer | 点赞数 |
| favoriteCount | Integer | 收藏数 |
| commentCount | Integer | 评论数 |
| shareCount | Integer | 分享数 |
| videoReview | Integer | 弹幕数 |
| coinCount | Integer | 投币数 |
| interactionQuantity | Integer | 互动数 |
| tagNames | Array | 标签 |

**URL 构造**: `https://www.bilibili.com/video/{bvId}`

---

## 5. 快手（广域库）

**Path**: `/story/api/ksAllData/searchWork`

**请求体**:
```json
{"keyword": "关键词", "page": 1, "size": 20, "sort": "综合"}
```
- `sort`: `综合`/`最新`/`最多点赞`/`最多收藏`
- `size`: 最大50

**响应**: `data.list[]`
| 字段 | 类型 | 说明 |
|------|------|------|
| photoId | String | 作品ID |
| caption | String | 标题 |
| nickname | String | 作者 |
| headUrl | String | 头像 |
| coverUrl | String | 封面 |
| videoUrl | String | 视频URL |
| publishTime | String | 发布时间 |
| duration | Integer | 时长（毫秒） |
| viewCount | Integer | 播放数 |
| likeCount | Integer | 点赞数 |
| commentCount | Integer | 评论数 |
| collectCount | Integer | 收藏数 |
| shareCount | Integer | 分享数 |
| forwardCount | Integer | 转发数 |
| authorFans | Integer | 粉丝数 |

**URL 构造**: `https://www.kuaishou.com/short-video/{photoId}`

---

## 6. 视频号（广域库）

**Path**: `/story/api/sphAllData/searchWork`

**请求体**:
```json
{"keyword": "关键词", "page": 1, "size": 20, "sort": "综合"}
```
- `sort`: `综合`/`最新`/`最多点赞`/`最多收藏`

**响应**: `data.list[]`
| 字段 | 类型 | 说明 |
|------|------|------|
| description | String | 作品描述 |
| nickname | String | 账号昵称 |
| headUrl | String | 头像 |
| coverUrl | String | 封面 |
| thumbUrl | String | 缩略图 |
| videoUrl | String | 视频URL |
| publishTime | String | 发布时间 |
| videoDuration | String | 时长（秒） |
| likeCount | Integer | 点赞数 |
| commentCount | Integer | 评论数 |
| forwardCount | Integer | 转发数 |
| favCount | Integer | 收藏数 |
| topic | String | 话题JSON数组 |
| width/height | Integer | 分辨率 |

---

## 7. 今日头条（实时）

**Path**: `/story/api/toutiao/searchWork`

**请求体**:
```json
{"keyword": "关键词", "offset": "0"}
```
- `offset`: 从"0"开始，每页+1

**响应**: `data[]`（注意：data 是数组，非对象）
| 字段 | 类型 | 说明 |
|------|------|------|
| opusId | String | 作品ID |
| opusUrl | String | 作品链接 |
| title | String | 标题 |
| nickname | String | 作者昵称 |
| uid | String | 作者UID |
| publishTime | String | 秒级时间戳 |
| commentNum | Integer | 评论数 |
| hasNext | Boolean | 是否有下一页 |
| pageCount | Integer | 每页条数 |

---

## 8. TikTok

**Path**: `/story/api/tiktok/ability/searchVideo`

**请求体**:
```json
{"keyword": "关键词", "offset": "0", "count": "20", "sortType": "0", "publishTime": "0", "region": "US"}
```
- `sortType`: `0`=相关度, `1`=最多点赞
- `publishTime`: `0`=不限, `1`=一天内, `7`=一周, `30`=一月, `90`=三月, `180`=半年
- `region`: ISO 3166-1 alpha-2 代码，默认 `US`

**响应**: `data[]`（注意：data 是数组）
| 字段 | 类型 | 说明 |
|------|------|------|
| workId | String | 作品ID |
| content | String | 作品描述 |
| mediaType | String | video/photo |
| publishTime | Integer | 秒级时间戳 |
| shareLink | String | 分享链接 |
| authorData.userName | String | 作者昵称 |
| authorData.userHandle | String | 作者handle |
| authorData.fansCount | Integer | 粉丝数 |
| authorData.avatarImage | String | 头像 |
| statsData.viewCount | Integer | 播放数 |
| statsData.likeCount | Integer | 点赞数 |
| statsData.commentTotal | Integer | 评论数 |
| statsData.shareTotal | Integer | 分享数 |
| statsData.favoriteCount | Integer | 收藏数 |
| statsData.repostTotal | Integer | 转载数 |
| videoData.coverImage | String | 封面 |
| videoData.playAddress | String | 播放地址 |
| videoData.downloadNoMarkAddress | String | 无水印下载 |
| videoData.playDuration | Integer | 时长（毫秒） |

---

## 9. Instagram

**Path**: `/story/api/ins/search`

**请求体**:
```json
{"keyword": "关键词"}
```
- 可选 `paginationToken` 翻页

**响应**: `data.items[]`
| 字段 | 类型 | 说明 |
|------|------|------|
| mediaId | String | 媒体ID |
| code | String | 短码（拼接链接用） |
| captionText | String | 正文 |
| captionHashtags | Array | 标签 |
| mediaFormat | String | video/image/album |
| mediaType | Integer | 1=图片,2=视频,8=轮播 |
| imageUrl | String | 封面图 |
| thumbnailUrl | String | 缩略图 |
| videoUrl | String | 视频URL（图片时为null） |
| videoDuration | Double | 时长（秒） |
| playCount | Integer | 播放数 |
| likeCount | Integer | 点赞数 |
| commentCount | Integer | 评论数 |
| shareCount | Integer | 分享数 |
| takenAt | Integer | 秒级时间戳 |
| takenAtDate | String | ISO 8601 时间 |
| user.username | String | 用户名 |
| user.fullName | String | 显示名 |
| user.followerCount | Integer | 粉丝数 |
| user.profilePicUrl | String | 头像 |
| user.isVerified | Boolean | 是否认证 |

**URL 构造**: `https://www.instagram.com/p/{code}/`

---

## 10. X (Twitter)

**Path**: `/story/api/x/search`

**请求体**:
```json
{"keyword": "关键词", "searchType": "Top"}
```
- `searchType`: `Top`/`Latest`/`Media`/`People`/`Lists`
- `cursor`: 翻页游标

**响应**: `data.tweets[]`
| 字段 | 类型 | 说明 |
|------|------|------|
| tweetId | String | 推文ID |
| text | String | 正文内容 |
| createdAt | String | 发布时间 |
| language | String | 语言 |
| likeCount | Integer | 点赞数 |
| retweetCount | Integer | 转推数 |
| replyCount | Integer | 回复数 |
| quoteCount | Integer | 引用数 |
| bookmarkCount | Integer | 收藏数 |
| viewCount | String | 浏览量 |
| username | String | 作者用户名 |
| user.displayName | String | 显示名 |
| user.followers | Integer | 粉丝数 |
| user.avatar | String | 头像 |
| user.verified | Boolean | 是否认证 |
| medias[] | Array | 媒体附件 |
| medias[].type | String | video/photo |
| medias[].coverUrl | String | 媒体封面 |
| medias[].variants[] | Array | 视频清晰度列表 |

**URL 构造**: `https://x.com/{username}/status/{tweetId}`

---

## 11. YouTube

**Path**: `/story/api/youtube/searchVideo`

**请求体**:
```json
{"searchQuery": "关键词"}
```
- 注意参数名为 `searchQuery` 而非 `keyword`
- 可选 `continuationToken` 翻页

**响应**: `data.videos[]`
| 字段 | 类型 | 说明 |
|------|------|------|
| videoId | String | 视频ID |
| title | String | 标题 |
| description | String | 描述 |
| author | String | 频道名 |
| channelId | String | 频道ID |
| duration | String | 时长（如 "35:38"） |
| publishedTime | String | 发布时间 |
| viewCount | Integer | 播放量 |
| thumbnails[] | Array | 缩略图 |
| thumbnails[].url | String | 缩略图URL |

**URL 构造**: `https://www.youtube.com/watch?v={videoId}`

#!/usr/bin/env python3
"""
全球AI新闻简报 — 数据采集脚本
并行请求 11 大平台搜索接口，统一标准化后输出 JSON。

用法:
    python3 fetch_all.py "关键词" [--output /tmp/result.json] [--platforms douyin,xhs,gzh]

依赖: 仅 Python 标准库 (urllib + concurrent.futures)，无需 pip 安装
环境变量: REDFOX_API_KEY (红狐 API 密钥)
"""

import argparse
import concurrent.futures
import json
import os
import sys
import time
import urllib.error
import urllib.request

HOST = "https://redfox.hk"
TIMEOUT = 30

# ---------------------------------------------------------------- 平台定义
# name: 平台名; path: 接口路径; body: 请求体模板; list_key: 响应中列表的定位路径
PLATFORMS = {
    "douyin": {
        "name": "抖音",
        "path": "/story/api/dy/data/searchWork",
        "body": {"keyword": "{kw}", "pageNum": 1, "pageSize": 20},
        "list_key": ["data", "list"],
    },
    "xiaohongshu": {
        "name": "小红书",
        "path": "/story/api/xhsUser/searchArticle",
        "body": {"keyword": "{kw}", "offset": 0, "sortType": "0"},
        "list_key": ["data", "list"],
    },
    "wechat_gzh": {
        "name": "公众号",
        "path": "/story/api/gzh/data/searchArticle",
        "body": {"keyword": "{kw}", "offset": 0, "sortType": "0"},
        "list_key": ["data", "list"],
    },
    "bilibili": {
        "name": "B站",
        "path": "/story/api/bili/data/workSearch",
        "body": {"keyword": "{kw}", "page": "1", "pageSize": 20, "order": "time"},
        "list_key": ["data", "workList"],
    },
    "kuaishou": {
        "name": "快手",
        "path": "/story/api/ksAllData/searchWork",
        "body": {"keyword": "{kw}", "page": 1, "size": 20, "sort": "综合"},
        "list_key": ["data", "list"],
    },
    "shipinhao": {
        "name": "视频号",
        "path": "/story/api/sphAllData/searchWork",
        "body": {"keyword": "{kw}", "page": 1, "size": 20, "sort": "综合"},
        "list_key": ["data", "list"],
    },
    "toutiao": {
        "name": "今日头条",
        "path": "/story/api/toutiao/searchWork",
        "body": {"keyword": "{kw}", "offset": "0"},
        "list_key": ["data"],  # data 直接是数组
    },
    "tiktok": {
        "name": "TikTok",
        "path": "/story/api/tiktok/ability/searchVideo",
        "body": {"keyword": "{kw}", "offset": "0", "count": "20", "sortType": "0", "publishTime": "0"},
        "list_key": ["data"],  # data 直接是数组
    },
    "instagram": {
        "name": "Instagram",
        "path": "/story/api/ins/search",
        "body": {"keyword": "{kw}"},
        "list_key": ["data", "items"],
    },
    "x_twitter": {
        "name": "X(Twitter)",
        "path": "/story/api/x/search",
        "body": {"keyword": "{kw}", "searchType": "Top"},
        "list_key": ["data", "tweets"],
    },
    "youtube": {
        "name": "YouTube",
        "path": "/story/api/youtube/searchVideo",
        "body": {"searchQuery": "{kw}"},  # 注意参数名为 searchQuery
        "list_key": ["data", "videos"],
    },
}

# ---------------------------------------------------------------- 平台专属映射函数
# 每个函数输入原始条目 dict，输出标准化 dict


def norm_douyin(i):
    vt = str(i.get("videoType", ""))
    return {
        "title": i.get("content", ""),
        "content": i.get("content", ""),
        "author": i.get("authorName", ""),
        "url": i.get("opusUrl", ""),
        "publishTime": i.get("publishTime", ""),
        "likes": i.get("likeCount", 0) or 0,
        "comments": i.get("commentCount", 0) or 0,
        "shares": i.get("shareCount", 0) or 0,
        "views": None,
        "collects": i.get("collectCount", 0) or 0,
        "followers": None,
        "coverUrl": i.get("coverUrl", ""),
        "mediaType": "image" if vt == "68" else "video",
    }


def norm_xiaohongshu(i):
    return {
        "title": i.get("workTitle", ""),
        "content": i.get("workDesc", ""),
        "author": i.get("accountNickname", ""),
        "url": i.get("workUrl", ""),
        "publishTime": i.get("workPublishTime", ""),
        "likes": i.get("workLikedCount", 0) or 0,
        "comments": i.get("workCommentsCount", 0) or 0,
        "shares": i.get("workSharedCount", 0) or 0,
        "views": None,
        "collects": i.get("workCollectedCount", 0) or 0,
        "followers": None,
        "coverUrl": i.get("coverUrl", ""),
        "mediaType": "video" if "video" in str(i.get("workType", "")) else "image",
    }


def norm_wechat_gzh(i):
    return {
        "title": i.get("title", ""),
        "content": i.get("summary", ""),
        "author": i.get("author", ""),
        "url": i.get("workUrl", ""),
        "publishTime": i.get("publishTime", ""),
        "likes": i.get("likeCount", 0) or 0,
        "comments": i.get("commentCount", 0) or 0,
        "shares": i.get("shareCount", 0) or 0,
        "views": i.get("readCount", 0) or 0,
        "collects": i.get("collectCount", 0) or 0,
        "followers": None,
        "coverUrl": i.get("coverUrl", ""),
        "mediaType": "text",
    }


def norm_bilibili(i):
    bv = i.get("bvId", "")
    return {
        "title": i.get("title", ""),
        "content": i.get("description", ""),
        "author": i.get("author", ""),
        "url": f"https://www.bilibili.com/video/{bv}" if bv else "",
        "publishTime": i.get("created", ""),
        "likes": i.get("likeCount", 0) or 0,
        "comments": i.get("commentCount", 0) or 0,
        "shares": i.get("shareCount", 0) or 0,
        "views": i.get("playCount", 0) or 0,
        "collects": i.get("favoriteCount", 0) or 0,
        "followers": None,
        "coverUrl": i.get("picUrl", ""),
        "mediaType": "video",
    }


def norm_kuaishou(i):
    pid = i.get("photoId", "")
    return {
        "title": i.get("caption", ""),
        "content": i.get("caption", ""),
        "author": i.get("nickname", ""),
        "url": f"https://www.kuaishou.com/short-video/{pid}" if pid else "",
        "publishTime": i.get("publishTime", ""),
        "likes": i.get("likeCount", 0) or 0,
        "comments": i.get("commentCount", 0) or 0,
        "shares": i.get("shareCount", 0) or 0,
        "views": i.get("viewCount", 0) or 0,
        "collects": i.get("collectCount", 0) or 0,
        "followers": i.get("authorFans", 0) or 0,
        "coverUrl": i.get("coverUrl", ""),
        "mediaType": "video",
    }


def norm_shipinhao(i):
    return {
        "title": i.get("description", ""),
        "content": i.get("description", ""),
        "author": i.get("nickname", ""),
        "url": i.get("videoUrl", ""),
        "publishTime": i.get("publishTime", ""),
        "likes": i.get("likeCount", 0) or 0,
        "comments": i.get("commentCount", 0) or 0,
        "shares": i.get("forwardCount", 0) or 0,
        "views": None,
        "collects": i.get("favCount", 0) or 0,
        "followers": None,
        "coverUrl": i.get("coverUrl", "") or i.get("thumbUrl", ""),
        "mediaType": "video",
    }


def norm_toutiao(i):
    return {
        "title": i.get("title", ""),
        "content": "",
        "author": i.get("nickname", ""),
        "url": i.get("opusUrl", ""),
        "publishTime": _ts_to_str(i.get("publishTime")),
        "likes": None,
        "comments": i.get("commentNum", 0) or 0,
        "shares": None,
        "views": None,
        "collects": None,
        "followers": None,
        "coverUrl": "",
        "mediaType": "text",
    }


def norm_tiktok(i):
    author = i.get("authorData") or {}
    stats = i.get("statsData") or {}
    video = i.get("videoData") or {}
    return {
        "title": i.get("content", ""),
        "content": i.get("content", ""),
        "author": author.get("userName", ""),
        "url": i.get("shareLink", ""),
        "publishTime": _ts_to_str(i.get("publishTime")),
        "likes": stats.get("likeCount", 0) or 0,
        "comments": stats.get("commentTotal", 0) or 0,
        "shares": stats.get("shareTotal", 0) or 0,
        "views": stats.get("viewCount", 0) or 0,
        "collects": stats.get("favoriteCount", 0) or 0,
        "followers": author.get("fansCount", 0) or 0,
        "coverUrl": video.get("coverImage", ""),
        "mediaType": "video" if i.get("mediaType") == "video" else "image",
    }


def norm_instagram(i):
    code = i.get("code", "")
    user = i.get("user") or {}
    return {
        "title": i.get("captionText", ""),
        "content": i.get("captionText", ""),
        "author": user.get("username", "") or user.get("fullName", ""),
        "url": f"https://www.instagram.com/p/{code}/" if code else "",
        "publishTime": i.get("takenAtDate", "") or _ts_to_str(i.get("takenAt")),
        "likes": i.get("likeCount", 0) or 0,
        "comments": i.get("commentCount", 0) or 0,
        "shares": i.get("shareCount", 0) or 0,
        "views": i.get("playCount", 0) or 0,
        "collects": None,
        "followers": user.get("followerCount", 0) or 0,
        "coverUrl": i.get("imageUrl", "") or i.get("thumbnailUrl", ""),
        "mediaType": {"video": "video", "image": "image", "album": "image"}.get(i.get("mediaFormat", ""), "image"),
    }


def norm_x_twitter(i):
    user = i.get("user") or {}
    username = user.get("username", "") or i.get("username", "")
    tweet_id = i.get("tweetId", "")
    medias = i.get("medias") or []
    first_media = medias[0] if medias else {}
    media_type = first_media.get("type", "") if first_media else ""
    return {
        "title": i.get("text", ""),
        "content": i.get("text", ""),
        "author": user.get("displayName", "") or username,
        "url": f"https://x.com/{username}/status/{tweet_id}" if username and tweet_id else "",
        "publishTime": i.get("createdAt", ""),
        "likes": i.get("likeCount", 0) or 0,
        "comments": i.get("replyCount", 0) or 0,
        "shares": i.get("retweetCount", 0) or 0,
        "views": _to_int(i.get("viewCount")),
        "collects": i.get("bookmarkCount", 0) or 0,
        "followers": user.get("followers", 0) or 0,
        "coverUrl": first_media.get("coverUrl", ""),
        "mediaType": media_type or "text",
    }


def norm_youtube(i):
    vid = i.get("videoId", "")
    thumbs = i.get("thumbnails") or []
    return {
        "title": i.get("title", ""),
        "content": i.get("description", ""),
        "author": i.get("author", ""),
        "url": f"https://www.youtube.com/watch?v={vid}" if vid else "",
        "publishTime": i.get("publishedTime", ""),
        "likes": None,
        "comments": None,
        "shares": None,
        "views": i.get("viewCount", 0) or 0,
        "collects": None,
        "followers": None,
        "coverUrl": thumbs[0].get("url", "") if thumbs else "",
        "mediaType": "video",
    }


NORMALIZERS = {
    "douyin": norm_douyin,
    "xiaohongshu": norm_xiaohongshu,
    "wechat_gzh": norm_wechat_gzh,
    "bilibili": norm_bilibili,
    "kuaishou": norm_kuaishou,
    "shipinhao": norm_shipinhao,
    "toutiao": norm_toutiao,
    "tiktok": norm_tiktok,
    "instagram": norm_instagram,
    "x_twitter": norm_x_twitter,
    "youtube": norm_youtube,
}

# ---------------------------------------------------------------- 工具函数


def _ts_to_str(ts):
    """秒级时间戳转 'YYYY-MM-DD HH:MM:SS'，None/非法返回空串"""
    if not ts:
        return ""
    try:
        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(int(ts)))
    except (ValueError, TypeError, OSError):
        return ""


def _to_int(v):
    try:
        return int(v) if v is not None else None
    except (ValueError, TypeError):
        return None


def _deep_get(obj, keys):
    """按路径取嵌套字段，任一环节缺失返回 None"""
    cur = obj
    for k in keys:
        if isinstance(cur, dict) and k in cur:
            cur = cur[k]
        else:
            return None
    return cur


# ---------------------------------------------------------------- 请求与解析


def fetch_platform(key, keyword, api_key):
    """请求单个平台，返回 (平台key, 结果dict)。失败时 result 含 error 字段。"""
    cfg = PLATFORMS[key]
    headers = {
        "Content-Type": "application/json",
        "REDFOX-API-KEY": api_key,
        "X-API-Key": api_key,
    }
    body_dict = {k: v.replace("{kw}", keyword) if isinstance(v, str) else v
                 for k, v in cfg["body"].items()}
    body_dict["source"] = "全球AI新闻简报-GitHub"
    body = json.dumps(body_dict).encode("utf-8")
    req = urllib.request.Request(f"{HOST}{cfg['path']}", data=body, headers=headers, method="POST")

    try:
        with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
            raw = json.loads(resp.read().decode("utf-8"))
    except urllib.error.HTTPError as e:
        detail = e.read().decode("utf-8", errors="replace")[:500]
        return key, {"platform": cfg["name"], "error": f"HTTP {e.code}: {detail}"}
    except urllib.error.URLError as e:
        return key, {"platform": cfg["name"], "error": f"网络错误: {e.reason}"}
    except Exception as e:  # noqa: BLE001 — 兜底保证单平台失败不影响整体
        return key, {"platform": cfg["name"], "error": f"解析错误: {e}"}

    if raw.get("code") != 2000:
        return key, {"platform": cfg["name"], "error": f"接口返回 code={raw.get('code')}, msg={raw.get('msg')}"}

    items = _deep_get(raw, cfg["list_key"])
    if items is None:
        items = []

    norm = NORMALIZERS[key]
    normalized = [norm(i) for i in items]
    total = _to_int(_deep_get(raw, ["data", "total"])) if key != "toutiao" and key != "tiktok" else None

    return key, {
        "platform": cfg["name"],
        "count": len(normalized),
        "total": total,
        "items": normalized,
    }


def main():
    parser = argparse.ArgumentParser(description="全球AI新闻简报 — 11 平台并行搜索")
    parser.add_argument("keyword", help="搜索关键词")
    parser.add_argument("-o", "--output", default="/tmp/news_intel_result.json", help="输出 JSON 路径")
    parser.add_argument("--platforms", default=None,
                        help="逗号分隔的平台子集，如 douyin,xhs。默认全部 11 平台")
    parser.add_argument("--pretty", action="store_true", help="格式化输出 JSON")
    args = parser.parse_args()

    api_key = os.environ.get("REDFOX_API_KEY", "").strip()
    if not api_key:
        print("错误: 环境变量 REDFOX_API_KEY 未设置", file=sys.stderr)
        print("请先执行: export REDFOX_API_KEY='你的密钥'", file=sys.stderr)
        sys.exit(1)

    if args.platforms:
        selected = [p.strip() for p in args.platforms.split(",") if p.strip()]
        unknown = [p for p in selected if p not in PLATFORMS]
        if unknown:
            print(f"错误: 未知平台 {unknown}，可选: {list(PLATFORMS)}", file=sys.stderr)
            sys.exit(1)
    else:
        selected = list(PLATFORMS)

    print(f"开始并行搜索 {len(selected)} 个平台，关键词: {args.keyword}", file=sys.stderr)
    results = {}
    errors = []
    with concurrent.futures.ThreadPoolExecutor(max_workers=len(selected)) as pool:
        futures = {pool.submit(fetch_platform, k, args.keyword, api_key): k for k in selected}
        for fut in concurrent.futures.as_completed(futures):
            key, result = fut.result()
            if "error" in result:
                errors.append(result)
                print(f"  ✗ {result['platform']}: {result['error']}", file=sys.stderr)
            else:
                results[key] = result
                print(f"  ✓ {result['platform']}: {result['count']} 条", file=sys.stderr)

    total_items = sum(r["count"] for r in results.values())
    total_engagement = sum(
        (i.get("likes") or 0) + (i.get("comments") or 0) + (i.get("shares") or 0)
        for r in results.values() for i in r["items"]
    )

    output = {
        "keyword": args.keyword,
        "generatedAt": time.strftime("%Y-%m-%d %H:%M:%S"),
        "platformCount": len(results),
        "failedPlatforms": errors,
        "totalItems": total_items,
        "totalEngagement": total_engagement,
        "results": results,
    }

    with open(args.output, "w", encoding="utf-8") as f:
        json.dump(output, f, ensure_ascii=False, indent=2 if args.pretty else None)

    print(f"\n完成: 成功 {len(results)}/{len(selected)} 平台, 共 {total_items} 条, 总互动 {total_engagement}", file=sys.stderr)
    print(args.output)


if __name__ == "__main__":
    main()