import requests
import time
import datetime
import pandas as pd
from collections import defaultdict
import json
from urllib3.exceptions import ConnectTimeoutError, MaxRetryError
from requests.exceptions import ConnectionError, Timeout
import random
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading
from rich.progress import (
    Progress,
    BarColumn,
    TimeRemainingColumn,
    SpinnerColumn,
    TextColumn
)


USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
HEADERS = {
    "User-Agent": USER_AGENT,
    "Referer": "https://www.bilibili.com/",
}
REQUEST_TIMEOUT = 15  # 增加超时时间
MAX_RETRIES = 3       # 最大重试次数
RETRY_DELAY = 2       # 重试间隔(秒)

session = requests.Session()
session.headers.update(HEADERS)

tag_cache = {}
tag_lock = threading.Lock()

last_req = 0.0
rate_lock = threading.Lock()


def clip(text, max_len=10):
    """安全截断文本，避免进度条换行"""
    if not text:
        return ""
    return text if len(text) <= max_len else text[:max_len - 1] + "…"


def get_favorite_videos(media_id, start_time, end_time, progress=None):
    """获取收藏夹视频列表（增强网络健棒性）"""
    base_url = "https://api.bilibili.com/x/v3/fav/resource/list"
    videos = []
    page = 1
    total = 0
    page_task = None
    
    if progress:
        page_task = progress.add_task(
            "[cyan]📥 获取收藏夹分页[/cyan]",
            total=None  # 页数未知
        )

    while True:
        params = {
            "media_id": media_id,
            "pn": page,
            "ps": 20,
            "keyword": "",
            "order": "mtime",  # 按收藏时间倒序排列
            "type": "0"
        }
        
        retry_count = 0
        while retry_count < MAX_RETRIES:
            try:
                response = session.get(
                    base_url, headers=HEADERS, params=params, timeout=REQUEST_TIMEOUT
                )

                response.raise_for_status()  # 检查HTTP状态码
                
                data = response.json().get("data", {})
                
                # 检查API返回状态
                if response.json().get("code") != 0:
                    print(f"API错误: {response.json().get('message')}")
                    break
                    
                if not data or not data.get("medias"):
                    print(f"第 {page} 页无数据，终止爬取")
                    if progress and page_task:
                        # 更新最终状态
                        progress.update(
                            page_task,
                            description=f"[cyan]📥 分页完成[/cyan] | 共{page-1}页 | {total}个视频"
                        )
                    return videos
                    
                # 检查最早收藏时间是否早于起始时间
                current_page_times = [item["fav_time"] for item in data["medias"]]
                earliest_time = datetime.datetime.fromtimestamp(min(current_page_times))
                if earliest_time < start_time:
                    print(f"第 {page} 页最早收藏时间 {earliest_time} 早于 {start_time}，终止爬取")
                    if progress and page_task:
                        # 更新最终状态
                        progress.update(
                            page_task,
                            description=f"[cyan]📥 分页完成[/cyan] | 共{page-1}页 | {total}个视频"
                        )
                    return videos
                
                # 处理当前页视频（逐条判断，保证分页进度可见）
                stop_paging = False

                for item in data["medias"]:
                    fav_time = datetime.datetime.fromtimestamp(item["fav_time"])

                    if fav_time < start_time:
                        stop_paging = True
                        continue
                    
                    if fav_time > end_time:
                        continue
                    
                    videos.append({
                        "bvid": item["bvid"],
                        "title": item["title"],
                        "up": item["upper"]["name"],
                        "fav_time": fav_time.strftime("%Y-%m-%d %H:%M:%S"),
                        "duration": item["duration"]
                    })
                    total += 1

                # 更新进度显示
                if progress and page_task:
                    progress.update(
                        page_task,
                        description=f"[cyan]📥 正在获取[/cyan] | 第{page}页 | 已获取{total}个视频"
                    )

                if stop_paging:
                    if progress and page_task:
                        # 更新最终状态
                        progress.update(
                            page_task,
                            description=f"[cyan]📥 分页完成[/cyan] | 共{page}页 | {total}个视频"
                        )
                    return videos
                
                # 检查是否还有下一页
                if data.get("has_more") != 1:
                    if progress and page_task:
                        # 更新最终状态
                        progress.update(
                            page_task,
                            description=f"[cyan]📥 分页完成[/cyan] | 共{page}页 | {total}个视频"
                        )
                    return videos
                    
                page += 1
                time.sleep(0.25)  # 增加延时避免被封
                break  # 成功获取数据，跳出重试循环
                
            except (ConnectionError, Timeout, ConnectTimeoutError, MaxRetryError) as e:
                retry_count += 1
                print(f"网络连接错误 ({retry_count}/{MAX_RETRIES}): {str(e)}")
                time.sleep(RETRY_DELAY * retry_count)
                
            except Exception as e:
                print(f"请求失败: {str(e)}")
                break
                
        if retry_count >= MAX_RETRIES:
            print(f"第 {page} 页请求失败，达到最大重试次数")
            if progress and page_task:
                # 更新最终状态
                progress.update(
                    page_task,
                    description=f"[cyan]📥 分页完成[/cyan] | 共{page-1}页 | {total}个视频"
                )
            return videos
        
    return videos

def get_video_tags(bvid):
    with tag_lock:
        if bvid in tag_cache:
            return tag_cache[bvid]

    url = f"https://api.bilibili.com/x/web-interface/view/detail/tag?bvid={bvid}"

    retry_count = 0
    while retry_count < MAX_RETRIES:
        try:
            response = session.get(url, timeout=REQUEST_TIMEOUT)
            response.raise_for_status()
            data = response.json().get("data", [])
            tags = [tag["tag_name"] for tag in data] if data else []

            with tag_lock:
                tag_cache[bvid] = tags
            return tags

        except (ConnectionError, Timeout, ConnectTimeoutError, MaxRetryError):
            retry_count += 1
            time.sleep(RETRY_DELAY * retry_count)

        except Exception:
            return []

    return []


def classify_videos(videos):
    """自动分类视频"""
    classification = defaultdict(list)
    
    for video in videos:
        tags = video.get("tags", [])
        if not tags:
            classification["未分类"].append(video)
            continue
            
        # 使用第一个标签作为主分类
        main_tag = tags[0]
        classification[main_tag].append(video)
        
        # 添加其他标签作为副分类
        for tag in tags[1:]:
            classification[tag].append(video)
    
    return classification

def save_results(videos, classification):
    """保存结果到文件"""
    # 保存视频数据
    if videos:
        df = pd.DataFrame(videos)
        # 展开标签列表为逗号分隔的字符串
        df['tags'] = df['tags'].apply(lambda x: ', '.join(x) if x else '')
        df.to_excel("bilibili_favorites.xlsx", index=False)
    
    # 保存分类数据
    # 将defaultdict转换为普通字典以便JSON序列化
    classification_dict = {k: v for k, v in classification.items()}
    with open("video_classification.json", "w", encoding="utf-8") as f:
        json.dump(classification_dict, f, ensure_ascii=False, indent=2)
    
    print("结果已保存到 bilibili_favorites.xlsx 和 video_classification.json")

def main():
    # 用户配置 
    MEDIA_ID = "1403756728"  # 收藏夹ID
    START_TIME = datetime.datetime(2025, 6, 21)  # 起始时间
    END_TIME = datetime.datetime(2026, 2, 8)  # 结束时间
    
    print(f"开始获取收藏夹 {MEDIA_ID} 的视频 ({START_TIME} 至 {END_TIME})...")

    with Progress(
    SpinnerColumn(),
    TextColumn("[bold cyan]{task.description}"),
    transient=False,
    ) as progress:

        videos = get_favorite_videos(
            MEDIA_ID,
            START_TIME,
            END_TIME,
            progress=progress
        )
    
    if not videos:
        print("未获取到符合时间条件的视频")
        return
    
    print(f"\n成功获取 {len(videos)} 个视频，开始获取标签...")

    with Progress(
        SpinnerColumn(),
        BarColumn(bar_width=30),
        TextColumn("{task.completed}/{task.total}"),
        TimeRemainingColumn(),
        TextColumn("[bold green]{task.description}"),
        transient=False,
    ) as progress:

        task = progress.add_task(
            "[green]🏷 获取视频标签[/green]",
            total=len(videos)
        )

        rate_lock = threading.Lock()
        last_req = 0.0
        
        def rate_limited_fetch(video):
            global last_req
            with rate_lock:
                now = time.time()
                if now - last_req < 0.5:
                    time.sleep(0.5 - (now - last_req))
                last_req = time.time()
            video["tags"] = get_video_tags(video["bvid"])
            return video


        with ThreadPoolExecutor(max_workers=2) as executor:
            futures = [executor.submit(rate_limited_fetch, v) for v in videos]

            for f in as_completed(futures):
                v = f.result()
                title = clip(v["title"], 28)
                progress.update(
                    task,
                    advance=1,
                    description=f"[green]{title}[/green] [dim]({len(v['tags'])} tags)[/dim]"
                )


    
    print("\n开始分类视频...")
    classified = classify_videos(videos)
    
    # 打印分类统计
    print("\n分类统计:")
    for category, items in classified.items():
        print(f"{category}: {len(items)}个视频")
    
    save_results(videos, classified)
    print("\n程序执行完毕!")

if __name__ == "__main__":
    # 添加全局异常捕获
    try:
        main()
    except Exception as e:
        print(f"程序发生未捕获异常: {str(e)}")
        import traceback
        traceback.print_exc()