# 文件路径：scripts/chunked_reader.py
import pandas as pd
import json
import sys

def process_large_csv(file_path: str, chunk_size: int = 10000) -> dict:
    """
    分块读取并处理大型 CSV 文件

    参数：
        file_path:  CSV 文件路径
        chunk_size: 每块的行数，默认 10000

    返回：
        合并后的统计结果
    """
    total_rows   = 0
    total_sum    = 0.0
    chunk_count  = 0

    # 逐块读取，不会一次性加载整个文件到内存
    for chunk in pd.read_csv(file_path, chunksize=chunk_size):
        chunk_count += 1
        total_rows  += len(chunk)

        # 对每块执行统计，结果累计
        if "score" in chunk.columns:
            total_sum += chunk["score"].sum()

        # 实时汇报进度
        print(f"  已处理第 {chunk_count} 批，累计 {total_rows} 行", flush=True)

    avg = total_sum / total_rows if total_rows > 0 else 0
    return {
        "status":      "success",
        "total_rows":  total_rows,
        "chunks":      chunk_count,
        "score_avg":   round(avg, 2)
    }

if __name__ == "__main__":
    file_path = sys.argv[1] if len(sys.argv) > 1 else ""
    result    = process_large_csv(file_path)
    print(json.dumps(result, ensure_ascii=False, indent=2))

# 文件路径：scripts/file_cache.py
import hashlib
import json
import os
import time

CACHE_DIR = "/home/claude/.skill_cache"
os.makedirs(CACHE_DIR, exist_ok=True)

def _file_fingerprint(file_path: str) -> str:
    """
    根据文件路径、大小和修改时间生成指纹
    比 MD5 文件内容快得多，适合大文件
    """
    stat = os.stat(file_path)
    raw  = f"{file_path}|{stat.st_size}|{stat.st_mtime}"
    return hashlib.md5(raw.encode()).hexdigest()

def get_cached(file_path: str, operation: str):
    """取缓存，不存在时返回 None"""
    key        = _file_fingerprint(file_path) + "_" + operation
    cache_file = os.path.join(CACHE_DIR, f"{key}.json")
    if os.path.exists(cache_file):
        with open(cache_file) as f:
            return json.load(f)
    return None

def set_cached(file_path: str, operation: str, result: dict):
    """写入缓存"""
    key        = _file_fingerprint(file_path) + "_" + operation
    cache_file = os.path.join(CACHE_DIR, f"{key}.json")
    with open(cache_file, "w") as f:
        json.dump(result, f, ensure_ascii=False)

# 使用示例
def get_stats(file_path: str) -> dict:
    # 先查缓存
    cached = get_cached(file_path, "stats")
    if cached:
        print("命中缓存，跳过重复计算")
        return cached

    # 缓存未命中，执行计算
    import pandas as pd
    t0 = time.time()
    df = pd.read_csv(file_path)
    result = {
        "rows":    len(df),
        "cols":    len(df.columns),
        "elapsed": round(time.time() - t0, 3)
    }

    # 写入缓存供下次使用
    set_cached(file_path, "stats", result)
    return result

# 文件路径：scripts/parallel_process.py
import concurrent.futures
import os
import json
import sys

def process_single_file(file_path: str) -> dict:
    """处理单个文件（会被并行调用）"""
    try:
        size = os.path.getsize(file_path)
        # 模拟实际处理逻辑
        return {"file": os.path.basename(file_path),
                "size_kb": size // 1024, "status": "ok"}
    except Exception as e:
        return {"file": file_path, "status": "error", "message": str(e)}

def process_files_parallel(file_paths: list, max_workers: int = 4) -> list:
    """
    并行处理多个文件

    参数：
        file_paths:  文件路径列表
        max_workers: 最大并发数，默认 4（避免过多进程争抢资源）
    """
    results = []
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 提交所有任务
        future_map = {
            executor.submit(process_single_file, fp): fp
            for fp in file_paths
        }
        # 按完成顺序收集结果
        for future in concurrent.futures.as_completed(future_map):
            result = future.result()
            results.append(result)
            print(f"  完成：{result['file']}")
    return results

if __name__ == "__main__":
    # 模拟：处理上传目录中的所有 CSV 文件
    upload_dir = "/mnt/user-data/uploads"
    csv_files  = [
        os.path.join(upload_dir, f)
        for f in os.listdir(upload_dir)
        if f.endswith(".csv")
    ]

    if not csv_files:
        print("未找到 CSV 文件")
        sys.exit(0)

    print(f"开始并行处理 {len(csv_files)} 个文件...")
    results = process_files_parallel(csv_files)
    print(json.dumps(results, ensure_ascii=False, indent=2))