#!/usr/bin/env python3
"""
Kaggle + Ollama + 无审查 Qwen3-14B + Cloudflare Tunnel（Quick Tunnel 默认）

从 Colab 版 qwen3-colab.py 改过来，适配 Kaggle 免费 GPU Notebook。
用法（Kaggle Notebook 里，新开一个 cell 跑就行）：
  1. Notebook 设置：Accelerator 选 GPU T4 x2，Internet 保持开启。
  2. 先把本文件下到 /kaggle/working：
       !wget -q https://muse.richyean.com/qwen3-kaggle.py -O /kaggle/working/qwen3-kaggle.py
  3. 再跑（这个 cell 会一直占着不返回，用来保活，防空闲断开）：
       !python /kaggle/working/qwen3-kaggle.py --tunnel quick --max-hours 8

关键点（跟 Colab 的不同）：
  - Kaggle 没有 Drive：模型存在 /kaggle/working/ollama-models（20GB 上限，
    14B 约 9GB 放得下）。想下次会话复用，去 Notebook 设置里开
    Session Persistence -> Files only；不开的话每次重下，9GB 约 1-2 分钟。
  - Kaggle 交互会话空闲 20 分钟就断（部分文档说 60 分钟，按 20 分钟算），
    后台跑的 Ollama 不算“执行中”。所以本脚本最后会一直睡着占住这个 cell，
    只要 cell 在跑就不会判空闲；满 --max-hours（默认 8 小时，Kaggle 单次
    上限约 9 小时）自动停 Ollama 和隧道。
  - 隧道默认 Quick Tunnel：随机 trycloudflare.com 域名，不用 token，
    每次会话域名会变，仅供测试。想用固定域名，
    改跑 --tunnel named --public-url https://kaggle.richyean.com，
    并把 token 放到环境变量 CLOUDFLARE_TUNNEL_TOKEN 里
    （Kaggle Secrets，或运行时前面加 CLOUDFLARE_TUNNEL_TOKEN=<token>），
    不要写进 Notebook 代码。实测：Quick Tunnel 的 trycloudflare 域名
    会被 Cloudflare 全拦（curl、urllib、真浏览器全是 403），
    Named Tunnel（固定域名）才走得通。
  - 本脚本不含任何密钥、不发微信。提前停：在新 cell 里跑 touch /tmp/qwen-stop，
    或直接点 Notebook 的 Stop / 断开会话。
"""

import argparse
import json
import os
import re
import subprocess
import time
import urllib.request

# 默认模型：无审查版 Qwen3 14B
MODEL = "huihui_ai/qwen3-abliterated:14b"
MODEL_SIZE = "9.0GB"
# 模型缓存目录：/kaggle/working 会自动保存（20GB 上限）
MODELS_DIR = "/kaggle/working/ollama-models"
CLOUDFLARED_DEB = "/kaggle/working/bin/cloudflared-linux-amd64.deb"
# Named Tunnel 才用得到：固定域名（token 从环境变量读，不写文件里）
NAMED_URL = "https://qwen.richyean.com"

STOP_FILE = "/tmp/qwen-stop"
# 单次会话上限约 9 小时，默认 8 小时自动停，留点余量
MAX_RUNTIME_HOURS = 8


def run(cmd, **kw):
    print("$", " ".join(cmd), flush=True)
    return subprocess.run(cmd, **kw)


def shell(cmd, env=None):
    print("$", cmd, flush=True)
    return subprocess.run(cmd, shell=True, env=env)


def check_gpu():
    print("== GPU ==", flush=True)
    run(["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv"])


def install_ollama():
    if run(["which", "ollama"], capture_output=True).returncode == 0:
        print("Ollama 已装，跳过", flush=True)
        return
    print("== 安装 Ollama ==", flush=True)
    shell("apt-get update -qq && apt-get install -y -qq zstd > /dev/null")
    shell("curl -fsSL https://ollama.com/install.sh | sh")


def wait_for_ollama(timeout=120):
    deadline = time.time() + timeout
    last_err = None
    while time.time() < deadline:
        try:
            with urllib.request.urlopen("http://localhost:11434/api/tags", timeout=5) as r:
                print(r.read().decode()[:500], flush=True)
                print("Ollama 已就绪", flush=True)
                return True
        except Exception as e:
            last_err = e
            print(f"Ollama 还没起来，等 3 秒再试：{e}", flush=True)
            time.sleep(3)
    print(f"Ollama {timeout} 秒还没起来，最后错误：{last_err}", flush=True)
    try:
        print("ollama 日志：", flush=True)
        print(open("/tmp/ollama.log").read()[-2000:], flush=True)
    except Exception as e:
        print("读不到 ollama 日志：", e, flush=True)
    return False


def start_ollama():
    env = dict(os.environ)
    env["OLLAMA_MODELS"] = MODELS_DIR
    os.makedirs(MODELS_DIR, exist_ok=True)
    run(["pkill", "-f", "ollama serve"], capture_output=True)
    time.sleep(2)
    with open("/tmp/ollama.log", "w") as log:
        subprocess.Popen(["ollama", "serve"], stdout=log, stderr=subprocess.STDOUT, env=env)
    if not wait_for_ollama():
        raise RuntimeError("Ollama 启动超时，先看上面日志")


def pull_if_missing(model):
    env = dict(os.environ)
    env["OLLAMA_MODELS"] = MODELS_DIR
    out = subprocess.run(["ollama", "list"], capture_output=True, text=True, env=env).stdout
    print(out, flush=True)
    names = {line.split()[0] for line in out.strip().splitlines()[1:] if line.split()}
    if any(n == model or n.startswith(model + ":") for n in names):
        print(f"已有 {model}，跳过下载（目录：{MODELS_DIR}）", flush=True)
        return
    print(f"没有 {model}，开始拉到 {MODELS_DIR}（{MODEL_SIZE}，约 1-2 分钟）", flush=True)
    run(["ollama", "pull", model], env=env)
    run(["ollama", "list"], env=env)


def install_cloudflared():
    if os.path.exists(CLOUDFLARED_DEB):
        print("已有 cloudflared deb，直接装：", CLOUDFLARED_DEB, flush=True)
        run(["dpkg", "-i", CLOUDFLARED_DEB])
    elif run(["which", "cloudflared"], capture_output=True).returncode == 0:
        print("本机已有 cloudflared，跳过", flush=True)
    else:
        print("没有 cloudflared deb，下载到：", CLOUDFLARED_DEB, flush=True)
        os.makedirs("/kaggle/working/bin", exist_ok=True)
        run(["wget", "-q",
             "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb",
             "-O", CLOUDFLARED_DEB])
        run(["dpkg", "-i", CLOUDFLARED_DEB])
    run(["which", "cloudflared"])


def start_quick_tunnel():
    """Quick Tunnel：随机 trycloudflare.com 域名，不用 token。返回公网地址。"""
    run(["pkill", "-f", "cloudflared"], capture_output=True)
    time.sleep(1)
    with open("/tmp/cloudflared.log", "w") as log:
        subprocess.Popen(
            ["cloudflared", "tunnel", "--url", "http://localhost:11434"],
            stdout=log, stderr=subprocess.STDOUT)
    print("等 Quick Tunnel 地址（最多 60 秒）…", flush=True)
    for _ in range(30):
        time.sleep(2)
        try:
            text = open("/tmp/cloudflared.log").read()
        except Exception:
            continue
        m = re.search(r"https://[A-Za-z0-9-]+\.trycloudflare\.com", text)
        if m:
            url = m.group(0)
            print("隧道已通，公网地址：", url, flush=True)
            return url
    print("60 秒没拿到隧道地址，日志：", flush=True)
    print(open("/tmp/cloudflared.log").read()[-2000:], flush=True)
    return None


def start_named_tunnel(public_url):
    """Named Tunnel：固定域名，token 从环境变量 CLOUDFLARE_TUNNEL_TOKEN 读。"""
    token = os.environ.get("CLOUDFLARE_TUNNEL_TOKEN")
    if not token:
        print("没找到 CLOUDFLARE_TUNNEL_TOKEN", flush=True)
        print("去 Kaggle Notebook 右侧 Secrets 加一个同名 Secret 再跑，", flush=True)
        print("或者先用 --tunnel quick 验证。", flush=True)
        return None
    run(["pkill", "-f", "cloudflared"], capture_output=True)
    env = dict(os.environ)
    env["TUNNEL_TOKEN"] = token
    shell('nohup cloudflared tunnel run --token "$TUNNEL_TOKEN" > /tmp/cloudflared-named.log 2>&1 &', env=env)
    time.sleep(8)
    print(open("/tmp/cloudflared-named.log").read()[-1500:], flush=True)
    print("固定地址：", public_url, flush=True)
    return public_url


def test_public(model, public_url):
    # 注意：Cloudflare 会拦 Python-urllib 默认 UA，必须加个浏览器 UA，否则 403
    headers = {"User-Agent": "Mozilla/5.0"}
    # 先在本地预热一次：第一次加载模型很慢，走公网会被 Cloudflare 100 秒超时拦成 524。
    try:
        print("本地预热一次 generate（不走 Cloudflare，等久一点没事）…", flush=True)
        req = urllib.request.Request(
            "http://localhost:11434/api/generate",
            data=json.dumps({
                "model": model, "prompt": "用一句话介绍新加坡，20字以内。",
                "stream": False, "think": False,
            }).encode(),
            headers={"Content-Type": "application/json"},
        )
        with urllib.request.urlopen(req, timeout=300) as r:
            print("本地 generate：", json.loads(r.read())["response"], flush=True)
    except Exception as e:
        print("本地预热失败（模型可能还在加载，公网自测继续）：", e, flush=True)
    time.sleep(2)
    try:
        print("自测 /api/tags：", flush=True)
        req = urllib.request.Request(f"{public_url}/api/tags", headers=headers)
        print(urllib.request.urlopen(req, timeout=20).read().decode()[:500], flush=True)
    except Exception as e:
        print("公网自测失败，等几秒再试：", e, flush=True)
        return
    try:
        req = urllib.request.Request(
            f"{public_url}/api/generate",
            data=json.dumps({
                "model": model, "prompt": "用一句话介绍新加坡，20字以内。",
                "stream": False, "think": False,
            }).encode(),
            headers={"Content-Type": "application/json", **headers},
        )
        with urllib.request.urlopen(req, timeout=180) as r:
            print("公网 generate：", json.loads(r.read())["response"], flush=True)
    except Exception as e:
        print("公网 generate 没回（常见是 524，Cloudflare 100 秒超时）：", e, flush=True)
        print("模型已在 /api/tags 里，热了之后再调就好，不用重跑脚本。", flush=True)


def stop_all():
    run(["pkill", "-f", "ollama serve"], capture_output=True)
    run(["pkill", "-f", "cloudflared"], capture_output=True)
    print("已停 Ollama 和 cloudflared", flush=True)


def main():
    parser = argparse.ArgumentParser(description="Kaggle + Ollama + 无审查 Qwen3-14B + Cloudflare Tunnel")
    parser.add_argument("--model", default=MODEL, help="要跑的模型名，默认 huihui_ai/qwen3-abliterated:14b")
    parser.add_argument("--tunnel", choices=["quick", "named"], default="quick",
                        help="quick=随机域名不用 token（默认），named=固定域名需 CLOUDFLARE_TUNNEL_TOKEN")
    parser.add_argument("--public-url", default=NAMED_URL,
                        help="Named Tunnel 的固定域名，默认 https://qwen.richyean.com，"
                             "新 tunnel 用 https://kaggle.richyean.com")
    parser.add_argument("--max-hours", type=float, default=MAX_RUNTIME_HOURS,
                        help="满多少小时自动停，默认 8（Kaggle 单次上限约 9 小时）")
    parser.add_argument("--no-test", action="store_true", help="跳过公网自测，只起服务和隧道")
    args = parser.parse_args()

    model = args.model
    start_time = time.time()
    print(f"选定模型：{model}（{MODEL_SIZE}）", flush=True)
    check_gpu()
    install_ollama()
    start_ollama()
    pull_if_missing(model)
    install_cloudflared()
    if args.tunnel == "named":
        public_url = start_named_tunnel(args.public_url)
    else:
        public_url = start_quick_tunnel()
    if not public_url:
        print("隧道没起来，Ollama 还在本地跑，先看上面日志。", flush=True)
        return
    if not args.no_test:
        test_public(model, public_url)
    print(f"完成。模型 {model} 已加载，公网地址：{public_url}", flush=True)
    print(f"这个 cell 会一直占着保活，{args.max_hours:g} 小时后自动停。", flush=True)
    print("提前停：在新 cell 里跑 touch /tmp/qwen-stop，或直接点 Stop。", flush=True)
    try:
        while (time.time() - start_time) / 3600 < args.max_hours:
            if os.path.exists(STOP_FILE):
                print("看到停机信号文件，正在停…", flush=True)
                break
            time.sleep(60)
    except KeyboardInterrupt:
        print("收到中断，正在停…", flush=True)
    print(f"已运行 {(time.time() - start_time) / 3600:.1f} 小时，到时间了，正在停…", flush=True)
    stop_all()


if __name__ == "__main__":
    main()
