Daily Hot News

"""
每日热榜技能扩展模块

整合了以下功能：
- news_digest: 热点新闻摘要（15种标签分类）
- industry_hot: 行业热榜垂直（十大行业分类）
- personalized: 个性化订阅（关键词/平台/排除项配置）
- cross_platform: 跨平台聚合（TOP10聚合）
- sentiment_monitor: 舆情监控（关键词过滤）
"""

from .news_digest import (
    NewsDigest,
    DigestConfig,
    DigestMode,
    TAG_MAPPING,
    ALL_TAGS,
    create_digest as create_news_digest
)

from .industry_hot import (
    IndustryHot,
    IndustryConfig,
    IndustryMode,
    INDUSTRIES,
    ALL_INDUSTRIES,
    create_industry_hot
)

from .personalized import (
    PersonalizedSubscription,
    UserPreferences,
    SubscriptionMode,
    KEYWORD_OPTIONS,
    PLATFORM_OPTIONS,
    EXCLUDE_OPTIONS,
    create_personalized
)

from .cross_platform import (
    CrossPlatformAggregator,
    CrossPlatformConfig,
    create_cross_platform
)

from .sentiment_monitor import (
    SentimentMonitor,
    SentimentConfig,
    SentimentType,
    create_sentiment_monitor
)

__all__ = [
    # News Digest
    "NewsDigest",
    "DigestConfig",
    "DigestMode",
    "TAG_MAPPING",
    "ALL_TAGS",
    "create_news_digest",
    
    # Industry Hot
    "IndustryHot",
    "IndustryConfig",
    "IndustryMode",
    "INDUSTRIES",
    "ALL_INDUSTRIES",
    "create_industry_hot",
    
    # Personalized
    "PersonalizedSubscription",
    "UserPreferences",
    "SubscriptionMode",
    "KEYWORD_OPTIONS",
    "PLATFORM_OPTIONS",
    "EXCLUDE_OPTIONS",
    "create_personalized",
    
    # Cross Platform
    "CrossPlatformAggregator",
    "CrossPlatformConfig",
    "create_cross_platform",
    
    # Sentiment Monitor
    "SentimentMonitor",
    "SentimentConfig",
    "SentimentType",
    "create_sentiment_monitor"
]

# Dependencies
node_modules/
.pnpm-store/

# Build outputs
dist/
build/

# Environment variables
.env
.env.local
.env.*.local

# IDE
.vscode/
.idea/
*.swp
*.swo
*~

# OS
.DS_Store
Thumbs.db

# Logs
logs/
*.log
npm-debug.log*

# Testing
coverage/
.nyc_output/

# Cache
.cache/
.__pycache__/
*.py[cod]
*$py.class

# Data files (user data)
data/
*.json

# Temporary files
tmp/
temp/
*.tmp

# OpenClaw specific
.clawdhub/

# Personal milestone (local only)
MILESTONE.md

# -*- coding: utf-8 -*-
"""
DailyHotApi Skill - API 客户端封装
"""

import aiohttp
import asyncio
import subprocess
import os
from typing import Optional, Dict, List, Any
from datetime import datetime
from config import config
from storage import storage  # 导入存储模块

# 部署状态存储
_deployment_status = {
    "is_deploying": False,
    "last_check": None,
    "needs_deployment": False,
    "message": ""
}


class HotSource:
    """热榜源定义"""

    def __init__(self, id: str, name: str, category: str, description: str = ""):
        self.id = id
        self.name = name
        self.category = category
        self.description = description


# 54 个热榜源定义
HOT_SOURCES = {
    # 视频/直播平台
    "bilibili": HotSource("bilibili", "哔哩哔哩", "video", "热门榜"),
    "acfun": HotSource("acfun", "AcFun", "video", "排行榜"),
    "douyin": HotSource("douyin", "抖音", "video", "热点榜"),
    "kuaishou": HotSource("kuaishou", "快手", "video", "热点榜"),
    "coolapk": HotSource("coolapk", "酷安", "video", "热榜"),

    # 社交媒体
    "weibo": HotSource("weibo", "微博", "social", "热搜榜"),
    "zhihu": HotSource("zhihu", "知乎", "social", "热榜"),
    "zhihu-daily": HotSource("zhihu-daily", "知乎日报", "social", "推荐榜"),
    "tieba": HotSource("tieba", "百度贴吧", "social", "热议榜"),
    "douban-group": HotSource("douban-group", "豆瓣讨论小组", "social", "讨论精选"),
    "v2ex": HotSource("v2ex", "V2EX", "social", "主题榜"),
    "ngabbs": HotSource("ngabbs", "NGA", "social", "热帖"),
    "hupu": HotSource("hupu", "虎扑", "social", "步行街热帖"),

    # 新闻资讯
    "baidu": HotSource("baidu", "百度", "news", "热搜榜"),
    "thepaper": HotSource("thepaper", "澎湃新闻", "news", "热榜"),
    "toutiao": HotSource("toutiao", "今日头条", "news", "热榜"),
    "36kr": HotSource("36kr", "36氪", "news", "热榜"),
    "qq-news": HotSource("qq-news", "腾讯新闻", "news", "热点榜"),
    "sina": HotSource("sina", "新浪网", "news", "热榜"),
    "sina-news": HotSource("sina-news", "新浪新闻", "news", "热点榜"),
    "netease-news": HotSource("netease-news", "网易新闻", "news", "热点榜"),
    "huxiu": HotSource("huxiu", "虎嗅", "news", "24小时"),
    "ifanr": HotSource("ifanr", "爱范儿", "news", "快讯"),

    # 科技/技术社区
    "ithome": HotSource("ithome", "IT之家", "tech", "热榜"),
    "ithome-xijiayi": HotSource("ithome-xijiayi", "IT之家「喜加一」", "tech", "最新动态"),
    "sspai": HotSource("sspai", "少数派", "tech", "热榜"),
    "csdn": HotSource("csdn", "CSDN", "tech", "排行榜"),
    "juejin": HotSource("juejin", "稀土掘金", "tech", "热榜"),
    "51cto": HotSource("51cto", "51CTO", "tech", "推荐榜"),
    "nodeseek": HotSource("nodeseek", "NodeSeek", "tech", "最新动态"),
    "hellogithub": HotSource("hellogithub", "HelloGitHub", "tech", "Trending"),

    # 游戏/ACG
    "genshin": HotSource("genshin", "原神", "game", "最新消息"),
    "miyoushe": HotSource("miyoushe", "米游社", "game", "最新消息"),
    "honkai": HotSource("honkai", "崩坏3", "game", "最新动态"),
    "starrail": HotSource("starrail", "崩坏：星穹铁道", "game", "最新动态"),
    "lol": HotSource("lol", "英雄联盟", "game", "更新公告"),

    # 阅读/文化
    "jianshu": HotSource("jianshu", "简书", "reading", "热门推荐"),
    "guokr": HotSource("guokr", "果壳", "reading", "热门文章"),
    "weread": HotSource("weread", "微信读书", "reading", "飙升榜"),
    "douban-movie": HotSource("douban-movie", "豆瓣电影", "reading", "新片榜"),

    # 工具/其他
    "52pojie": HotSource("52pojie", "吾爱破解", "tool", "榜单"),
    "hostloc": HotSource("hostloc", "全球主机交流", "tool", "榜单"),
    "weatheralarm": HotSource("weatheralarm", "中央气象台", "tool", "全国气象预警"),
    "earthquake": HotSource("earthquake", "中国地震台", "tool", "地震速报"),
    "history": HotSource("history", "历史上的今天", "tool", "月-日"),
}


class DailyHotApiClient:
    """DailyHotApi 客户端"""

    def __init__(self):
        self.api_url = config.api_url
        self.timeout = config.timeout

    async def fetch_hot_list(self, source_id: str, use_cache: bool = False) -> Optional[Dict[str, Any]]:
        """
        获取热榜数据

        Args:
            source_id: 热榜源 ID（如 weibo, zhihu, bilibili）
            use_cache: 是否使用缓存（默认False，每次获取最新数据）

        Returns:
            热榜数据字典或 None（失败时）
        """
        # 获取热榜源信息
        source = HOT_SOURCES.get(source_id)
        if not source:
            return None

        # 构建请求 URL
        url = config.get_api_url(source_id)

        # 步骤1：检查API是否可用
        print(f"[DailyHotApi] 正在连接 {source.name}...")
        api_available = await check_api_availability(url)

        if not api_available:
            # API不可用，尝试部署
            print(f"[DailyHotApi] ⚠️ 后端服务不可用，尝试自动部署...")

            # 触发部署
            deploy_result = await deploy_daily_hot_api()

            if deploy_result["success"]:
                # 部署成功，等待服务启动
                print(f"[DailyHotApi] ⏳ 等待服务启动 (5秒)...")
                await asyncio.sleep(5)

                # 再次检查API
                api_available = await check_api_availability(url)

                if not api_available:
                    # 仍然不可用，可能需要更多时间
                    print(f"[DailyHotApi] ⏳ 服务可能需要更多时间启动，再次等待 (10秒)...")
                    await asyncio.sleep(10)
                    api_available = await check_api_availability(url)

            # 返回部署状态
            if deploy_result["success"]:
                return {
                    "success": True,
                    "deploy_message": deploy_result["message"],
                    "is_deployed": True,
                    "data": None,
                    "message": "🎉 后端服务已部署成功！请稍后再次尝试获取热榜数据。"
                }
            else:
                return {
                    "success": False,
                    "deploy_message": "❌ 自动部署失败",
                    "steps": deploy_result.get("steps", []),
                    "data": None,
                    "message": f"⚠️ 无法连接后端服务\n\n自动部署失败：{deploy_result['message']}\n\n请手动部署：\n1. cd /root/.openclaw\n2. git clone https://github.com/imsyy/DailyHotApi.git\n3. cd DailyHotApi\n4. bash deploy.sh"
                }

        # API可用，获取数据
        try:
            timeout_obj = aiohttp.ClientTimeout(total=self.timeout)
            async with aiohttp.ClientSession(timeout=timeout_obj) as session:
                async with session.get(url) as response:
                    if response.status != 200:
                        return None

                    result = await response.json()

                    # 检查返回格式
                    if result.get("code") != 200:
                        return None

                    # 格式化数据
                    data = {
                        "platform": source.name,
                        "category": source.category,
                        "source_id": source_id,
                        "update_time": result.get("updateTime"),
                        "from_cache": result.get("fromCache", False),
                        "total": result.get("total", 0),
                        "data": self._format_items(result.get("data", [])),
                    }

                    # 每次获取最新数据后，保存到本地历史记录
                    save_result = storage.save_hot_list(source_id, data)
                    if save_result:
                        print(f"[DailyHotApi] ✅ 已保存 {source.name} 热榜数据到历史记录")

                    return data

        except Exception as e:
            print(f"[DailyHotApi] Error fetching {source_id}: {e}")
            return None

    async def get_hot榜单(self, source_id: str, limit: int = 10) -> Optional[List[Dict]]:
        """
        获取热榜条目列表（兼容旧接口）

        Args:
            source_id: 热榜源 ID
            limit: 返回条目数限制

        Returns:
            热榜条目列表或 None
        """
        data = await self.fetch_hot_list(source_id)
        if data:
            return data.get("data", [])[:limit]
        return None

    def _format_items(self, items: List[Dict]) -> List[Dict]:
        """格式化热榜条目"""
        formatted = []
        for i, item in enumerate(items[:config.max_items], 1):
            formatted.append({
                "rank": i,
                "title": item.get("title", ""),
                "desc": item.get("desc", ""),
                "hot": item.get("hot", ""),
                "url": item.get("url", ""),
                "mobile_url": item.get("mobileUrl", ""),
            })
        return formatted

    def get_all_sources(self) -> Dict[str, Dict]:
        """获取所有热榜源"""
        return {
            source_id: {
                "id": source_id,
                "name": source.name,
                "category": source.category,
                "description": source.description,
            }
            for source_id, source in HOT_SOURCES.items()
        }

    def get_sources_by_category(self) -> Dict[str, List[Dict]]:
        """按类别获取热榜源"""
        categories = {}
        for source_id, source in HOT_SOURCES.items():
            if source.category not in categories:
                categories[source.category] = []
            categories[source.category].append({
                "id": source_id,
                "name": source.name,
                "description": source.description,
            })
        return categories

    def search_sources(self, query: str) -> List[Dict]:
        """搜索热榜源"""
        query = query.lower()
        results = []
        for source_id, source in HOT_SOURCES.items():
            if (query in source.name.lower() or
                query in source.id.lower() or
                query in source.category.lower()):
                results.append({
                    "id": source_id,
                    "name": source.name,
                    "category": source.category,
                })
        return results


# 全局客户端实例
api_client = DailyHotApiClient()


# ============================================
# 自动检测和部署功能
# ============================================

async def check_api_availability(url: str, timeout: int = 3) -> bool:
    """
    检查API是否可用

    Args:
        url: API地址
        timeout: 超时时间（秒）

    Returns:
        True表示可用，False表示不可用
    """
    try:
        timeout_obj = aiohttp.ClientTimeout(total=timeout)
        async with aiohttp.ClientSession(timeout=timeout_obj) as session:
            async with session.get(url, allow_redirects=True) as response:
                return response.status == 200
    except Exception as e:
        print(f"[DailyHotApi] API不可用: {e}")
        return False


async def deploy_daily_hot_api() -> Dict[str, Any]:
    """
    自动部署DailyHotApi后端服务

    Returns:
        部署结果字典
    """
    global _deployment_status

    if _deployment_status["is_deploying"]:
        return {
            "success": False,
            "message": "部署正在进行中，请稍候...",
            "is_deploying": True
        }

    _deployment_status["is_deploying"] = True
    _deployment_status["message"] = "🚀 正在自动部署DailyHotApi后端服务..."

    result = {
        "success": False,
        "message": "",
        "steps": []
    }

    try:
        # 检查是否已安装
        daily_hot_path = "/root/.openclaw/DailyHotApi"
        if not os.path.exists(daily_hot_path):
            # 步骤1：克隆仓库
            step_msg = "📦 正在克隆DailyHotApi仓库..."
            print(step_msg)
            result["steps"].append(step_msg)

            clone_cmd = ["git", "clone", "https://github.com/imsyy/DailyHotApi.git", daily_hot_path]
            clone_proc = await asyncio.create_subprocess_exec(
                *clone_cmd,
                stdout=asyncio.subprocess.PIPE,
                stderr=asyncio.subprocess.PIPE
            )
            stdout, stderr = await clone_proc.communicate()

            if clone_proc.returncode != 0:
                error_msg = f"❌ 克隆失败: {stderr.decode()}"
                print(error_msg)
                result["steps"].append(error_msg)
                result["message"] = "部署失败：无法克隆仓库"
                _deployment_status["is_deploying"] = False
                return result

            result["steps"].append("✅ 克隆成功")
        else:
            result["steps"].append("✅ DailyHotApi已存在，跳过克隆")

        # 步骤2：部署服务
        if os.path.exists(daily_hot_path):
            step_msg = "🔧 正在部署DailyHotApi服务..."
            print(step_msg)
            result["steps"].append(step_msg)

            deploy_script = os.path.join(daily_hot_path, "deploy.sh")
            deploy_cmd = ["bash", deploy_script]

            deploy_proc = await asyncio.create_subprocess_exec(
                *deploy_cmd,
                stdout=asyncio.subprocess.PIPE,
                stderr=asyncio.subprocess.PIPE
            )
            stdout, stderr = await deploy_proc.communicate()

            deploy_output = stdout.decode() + stderr.decode()

            if deploy_proc.returncode == 0:
                result["steps"].append("✅ 部署成功")
                result["success"] = True
                result["message"] = "🎉 DailyHotApi后端服务部署成功！正在启动..."
                _deployment_status["message"] = result["message"]
            else:
                error_msg = f"❌ 部署失败: {deploy_output}"
                print(error_msg)
                result["steps"].append(error_msg)
                result["message"] = "部署失败，请手动检查"

    except Exception as e:
        error_msg = f"❌ 部署异常: {str(e)}"
        print(error_msg)
        result["steps"].append(error_msg)
        result["message"] = f"部署异常: {str(e)}"

    finally:
        _deployment_status["is_deploying"] = False
        _deployment_status["last_check"] = datetime.now().isoformat()

    return result


def get_deployment_status() -> Dict[str, Any]:
    """
    获取当前部署状态

    Returns:
        部署状态字典
    """
    return {
        "is_deploying": _deployment_status["is_deploying"],
        "last_check": _deployment_status["last_check"],
        "message": _deployment_status["message"]
    }


async def test_connection() -> bool:
    """测试 API 连接"""
    try:
        timeout_obj = aiohttp.ClientTimeout(total=5)
        async with aiohttp.ClientSession(timeout=timeout_obj) as session:
            async with session.get(f"{config.api_url}/") as response:
                return response.status == 200
    except Exception:
        return False


if __name__ == "__main__":
    import sys
    print("Testing DailyHotApi connection...")

    if asyncio.run(test_connection()):
        print("✓ Service is running")
    else:
        print("✗ Service not available")
        print(f"  URL: {config.api_url}")
        sys.exit(1)

# -*- coding: utf-8 -*-
"""
每日热榜 Skill - 配置管理
"""

import os
from typing import Optional


class Config:
    """配置管理类"""

    def __init__(self):
        # 每日热榜服务地址
        self.api_url: str = os.getenv(
            "DAILY_HOT_API_URL",
            "http://localhost:6688"
        )

        # 缓存时间（秒）
        self.cache_ttl: int = int(os.getenv("DAILY_HOT_CACHE_TTL", "3600"))

        # 返回最大条数
        self.max_items: int = int(os.getenv("DAILY_HOT_MAX_ITEMS", "20"))

        # 请求超时时间（秒）
        self.timeout: int = int(os.getenv("DAILY_HOT_TIMEOUT", "10"))

        # 启用调试模式
        self.debug: bool = os.getenv("DAILY_HOT_DEBUG", "false").lower() == "true"

        # 数据存储路径
        self.data_dir: str = os.getenv(
            "DAILY_HOT_DATA_DIR",
            "/root/.openclaw/workspace/skills/daily-hot-news/data"
        )

        # 是否自动保存每日热榜
        self.auto_save: bool = os.getenv("DAILY_HOT_AUTO_SAVE", "true").lower() == "true"

    def get_api_url(self, endpoint: str = "") -> str:
        """获取完整的 API 地址"""
        # 移除末尾斜杠
        base_url = self.api_url.rstrip("/")
        if endpoint:
            return f"{base_url}/{endpoint}"
        return base_url

    def is_service_available(self) -> bool:
        """检查服务是否配置"""
        return bool(self.api_url)

    def get_data_path(self, source_id: str = "", date_str: str = "") -> str:
        """获取数据文件路径"""
        import os
        from datetime import datetime

        if not date_str:
            date_str = datetime.now().strftime("%Y-%m-%d")

        data_dir = self.data_dir

        if source_id:
            # 按热榜源分目录存储
            source_dir = os.path.join(data_dir, source_id)
            os.makedirs(source_dir, exist_ok=True)
            return os.path.join(source_dir, f"{date_str}.json")
        else:
            # 主目录
            os.makedirs(data_dir, exist_ok=True)
            return os.path.join(data_dir, f"all_{date_str}.json")


# 全局配置实例
config = Config()

"""
跨平台聚合 - Cross Platform Aggregation Module

功能：
- 直接用全量数据做TOP10聚合
- 跨平台热点排行
"""

from typing import List, Dict, Optional, Any
from dataclasses import dataclass
import asyncio


@dataclass
class CrossPlatformConfig:
    """跨平台聚合配置"""
    total_items: int = 10           # 总条目数限制（默认TOP10）
    min_hot_score: float = 0        # 最小热度阈值
    merge_strategy: str = "score"   # 合并策略：score(按热度), time(按时间)
    include_platforms: List[str] = None   # 包含的平台（None表示全部）
    exclude_platforms: List[str] = None  # 排除的平台


class CrossPlatformAggregator:
    """跨平台聚合类"""
    
    def __init__(self, api_client=None, formatter=None):
        """
        初始化跨平台聚合
        
        Args:
            api_client: API客户端实例（可选）
            formatter: 格式化器实例（可选）
        """
        self.api_client = api_client
        self.formatter = formatter
        self.all_platforms = self._get_default_platforms()
    
    def _get_default_platforms(self) -> List[str]:
        """获取默认的全部平台列表"""
        return [
            "weibo", "zhihu", "douban-group", "douban-movie",
            "ithome", "36kr", "sspai", "csdn", "juejin",
            "genshin", "miyoushe", "bilibili", "hupu",
            "sina-news", "netease-news", "qq-news",
            "sina-money", "eastmoney", "xueqiu",
            "autohome", "懂车帝", "mafengwo", "ctrip",
            "dianping", "xiaohongshu", "weibo"
        ]
    
    async def fetch_all_hot_data(self, limit_per_platform: int = 10) -> List[Dict[str, Any]]:
        """
        一次性获取全部平台的热榜数据
        
        Args:
            limit_per_platform: 每个平台获取的条目数
            
        Returns:
            全部平台的热榜数据列表
        """
        all_items = []
        
        if self.api_client:
            for platform in self.all_platforms:
                try:
                    items = await self.api_client.get_hot榜单(platform, limit=limit_per_platform)
                    if items:
                        for item in items:
                            item["source_platform"] = platform
                        all_items.extend(items)
                except Exception as e:
                    print(f"Error fetching {platform}: {e}")
                    continue
        
        return all_items
    
    async def aggregate_top_hot(self, config: Optional[CrossPlatformConfig] = None) -> Dict[str, Any]:
        """
        聚合跨平台TOP热点（新版：先全部获取，再聚合）
        
        Args:
            config: 配置对象（可选）
            
        Returns:
            聚合后的热榜数据
        """
        if config is None:
            config = CrossPlatformConfig()
        
        # 步骤1：全部获取
        all_items = await self.fetch_all_hot_data()
        
        # 步骤2：聚合处理
        # 平台过滤
        if config.include_platforms:
            all_items = [item for item in all_items if item.get("source_platform") in config.include_platforms]
        if config.exclude_platforms:
            all_items = [item for item in all_items if item.get("source_platform") not in config.exclude_platforms]
        
        # 热度过滤
        if config.min_hot_score > 0:
            all_items = [item for item in all_items if (item.get("hot", 0) or item.get("score", 0)) >= config.min_hot_score]
        
        # 去重和排序
        merged_items = self._merge_and_sort(all_items, config.merge_strategy)
        
        # 限制总数
        merged_items = merged_items[:config.total_items]
        
        return {
            "total_items": len(merged_items),
            "items": merged_items
        }
    
    def _merge_and_sort(self, items: List[Dict], strategy: str = "score") -> List[Dict]:
        """
        合并、去重和排序
        
        Args:
            items: 条目列表
            strategy: 排序策略
            
        Returns:
            处理后的条目列表
        """
        if not items:
            return []
        
        # 按标题去重
        seen_titles = set()
        unique_items = []
        
        for item in items:
            title = item.get("title", "").strip().lower()
            if title and title not in seen_titles:
                seen_titles.add(title)
                unique_items.append(item)
        
        # 根据策略排序
        if strategy == "score":
            unique_items.sort(key=lambda x: x.get("hot", 0) or x.get("score", 0), reverse=True)
        elif strategy == "time":
            unique_items.sort(key=lambda x: x.get("time", "") or "", reverse=True)
        
        return unique_items
    
    def format_aggregation_response(self, agg_data: Dict[str, Any]) -> str:
        """
        格式化聚合响应
        
        Args:
            agg_data: 聚合数据
            
        Returns:
            格式化的响应文本
        """
        items = agg_data.get("items", [])
        
        if not items:
            return "❌ 暂无热点数据"
        
        response = "🏆 **跨平台热点TOP10**\n"
        response += f"共 {agg_data['total_items']} 条热点\n"
        response += "-" * 40 + "\n\n"
        
        for i, item in enumerate(items, 1):
            title = item.get("title", "无标题")
            hot = item.get("hot", item.get("score", ""))
            platform = item.get("source_platform", "")
            
            response += f"{i}. {title}\n"
            if hot:
                response += f"   🔥 热度: {hot}"
            if platform:
                response += f" | 📱 {platform}"
            response += "\n\n"
        
        return response
    
    async def process_user_request(self, user_input: str = None) -> Dict[str, Any]:
        """
        处理用户请求
        
        Args:
            user_input: 用户输入（可选）
            
        Returns:
            处理结果
        """
        # 获取聚合数据
        agg_data = await self.aggregate_top_hot()
        
        # 格式化响应
        response_text = self.format_aggregation_response(agg_data)
        
        return {
            "action": "show_top_hot",
            "data": agg_data,
            "message": response_text
        }


# 便捷函数
async def create_cross_platform(api_client=None, formatter=None) -> CrossPlatformAggregator:
    """创建跨平台聚合实例"""
    return CrossPlatformAggregator(api_client=api_client, formatter=formatter)


if __name__ == "__main__":
    # 测试代码
    async def test():
        aggregator = await create_cross_platform()
        
        print("获取跨平台热点TOP10...")
        result = await aggregator.process_user_request()
        print(result["message"])
    
    asyncio.run(test())

"""
每日热榜技能主入口示例

这个文件展示如何将三个扩展功能集成到主Skill中。
在实际使用时，可以根据需要调整和整合。
"""

import asyncio
from typing import Dict, Any, Optional

# 支持相对导入（作为包的一部分）和绝对导入（直接运行）
try:
    from .news_digest import NewsDigest, DigestConfig, create_digest as create_news_digest
    from .industry_hot import IndustryHot, IndustryConfig, create_industry_hot
    from .personalized import PersonalizedSubscription, UserPreferences, create_personalized
    from .storage import storage
    from .api_client import api_client, check_api_availability, deploy_daily_hot_api, get_deployment_status
    from .config import config
except ImportError:
    from news_digest import NewsDigest, DigestConfig, create_digest as create_news_digest
    from industry_hot import IndustryHot, IndustryConfig, create_industry_hot
    from personalized import PersonalizedSubscription, UserPreferences, create_personalized
    from storage import storage
    from api_client import api_client, check_api_availability, deploy_daily_hot_api, get_deployment_status
    from config import config


class DailyHotNewsSkill:
    """每日热榜技能主类"""

    def __init__(self, api_client=None, formatter=None):
        """
        初始化技能

        Args:
            api_client: API客户端实例（用于获取热榜数据）
            formatter: 格式化器实例（用于格式化输出）
        """
        self.api_client = api_client
        self.formatter = formatter

        # 初始化各功能模块
        self.news_digest: Optional[NewsDigest] = None
        self.industry_hot: Optional[IndustryHot] = None
        self.personalized: Optional[PersonalizedSubscription] = None

        # 标记是否已检查过旧数据（避免每次都提示）
        self._old_data_checked = False
        self._old_data_notification = None

    async def initialize(self):
        """初始化各模块"""
        self.news_digest = await create_news_digest(
            api_client=self.api_client,
            formatter=self.formatter
        )
        self.industry_hot = await create_industry_hot(
            api_client=self.api_client,
            formatter=self.formatter
        )
        self.personalized = await create_personalized(
            api_client=self.api_client,
            formatter=self.formatter
        )

        # 启动时检查是否有7天前的旧数据
        await self._check_old_data()

    async def _check_old_data(self):
        """检查并提示用户清理7天前的旧数据"""
        if self._old_data_checked:
            return

        old_files = storage.get_old_data_files(days=7)
        if old_files:
            # 统计
            sources = set(f["source_id"] for f in old_files)
            print(f"\n⚠️ 发现 {len(old_files)} 个旧数据文件（7天前）")
            print(f"   涉及平台: {', '.join(list(sources)[:5])}...")
            print(f"   示例文件: {old_files[0]['date_str']} - {old_files[0]['source_id']}")

            # 返回提示信息给用户
            self._old_data_notification = {
                "has_old_data": True,
                "count": len(old_files),
                "sources": list(sources),
                "message": f"""🗑️ **发现旧热榜数据**

检测到 {len(old_files)} 个热榜数据文件已超过7天未清理，涉及 {len(sources)} 个平台。

是否需要清理这些旧数据？
- 回复"**清理**"或"**是**"：删除7天前的所有旧数据
- 回复"**跳过**"或"**否**"：保留数据，下次启动不再提醒"""
            }
        else:
            self._old_data_notification = None

        self._old_data_checked = True

    def get_old_data_notification(self) -> Optional[Dict[str, Any]]:
        """获取旧数据清理提示（如果有）"""
        return self._old_data_notification

    async def handle_old_data_cleanup(self, confirm: bool = False) -> Dict[str, Any]:
        """
        处理旧数据清理

        Args:
            confirm: 是否确认清理

        Returns:
            清理结果
        """
        if not confirm:
            return {
                "action": "ask_confirm",
                "message": "请确认是否清理7天前的旧数据？\n回复\"清理\"确认，回复\"跳过\"取消。"
            }

        old_files = storage.get_old_data_files(days=7)
        if not old_files:
            return {
                "action": "show_message",
                "message": "✅ 没有需要清理的旧数据"
            }

        deleted = storage.cleanup_old_files(old_files)
        return {
            "action": "show_message",
            "message": f"✅ 成功清理 {deleted} 个旧数据文件"
        }
    
    async def handle_request(self, user_input: str, intent: str = None) -> Dict[str, Any]:
        """
        处理用户请求

        Args:
            user_input: 用户输入
            intent: 意图（可选，用于路由到对应功能）

        Returns:
            处理结果
        """
        user_input_lower = user_input.lower()

        # 检查是否是清理旧数据命令
        cleanup_keywords = ["清理", "删除旧数据", "清除缓存", "clean"]
        if any(kw in user_input_lower for kw in cleanup_keywords):
            return await self.handle_old_data_cleanup(confirm=True)

        # 检查是否是获取热榜的请求
        is_hot_request = any([
            intent == "news_digest",
            self._is_news_digest_request(user_input_lower),
            intent == "industry_hot",
            self._is_industry_hot_request(user_input_lower),
        ])

        if is_hot_request:
            # 先检查API是否可用
            api_url = config.api_url
            print(f"\n[DailyHotSkill] 检查后端服务可用性: {api_url}")

            api_available = await check_api_availability(api_url)

            if not api_available:
                print(f"[DailyHotSkill] ⚠️ 后端服务不可用，触发自动部署...")
                deploy_result = await deploy_daily_hot_api()

                # 返回部署状态给用户
                if deploy_result["success"]:
                    # 构建部署步骤消息
                    steps_text = ""
                    for step in deploy_result.get("steps", []):
                        steps_text += f"{step}\n"

                    return {
                        "action": "show_deploying",
                        "message": f"""🚀 **正在自动部署后端服务**

{steps_text}

⏳ **请稍候...**

后端服务正在启动，预计需要1-2分钟。

**部署完成后**，请再次发送请求获取热榜数据。

---
💡 如果自动部署失败，请手动执行：
1. `cd /root/.openclaw`
2. `git clone https://github.com/imsyy/DailyHotApi.git`
3. `cd DailyHotApi`
4. `bash deploy.sh`""",
                        "deploy_success": True,
                        "steps": deploy_result.get("steps", [])
                    }
                else:
                    # 部署失败，返回错误和手动部署指南
                    steps_text = ""
                    for step in deploy_result.get("steps", []):
                        steps_text += f"{step}\n"

                    return {
                        "action": "show_deploy_failed",
                        "message": f"""⚠️ **后端服务不可用**

自动部署失败，需要手动部署。

**部署步骤：**
```bash
cd /root/.openclaw
git clone https://github.com/imsyy/DailyHotApi.git
cd DailyHotApi
bash deploy.sh
```""",
                        "deploy_success": False,
                        "steps": deploy_result.get("steps", [])
                    }

        # 路由到对应功能
        if intent == "news_digest" or self._is_news_digest_request(user_input_lower):
            return await self._handle_news_digest(user_input)

        elif intent == "industry_hot" or self._is_industry_hot_request(user_input_lower):
            return await self._handle_industry_hot(user_input)

        elif intent == "personalized" or self._is_personalized_request(user_input_lower):
            return await self._handle_personalized(user_input)

        else:
            # 默认返回功能选择引导
            return await self._show_main_menu()
    
    def _is_news_digest_request(self, user_input: str) -> bool:
        """判断是否为新闻摘要请求"""
        keywords = ["热点", "摘要", "标签", "科技", "游戏", "娱乐", "财经", "新闻"]
        return any(kw in user_input for kw in keywords)
    
    def _is_industry_hot_request(self, user_input: str) -> bool:
        """判断是否为行业热榜请求"""
        keywords = ["行业", "汽车", "金融", "医疗", "旅游", "餐饮", "房产"]
        return any(kw in user_input for kw in keywords)
    
    def _is_personalized_request(self, user_input: str) -> bool:
        """判断是否为个性化请求"""
        keywords = ["配置", "设置", "偏好", "关注", "个性化", "订阅"]
        return any(kw in user_input for kw in keywords)
    
    async def _handle_news_digest(self, user_input: str) -> Dict[str, Any]:
        """处理新闻摘要请求"""
        if not self.news_digest:
            return {"error": "模块未初始化"}
        
        return await self.news_digest.process_user_request(user_input)
    
    async def _handle_industry_hot(self, user_input: str) -> Dict[str, Any]:
        """处理行业热榜请求"""
        if not self.industry_hot:
            return {"error": "模块未初始化"}
        
        return await self.industry_hot.process_user_request(user_input)
    
    async def _handle_personalized(self, user_input: str) -> Dict[str, Any]:
        """处理个性化订阅请求"""
        if not self.personalized:
            return {"error": "模块未初始化"}
        
        return await self.personalized.process_user_request(user_input)
    
    async def _show_main_menu(self) -> Dict[str, Any]:
        """显示主菜单"""
        # 检查是否有旧数据清理提示
        old_data = self.get_old_data_notification()

        menu_text = """🎯 **每日热榜 - 功能选择**

请选择您想使用的功能：

1. **📰 热点新闻摘要**
   按标签浏览热点新闻（科技、游戏、娱乐、财经等）

2. **🏭 行业热榜垂直**
   按行业分类查看热榜（汽车、金融、医疗、旅游等）

3. **⚙️ 个性化订阅**
   配置您的偏好，获取定制化热榜

💡 您可以直接告诉我您想做什么，例如：
- "今天有什么科技热点"
- "看看汽车行业热榜"
- "配置个性化热榜"
"""

        result = {
            "action": "show_menu",
            "message": menu_text
        }

        # 如果有旧数据，添加提示
        if old_data:
            result["old_data_prompt"] = old_data["message"]

        return result
    
    # 便捷方法
    
    async def get_news_digest_tags(self) -> str:
        """获取新闻摘要标签选项"""
        if self.news_digest:
            return await self.news_digest.get_tag_options()
        return "模块未初始化"
    
    async def get_industry_options(self) -> str:
        """获取行业选项"""
        if self.industry_hot:
            return await self.industry_hot.get_industry_options()
        return "模块未初始化"
    
    async def get_personalized_options(self) -> str:
        """获取个性化配置选项"""
        if self.personalized:
            return await self.personalized.get_config_options()
        return "模块未初始化"
    
    def get_current_config(self) -> Optional[UserPreferences]:
        """获取当前个性化配置"""
        if self.personalized:
            return self.personalized.get_current_config()
        return None


# 便捷函数
async def create_skill(api_client=None, formatter=None) -> DailyHotNewsSkill:
    """创建技能实例"""
    skill = DailyHotNewsSkill(api_client=api_client, formatter=formatter)
    await skill.initialize()
    return skill


# 示例使用
if __name__ == "__main__":
    async def example():
        # 创建技能实例（不传入api_client时的模拟示例）
        skill = await create_skill()
        
        # 示例1：展示主菜单
        result = await skill.handle_request("帮助")
        print(result["message"])
        
        print("\n" + "="*60 + "\n")
        
        # 示例2：展示标签选择
        result = await skill.get_news_digest_tags()
        print(result)
        
        print("\n" + "="*60 + "\n")
        
        # 示例3：展示行业选择
        result = await skill.get_industry_options()
        print(result)
        
        print("\n" + "="*60 + "\n")
        
        # 示例4：展示个性化配置选项
        result = await skill.get_personalized_options()
        print(result)
    
    asyncio.run(example())

# -*- coding: utf-8 -*-
"""
DailyHotApi Skill - 响应格式化
"""

from typing import Dict, List, Any
from api_client import HOT_SOURCES


class ResponseFormatter:
    """响应格式化器"""

    # 分类名称映射（中文）
    CATEGORY_NAMES = {
        "video": "🎬 视频/直播",
        "social": "💬 社交媒体",
        "news": "📰 新闻资讯",
        "tech": "💻 科技/技术",
        "game": "🎮 游戏/ACG",
        "reading": "📚 阅读/文化",
        "tool": "🔧 工具/其他",
    }

    @staticmethod
    def format_hot_list(data: Dict[str, Any]) -> str:
        """格式化热榜列表为文本"""
        lines = []
        platform = data.get("platform", "未知平台")
        update_time = data.get("update_time", "")

        # 头部
        lines.append(f"🔥 **{platform}**")
        if update_time:
            lines.append(f"更新时间: {update_time}")
        lines.append("")

        # 列表
        items = data.get("data", [])
        if not items:
            lines.append("暂无数据")
            return "\n".join(lines)

        for item in items:
            rank = item.get("rank", 0)
            title = item.get("title", "")
            hot = item.get("hot", "")
            url = item.get("url", "")

            # 热度处理
            hot_str = f" {hot}" if hot else ""

            # 标题处理（过长截断）
            if len(title) > 40:
                title = title[:40] + "..."

            lines.append(f"{rank:2d}. {title}{hot_str}")

        # 底部
        lines.append("")
        lines.append(f"共 {len(items)} 条")

        return "\n".join(lines)

    @staticmethod
    def format_hot_list_compact(data: Dict[str, Any], max_items: int = 10) -> str:
        """格式化热榜列表为紧凑格式"""
        lines = []
        platform = data.get("platform", "未知平台")

        lines.append(f"🔥 **{platform}**")
        lines.append("-" * 40)

        items = data.get("data", [])[:max_items]
        for item in items:
            rank = item.get("rank", 0)
            title = item.get("title", "")
            hot = item.get("hot", "")

            # 简化标题
            title = title.replace("\n", " ")
            if len(title) > 30:
                title = title[:30] + "..."

            hot_str = f" 📈 {hot}" if hot else ""
            lines.append(f"{rank:2d}. {title}{hot_str}")

        return "\n".join(lines)

    @staticmethod
    def format_all_sources() -> str:
        """格式化所有热榜源列表"""
        from api_client import api_client

        sources_by_cat = api_client.get_sources_by_category()
        lines = []

        lines.append("📊 **支持的热榜源（共 54 个）**")
        lines.append("")

        for cat_key, cat_name in ResponseFormatter.CATEGORY_NAMES.items():
            if cat_key in sources_by_cat:
                sources = sources_by_cat[cat_key]
                lines.append(f"### {cat_name}")
                lines.append(f"共 {len(sources)} 个")

                for source in sources:
                    lines.append(f"• **{source['name']}** (`{source['id']}`)")

                lines.append("")

        return "\n".join(lines)

    @staticmethod
    def format_sources_by_category() -> str:
        """按类别格式化热榜源"""
        from api_client import api_client

        sources_by_cat = api_client.get_sources_by_category()
        lines = []

        for cat_key, cat_name in ResponseFormatter.CATEGORY_NAMES.items():
            if cat_key not in sources_by_cat:
                continue

            lines.append(f"\n{cat_name}\n{'─' * 30}")
            sources = sources_by_cat[cat_key]
            for source in sources:
                lines.append(f"• {source['name']} (`{source['id']}`)")

        return "\n".join(lines)

    @staticmethod
    def format_search_results(results: List[Dict], query: str) -> str:
        """格式化搜索结果"""
        lines = []

        if not results:
            return f"❌ 没有找到与「{query}」相关的热榜源"

        lines.append(f"🔍 搜索「{query}」结果 ({len(results)} 个)")
        lines.append("")

        for result in results:
            lines.append(f"• **{result['name']}** (`{result['id']}`)")

        return "\n".join(lines)

    @staticmethod
    def format_error(message: str, suggestion: str = "") -> str:
        """格式化错误信息"""
        lines = [f"❌ {message}"]

        if suggestion:
            lines.append("")
            lines.append(f"💡 {suggestion}")

        return "\n".join(lines)

    @staticmethod
    def format_service_status(is_running: bool, url: str) -> str:
        """格式化服务状态"""
        if is_running:
            return f"✅ 每日热榜服务运行中\n\n📡 API 地址: {url}"
        else:
            return f"❌ 每日热榜服务未运行\n\n📡 预期地址: {url}\n\n💡 请使用 `./deploy.sh status` 查看状态"


# 全局格式化器实例
formatter = ResponseFormatter()

"""
行业热榜垂直（增强版） - Industry Hot Module

功能：
- 十大行业分类：科技互联网、游戏、汽车、金融财经、数码消费、娱乐影视、房产家居、医疗健康、旅游出行、餐饮消费
- 用户自主选择行业
- 行业描述和平台标注
"""

from typing import List, Dict, Optional, Any
from dataclasses import dataclass
from enum import Enum
import asyncio

# 十大行业映射
INDUSTRIES: Dict[str, Dict[str, Any]] = {
    "科技互联网": {
        "platforms": ["ithome", "36kr", "csdn", "juejin", "oschina", "infoq"],
        "description": "IT之家、36氪、CSDN、稀土掘金、开源中国、InfoQ"
    },
    "游戏行业": {
        "platforms": ["genshin", "miyoushe", "lol", "bilibili", "douyu", "huya", "netease-game"],
        "description": "原神、米游社、英雄联盟、B站、斗鱼、虎牙、网易游戏"
    },
    "汽车行业": {
        "platforms": ["autohome", "car", "懂车帝", "bitauto", "soufun-auto"],
        "description": "汽车之家、懂车帝、易车网、苏宁汽车"
    },
    "金融财经": {
        "platforms": ["sina-money", "eastmoney", "xueqiu", "jrj", "cnstock", "wallstreetcn", "money163"],
        "description": "新浪财经、东方财富、雪球、金融界、中国财经网、华尔街见闻、网易财经"
    },
    "数码消费": {
        "platforms": ["coolapk", "ithome", "sspai", "geekpark", "少数派", "smzdm"],
        "description": "酷安、IT之家、少数派、什么值得买"
    },
    "娱乐影视": {
        "platforms": ["weibo", "douban-group", "douban-movie", "mtime", "movie", "bilibili"],
        "description": "微博、豆瓣、豆瓣电影、时光网、B站"
    },
    "房产家居": {
        "platforms": ["lfang", "soufunianjia", "anjuke", "house", "lianjia"],
        "description": "链家、安居客、房天下、贝壳找房"
    },
    "医疗健康": {
        "platforms": ["zhihu", "知乎", "sina-health", "health", "baikemy", "丁香园"],
        "description": "知乎、新浪健康、丁香园、百度健康"
    },
    "旅游出行": {
        "platforms": ["mafengwo", "ctrip", "qunar", "飞猪", "马蜂窝", "携程"],
        "description": "马蜂窝、携程、去哪儿、飞猪"
    },
    "餐饮消费": {
        "platforms": ["dianping", "xiaohongshu", "大众点评", "ele.me", "meituan"],
        "description": "大众点评、美团、饿了么、小红书"
    }
}

# 所有行业名称
ALL_INDUSTRIES = list(INDUSTRIES.keys())


class IndustryMode(Enum):
    """行业模式"""
    SINGLE = "single"  # 单行业
    MULTI = "multi"    # 多行业


@dataclass
class IndustryConfig:
    """行业配置"""
    industries: List[str]        # 选择的行业列表
    mode: IndustryMode = IndustryMode.SINGLE
    items_per_platform: int = 10  # 每个平台显示的条目数
    total_items: int = 50         # 总条目数限制
    include_description: bool = True  # 是否包含行业描述


class IndustryHot:
    """行业热榜类"""
    
    def __init__(self, api_client=None, formatter=None):
        """
        初始化行业热榜
        
        Args:
            api_client: API客户端实例（可选）
            formatter: 格式化器实例（可选）
        """
        self.api_client = api_client
        self.formatter = formatter
        self._all_platforms = self._get_all_platforms()
    
    def _get_all_platforms(self) -> List[str]:
        """获取所有行业相关的平台"""
        platforms = set()
        for industry_info in INDUSTRIES.values():
            platforms.update(industry_info.get("platforms", []))
        return list(platforms)
    
    async def fetch_all_hot_data(self, limit_per_platform: int = 10) -> List[Dict[str, Any]]:
        """
        一次性获取全部平台的热榜数据
        
        Args:
            limit_per_platform: 每个平台获取的条目数
            
        Returns:
            全部平台的热榜数据列表
        """
        all_items = []
        
        if self.api_client:
            for platform in self._all_platforms:
                try:
                    items = await self.api_client.get_hot榜单(platform, limit=limit_per_platform)
                    if items:
                        for item in items:
                            item["source_platform"] = platform
                        all_items.extend(items)
                except Exception as e:
                    print(f"Error fetching {platform}: {e}")
                    continue
        
        return all_items
    
    async def get_industry_options(self) -> str:
        """
        获取行业选择选项（AI引导话术）
        
        Returns:
            格式化的行业选择文本
        """
        options_text = "🏭 **请选择您关注的行业**\n\n"
        
        for i, (industry, info) in enumerate(INDUSTRIES.items(), 1):
            platforms_count = len(info["platforms"])
            options_text += f"{i}. **{industry}**\n"
            options_text += f"   📋 包含 {platforms_count} 个平台\n"
            options_text += f"   🔗 {info['description']}\n\n"
        
        options_text += "-" * 50 + "\n"
        options_text += "💡 您可以输入行业名称或数字编号，支持多选（如：1,3或汽车+金融）"
        return options_text
    
    def parse_industries_from_input(self, user_input: str) -> List[str]:
        """
        解析用户输入的行业
        
        Args:
            user_input: 用户输入的文本
            
        Returns:
            匹配的行业列表
        """
        user_input = user_input.strip().lower()
        matched_industries = []
        
        # 处理数字选择
        import re
        number_pattern = re.findall(r'\d+', user_input)
        for num in number_pattern:
            idx = int(num) - 1
            if 0 <= idx < len(ALL_INDUSTRIES):
                matched_industries.append(ALL_INDUSTRIES[idx])
        
        # 行业关键词映射（行业名称 -> 包含的关键词）
        industry_keywords = {
            "科技互联网": ["科技", "互联网", "IT", "技术"],
            "游戏行业": ["游戏", "手游", "网游"],
            "汽车行业": ["汽车", "车", "车企", "新能源车"],
            "金融财经": ["金融", "财经", "投资", "理财", "股票"],
            "数码消费": ["数码", "手机", "电脑", "电子"],
            "娱乐影视": ["娱乐", "影视", "电影", "综艺", "明星"],
            "房产家居": ["房产", "房", "家居", "装修", "买房"],
            "医疗健康": ["医疗", "健康", "医药", "养生"],
            "旅游出行": ["旅游", "出行", "旅行", "机票", "酒店"],
            "餐饮消费": ["餐饮", "美食", "外卖", "餐厅", "消费"]
        }
        
        # 处理行业关键词
        for industry, keywords in industry_keywords.items():
            for keyword in keywords:
                if keyword in user_input:
                    if industry not in matched_industries:
                        matched_industries.append(industry)
                    break
        
        # 处理完整行业名称（向后兼容）
        for industry in ALL_INDUSTRIES:
            if industry.lower() in user_input or industry in user_input:
                if industry not in matched_industries:
                    matched_industries.append(industry)
        
        return matched_industries if matched_industries else []
    
    async def get_industry_hot(self, industries: List[str], config: Optional[IndustryConfig] = None) -> Dict[str, Any]:
        """
        获取行业热榜（新版：先全部获取，再按行业筛选）
        
        Args:
            industries: 行业列表
            config: 配置对象（可选）
            
        Returns:
            行业热榜数据
        """
        if config is None:
            config = IndustryConfig(industries=industries)
        
        # 步骤1：全部获取
        all_items = await self.fetch_all_hot_data(limit_per_platform=config.items_per_platform)
        
        # 步骤2：按行业筛选
        # 获取所有相关平台
        target_platforms = set()
        for industry in industries:
            if industry in INDUSTRIES:
                target_platforms.update(INDUSTRIES[industry]["platforms"])
        
        filtered_items = []
        for item in all_items:
            platform = item.get("source_platform", "")
            if platform in target_platforms:
                item["source_industry"] = next((ind for ind in industries if ind in INDUSTRIES and platform in INDUSTRIES[ind]["platforms"]), industries[0])
                filtered_items.append(item)
        
        # 去重和排序
        merged_items = self._merge_items(filtered_items)
        
        # 限制总数
        merged_items = merged_items[:config.total_items]
        
        return {
            "industries": industries,
            "industry_descriptions": {ind: INDUSTRIES[ind]["description"] for ind in industries},
            "total_items": len(merged_items),
            "items": merged_items
        }
    
    def _merge_items(self, items: List[Dict]) -> List[Dict]:
        """
        合并和去重条目
        
        Args:
            items: 条目列表
            
        Returns:
            合并后的条目列表
        """
        if not items:
            return []
        
        # 按标题去重
        seen_titles = set()
        unique_items = []
        
        for item in items:
            title = item.get("title", "").strip().lower()
            if title and title not in seen_titles:
                seen_titles.add(title)
                unique_items.append(item)
        
        # 按热度排序
        unique_items.sort(key=lambda x: x.get("hot", 0) or x.get("score", 0), reverse=True)
        
        return unique_items
    
    def format_industry_response(self, hot_data: Dict[str, Any]) -> str:
        """
        格式化行业热榜响应
        
        Args:
            hot_data: 热榜数据
            
        Returns:
            格式化的响应文本
        """
        if not hot_data.get("items"):
            return "❌ 暂无行业热榜数据"
        
        industries = hot_data["industries"]
        items = hot_data["items"]
        
        response = f"🏭 **行业热榜 - {', '.join(industries)}**\n\n"
        
        # 显示行业描述
        for industry in industries:
            desc = hot_data["industry_descriptions"].get(industry, "")
            response += f"📌 **{industry}**: {desc}\n"
        
        response += "-" * 50 + "\n"
        response += f"共 {hot_data['total_items']} 条热榜\n\n"
        
        # 按行业分组显示
        items_by_industry = {}
        for item in items:
            industry = item.get("source_industry", "其他")
            if industry not in items_by_industry:
                items_by_industry[industry] = []
            items_by_industry[industry].append(item)
        
        for industry, ind_items in items_by_industry.items():
            response += f"\n📊 **{industry}**\n"
            for i, item in enumerate(ind_items[:5], 1):  # 每个行业显示5条
                title = item.get("title", "无标题")
                hot = item.get("hot", item.get("score", ""))
                platform = item.get("source_platform", "")
                
                response += f"{i}. {title}\n"
                if hot:
                    response += f"   🔥 {hot}"
                if platform:
                    response += f" | 📱 {platform}"
                response += "\n"
        
        return response
    
    async def process_user_request(self, user_input: str) -> Dict[str, Any]:
        """
        处理用户请求
        
        Args:
            user_input: 用户输入
            
        Returns:
            处理结果
        """
        # 解析行业
        industries = self.parse_industries_from_input(user_input)
        
        if not industries:
            # 返回引导信息
            return {
                "action": "ask_industry",
                "message": await self.get_industry_options()
            }
        
        # 获取热榜
        hot_data = await self.get_industry_hot(industries)
        
        # 格式化响应
        response_text = self.format_industry_response(hot_data)
        
        return {
            "action": "show_industry_hot",
            "data": hot_data,
            "message": response_text
        }


# 便捷函数
async def create_industry_hot(api_client=None, formatter=None) -> IndustryHot:
    """创建行业热榜实例"""
    return IndustryHot(api_client=api_client, formatter=formatter)


if __name__ == "__main__":
    # 测试代码
    async def test():
        industry_hot = await create_industry_hot()
        print(await industry_hot.get_industry_options())
        
        print("\n" + "="*50 + "\n")
        
        result = await industry_hot.process_user_request("汽车和金融")
        print(result["message"])
    
    asyncio.run(test())

MIT License

Copyright (c) 2026 OpenClaw Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

"""
热点新闻摘要（增强版） - News Digest Module

功能：
- 15种标签分类：科技、互联网、游戏、娱乐、社会、财经、汽车、体育、教育、健康、国际、房产、数码、时尚、美食
- AI主动引导用户选择标签
- 按标签获取和合并热榜
"""

from typing import List, Dict, Optional, Any
from dataclasses import dataclass
from enum import Enum
import asyncio

# 标签到平台的映射
TAG_MAPPING: Dict[str, List[str]] = {
    "科技": ["ithome", "36kr", "sspai", "csdn", "juejin", "51cto", "oschina", "infoq"],
    "互联网": ["sina-news", "netease-news", "qq-news", "sohu-news", "ifeng"],
    "游戏": ["genshin", "miyoushe", "lol", "hupu", "bilibili", "douyu", "huya", "netease-game"],
    "娱乐": ["weibo", "douban-group", "douban-movie", "mtime", "movie"],
    "社会": ["sina-news", "netease-news", "qq-news", "sohu-news", "ifeng", "qq"],
    "财经": ["sina-money", "eastmoney", "xueqiu", "jrj", "cnstock", "wallstreetcn"],
    "汽车": ["autohome", "car", "懂车帝", "bitauto", "car1"],
    "体育": ["hupu", "sports", "sina-sports", "qq-sports", "zhibo8"],
    "教育": ["zhihu", "知乎", "bilibili", "jike", "dazhihui"],
    "健康": ["zhihu", "知乎", "sina-health", "health", "baikemy"],
    "国际": ["sina-news", "netease-news", "qq-news", "ifeng", "cnn", "bbc"],
    "房产": ["lfang", "soufunianjia", "anjuke", "house"],
    "数码": ["ithome", "coolapk", "sspai", "geekpark", "少数派"],
    "时尚": ["mogujie", "meilishuo", "xiaohongshu", "微博时尚", "yoho"],
    "美食": ["dianping", "xiaohongshu", "大众点评", "maoyan", "ele.me"]
}

# 所有可用的标签
ALL_TAGS = list(TAG_MAPPING.keys())


class DigestMode(Enum):
    """摘要模式"""
    SINGLE = "single"  # 单标签
    MULTI = "multi"    # 多标签


@dataclass
class DigestConfig:
    """摘要配置"""
    tags: List[str]          # 选择的标签列表
    mode: DigestMode = DigestMode.MULTI
    items_per_platform: int = 10  # 每个平台显示的条目数
    total_items: int = 50         # 总条目数限制
    merge_strategy: str = "score"  # 合并策略：score(按热度), time(按时间), random(随机)


class NewsDigest:
    """热点新闻摘要类"""
    
    def __init__(self, api_client=None, formatter=None):
        """
        初始化新闻摘要
        
        Args:
            api_client: API客户端实例（可选，如果不提供则需要外部传入）
            formatter: 格式化器实例（可选）
        """
        self.api_client = api_client
        self.formatter = formatter
        self.platforms = self._get_all_platforms()
    
    def _get_all_platforms(self) -> List[str]:
        """获取所有可用的平台"""
        platforms = set()
        for tag, plats in TAG_MAPPING.items():
            platforms.update(plats)
        return list(platforms)
    
    async def fetch_all_hot_data(self, limit_per_platform: int = 10) -> List[Dict[str, Any]]:
        """
        一次性获取全部54个平台的热榜数据
        
        Args:
            limit_per_platform: 每个平台获取的条目数
            
        Returns:
            全部平台的热榜数据列表
        """
        all_items = []
        
        if self.api_client:
            for platform in self.platforms:
                try:
                    items = await self.api_client.get_hot榜单(platform, limit=limit_per_platform)
                    if items:
                        for item in items:
                            item["source_platform"] = platform
                        all_items.extend(items)
                except Exception as e:
                    print(f"Error fetching {platform}: {e}")
                    continue
        
        return all_items
    
    async def get_tag_options(self) -> str:
        """
        获取标签选择选项（AI引导话术）
        
        Returns:
            格式化的标签选择文本
        """
        options_text = "📊 **请选择您感兴趣的标签**\n\n"
        
        # 分两列显示
        tags_left = ALL_TAGS[:8]
        tags_right = ALL_TAGS[8:]
        
        for i, tag in enumerate(tags_left):
            right_tag = tags_right[i] if i < len(tags_right) else ""
            left_plats = ", ".join(TAG_MAPPING[tag][:3])
            right_plats = f"│ {i+8+1}. {right_tag}: {', '.join(TAG_MAPPING[right_tag][:3])}" if right_tag else ""
            options_text += f"{i+1}. {tag} ({left_plats}) {right_plats}\n"
        
        options_text += "\n💡 您可以输入标签名称或数字编号，支持多选（如：1,3或科技+游戏）"
        return options_text
    
    def parse_tags_from_input(self, user_input: str) -> List[str]:
        """
        解析用户输入的标签
        
        Args:
            user_input: 用户输入的文本
            
        Returns:
            匹配的标签列表
        """
        user_input = user_input.strip().lower()
        matched_tags = []
        
        # 处理数字选择
        numbers = []
        import re
        number_pattern = re.findall(r'\d+', user_input)
        for num in number_pattern:
            idx = int(num) - 1
            if 0 <= idx < len(ALL_TAGS):
                numbers.append(ALL_TAGS[idx])
        
        # 处理标签名称
        for tag in ALL_TAGS:
            if tag.lower() in user_input or tag in user_input:
                if tag not in matched_tags and tag not in numbers:
                    matched_tags.append(tag)
        
        # 合并数字选择的结果
        matched_tags.extend([t for t in numbers if t not in matched_tags])
        
        return matched_tags if matched_tags else []
    
    async def get_digest_by_tags(self, tags: List[str], config: Optional[DigestConfig] = None) -> Dict[str, Any]:
        """
        按标签获取新闻摘要（新版：先全部获取，再按标签筛选）
        
        Args:
            tags: 标签列表
            config: 配置对象（可选）
            
        Returns:
            合并后的热榜数据
        """
        if config is None:
            config = DigestConfig(tags=tags)
        
        # 步骤1：全部获取
        all_items = await self.fetch_all_hot_data(limit_per_platform=config.items_per_platform)
        
        # 步骤2：按标签筛选
        # 获取所有相关平台
        target_platforms = set()
        for tag in tags:
            if tag in TAG_MAPPING:
                target_platforms.update(TAG_MAPPING[tag])
        
        filtered_items = []
        for item in all_items:
            platform = item.get("source_platform", "")
            if platform in target_platforms:
                item["source_tag"] = next((t for t in tags if t in TAG_MAPPING and platform in TAG_MAPPING[t]), tags[0])
                filtered_items.append(item)
        
        # 去重和合并
        merged_items = self._merge_items(filtered_items, config.merge_strategy)
        
        # 限制总数
        merged_items = merged_items[:config.total_items]
        
        return {
            "tags": tags,
            "platforms": list(target_platforms),
            "total_items": len(merged_items),
            "items": merged_items
        }
    
    def _merge_items(self, items: List[Dict], strategy: str = "score") -> List[Dict]:
        """
        合并和去重条目
        
        Args:
            items: 条目列表
            strategy: 合并策略
            
        Returns:
            合并后的条目列表
        """
        if not items:
            return []
        
        # 按标题去重
        seen_titles = set()
        unique_items = []
        
        for item in items:
            title = item.get("title", "").strip().lower()
            if title and title not in seen_titles:
                seen_titles.add(title)
                unique_items.append(item)
        
        # 根据策略排序
        if strategy == "score":
            # 按热度/分数排序
            unique_items.sort(key=lambda x: x.get("hot", 0) or x.get("score", 0), reverse=True)
        elif strategy == "time":
            # 按时间排序
            unique_items.sort(key=lambda x: x.get("time", "") or "", reverse=True)
        
        return unique_items
    
    def format_digest_response(self, digest_data: Dict[str, Any]) -> str:
        """
        格式化摘要响应
        
        Args:
            digest_data: 摘要数据
            
        Returns:
            格式化的响应文本
        """
        if not digest_data.get("items"):
            return "❌ 暂无热点数据"
        
        tags = digest_data["tags"]
        items = digest_data["items"]
        
        response = f"📰 **热点摘要 - {', '.join(tags)}**\n"
        response += f"来源平台: {', '.join(digest_data['platforms'])}\n"
        response += f"共 {digest_data['total_items']} 条热点\n"
        response += "-" * 40 + "\n\n"
        
        for i, item in enumerate(items, 1):
            title = item.get("title", "无标题")
            hot = item.get("hot", item.get("score", ""))
            platform = item.get("source_platform", "")
            
            response += f"{i}. {title}\n"
            if hot:
                response += f"   🔥 热度: {hot}"
            if platform:
                response += f" | 📱 {platform}"
            response += "\n\n"
        
        return response
    
    async def process_user_request(self, user_input: str) -> Dict[str, Any]:
        """
        处理用户请求
        
        Args:
            user_input: 用户输入
            
        Returns:
            处理结果
        """
        # 解析标签
        tags = self.parse_tags_from_input(user_input)
        
        if not tags:
            # 返回引导信息
            return {
                "action": "ask_tag",
                "message": await self.get_tag_options()
            }
        
        # 获取摘要
        digest_data = await self.get_digest_by_tags(tags)
        
        # 格式化响应
        response_text = self.format_digest_response(digest_data)
        
        return {
            "action": "show_digest",
            "data": digest_data,
            "message": response_text
        }


# 便捷函数
async def create_digest(api_client=None, formatter=None) -> NewsDigest:
    """创建新闻摘要实例"""
    return NewsDigest(api_client=api_client, formatter=formatter)


if __name__ == "__main__":
    # 测试代码
    async def test():
        digest = await create_digest()
        print(await digest.get_tag_options())
        
        print("\n" + "="*50 + "\n")
        
        result = await digest.process_user_request("科技和游戏")
        print(result["message"])
    
    asyncio.run(test())