# Copyright (c) 2025-2026 马建军. All rights reserved.
# 专有软件 — 未经授权禁止复制、传播、转售。
# 严禁用于：带单/代客理财、向他人推荐期货品种或买卖建议、融资配资等业务。
# 详见 LICENSE.zh-CN.txt 与 docs/软件购买与使用协议.md

"""数据库备份：SQLite futures.db，含 uploads 与一键恢复脚本。"""
from __future__ import annotations

import json
import logging
import os
import re
import shutil
import sqlite3
import subprocess
import sys
import tarfile
import tempfile
import threading
import time
from datetime import datetime
from pathlib import Path
from typing import Any, Callable, IO, Optional
from zoneinfo import ZoneInfo

from modules.core.db_conn import DB_PATH

logger = logging.getLogger(__name__)

TZ = ZoneInfo("Asia/Shanghai")
BACKUP_FILENAME_RE = re.compile(r"^qihuo_backup_\d{8}_\d{6}\.tar\.gz$")
BACKUP_LAST_KEY = "backup_last_at"
BACKUP_KEEP_KEY = "backup_keep_count"
BACKUP_AUTO_KEY = "backup_auto_enabled"
BACKUP_HOUR_KEY = "backup_auto_hour"
DEFAULT_KEEP_COUNT = 30
DEFAULT_AUTO_HOUR = 3
CHECK_INTERVAL_SEC = 3600
_backup_lock = threading.Lock()
RESTORE_STATUS_FILE = "restore_status.json"
RESTORE_CONFIRM_TOKEN = "RESTORE"

RESTORE_MD = """# qihuo 备份恢复说明

本压缩包由 qihuo 系统自动生成，可在另一台 Linux 服务器上恢复交易数据。

## 包内文件

| 文件/目录 | 说明 |
|-----------|------|
| `futures.db` | SQLite 主库 |
| `uploads/` | 复盘截图与 K 线图（若备份时存在） |
| `.env` | 环境配置（`config/.env` 或根目录 `.env`） |
| `manifest.json` | 备份元数据 |
| `restore.sh` | 一键恢复脚本 |

## 快速恢复（推荐）

1. 将本压缩包上传到目标服务器（例如 `/root/`）
2. 解压并执行恢复脚本：

```bash
cd /root
tar -xzf qihuo_backup_YYYYMMDD_HHMMSS.tar.gz
cd qihuo_backup_YYYYMMDD_HHMMSS
chmod +x restore.sh
./restore.sh
```

默认恢复到 **`/root/qihuo`**。指定应用目录：

```bash
RESTORE_DIR=/opt/qihuo ./restore.sh
```

3. 在新服务器部署 qihuo 代码与 Python 环境（见 `docs/DEPLOY.md`）
4. 若包内含 `.env`，`restore.sh` 会自动恢复到应用目录（无需手工复制）
5. 重启服务：`pm2 restart qihuo`

## 手工恢复

```bash
mkdir -p /opt/qihuo/uploads
cp futures.db /opt/qihuo/futures.db
cp -a uploads/. /opt/qihuo/uploads/
```

## 注意

- 恢复前请停止 qihuo 进程
- `.env` 含敏感信息，请妥善保管备份包
- 详见 `docs/BACKUP.md`
"""


def _app_root() -> Path:
    from modules.core.paths import ROOT
    return ROOT


def default_backup_dir() -> str:
    env = (os.getenv("QIHUO_BACKUP_DIR") or "").strip()
    if env:
        return env
    if os.name == "nt":
        return str(_app_root() / "qihuo_backup")
    return "/root/qihuo_backup"


def default_restore_dir() -> str:
    env = (os.getenv("QIHUO_RESTORE_DIR") or "").strip()
    if env:
        return env
    if os.name == "nt":
        return str(_app_root())
    return "/root/qihuo"


def restore_target_dir() -> Path:
    """Web/API 恢复目标目录，默认当前应用根目录。"""
    env = (os.getenv("QIHUO_RESTORE_DIR") or "").strip()
    if env:
        return Path(env)
    return _app_root()


def backup_dir() -> Path:
    path = Path(default_backup_dir())
    path.mkdir(parents=True, exist_ok=True)
    return path


def backup_in_progress() -> bool:
    return _backup_lock.locked()


def _restore_status_path() -> Path:
    from modules.core.paths import DATA_DIR

    DATA_DIR.mkdir(parents=True, exist_ok=True)
    return DATA_DIR / RESTORE_STATUS_FILE


def _write_restore_status(state: str, message: str = "", **extra: Any) -> None:
    payload = {
        "state": state,
        "message": message,
        "updated_at": datetime.now(TZ).isoformat(timespec="seconds"),
    }
    payload.update(extra)
    _restore_status_path().write_text(
        json.dumps(payload, ensure_ascii=False, indent=2),
        encoding="utf-8",
    )


def get_restore_status() -> dict:
    path = _restore_status_path()
    if not path.is_file():
        return {"state": "idle", "message": "", "updated_at": ""}
    try:
        data = json.loads(path.read_text(encoding="utf-8"))
        if isinstance(data, dict):
            data.setdefault("state", "idle")
            data.setdefault("message", "")
            return data
    except Exception:
        pass
    return {"state": "idle", "message": "", "updated_at": ""}


def restore_in_progress() -> bool:
    return get_restore_status().get("state") in ("pending", "running")


def _manifest_root_prefix(tar: tarfile.TarFile) -> str:
    for member in tar.getmembers():
        name = member.name.rstrip("/")
        if name.endswith("/manifest.json") or name == "manifest.json":
            if name == "manifest.json":
                return ""
            return name[: -len("/manifest.json")]
    raise ValueError("备份包缺少 manifest.json")


def _read_manifest_from_tar(tar: tarfile.TarFile) -> dict:
    root = _manifest_root_prefix(tar)
    manifest_name = f"{root}/manifest.json" if root else "manifest.json"
    try:
        member = tar.getmember(manifest_name)
    except KeyError as exc:
        raise ValueError("备份包缺少 manifest.json") from exc
    extracted = tar.extractfile(member)
    if not extracted:
        raise ValueError("无法读取 manifest.json")
    data = json.loads(extracted.read().decode("utf-8"))
    if not isinstance(data, dict):
        raise ValueError("manifest.json 格式无效")
    return data


def _validate_manifest(manifest: dict) -> None:
    if manifest.get("app") != "qihuo":
        raise ValueError("不是有效的 qihuo 备份包")
    backend = (manifest.get("backend") or "sqlite").strip()
    if backend == "postgres":
        raise ValueError("不再支持 PostgreSQL 备份，请使用 SQLite 备份包")
    if backend != "sqlite":
        raise ValueError("manifest 缺少或无效的数据库类型")


def _member_exists(tar: tarfile.TarFile, root: str, name: str) -> bool:
    candidates = [name]
    if root:
        candidates.append(f"{root}/{name}")
    return any(_tar_has_member(tar, path) for path in candidates)


def _tar_has_member(tar: tarfile.TarFile, path: str) -> bool:
    try:
        tar.getmember(path)
        return True
    except KeyError:
        return False


def _validate_archive_contents(tar: tarfile.TarFile, root: str) -> None:
    if not _member_exists(tar, root, "futures.db"):
        raise ValueError("备份缺少 futures.db")


def _manifest_preview(manifest: dict, path: Path) -> dict:
    stat = path.stat()
    created_at = (manifest.get("created_at") or "").strip()
    return {
        "name": path.name,
        "created_at": created_at,
        "includes_uploads": bool(manifest.get("includes_uploads")),
        "includes_env": bool(manifest.get("includes_env")),
        "env_restore_path": (manifest.get("env_restore_path") or "").strip(),
        "size": stat.st_size,
        "size_mb": round(stat.st_size / (1024 * 1024), 2),
        "mtime": datetime.fromtimestamp(stat.st_mtime, TZ).isoformat(timespec="seconds"),
    }


def peek_manifest(path: Path) -> dict:
    with tarfile.open(path, "r:gz") as tar:
        return _read_manifest_from_tar(tar)


def inspect_backup_archive(path: Path) -> dict:
    with tarfile.open(path, "r:gz") as tar:
        manifest = _read_manifest_from_tar(tar)
        _validate_manifest(manifest)
        root = _manifest_root_prefix(tar)
        _validate_archive_contents(tar, root)
        return _manifest_preview(manifest, path)


def _allocate_backup_filename(manifest: dict, preferred: str = "") -> str:
    preferred = (preferred or "").strip()
    if preferred and BACKUP_FILENAME_RE.match(preferred):
        candidate = backup_dir() / preferred
        if not candidate.exists():
            return preferred
    created = (manifest.get("created_at") or "").strip()
    stamp = ""
    if created:
        try:
            stamp = datetime.fromisoformat(created).strftime("%Y%m%d_%H%M%S")
        except ValueError:
            stamp = ""
    if not stamp:
        stamp = datetime.now(TZ).strftime("%Y%m%d_%H%M%S")
    name = f"qihuo_backup_{stamp}.tar.gz"
    if not (backup_dir() / name).exists():
        return name
    stamp = datetime.now(TZ).strftime("%Y%m%d_%H%M%S")
    return f"qihuo_backup_{stamp}.tar.gz"


def save_uploaded_backup(stream: IO[bytes], original_filename: str = "") -> tuple[str, dict]:
    with tempfile.NamedTemporaryFile(delete=False, suffix=".tar.gz") as tmp:
        shutil.copyfileobj(stream, tmp)
        tmp_path = Path(tmp.name)
    try:
        info = inspect_backup_archive(tmp_path)
        manifest = peek_manifest(tmp_path)
        filename = _allocate_backup_filename(manifest, original_filename)
        dest = backup_dir() / filename
        shutil.move(str(tmp_path), str(dest))
        info["name"] = filename
        return filename, info
    except Exception:
        tmp_path.unlink(missing_ok=True)
        raise


def _pm2_available() -> bool:
    return shutil.which("pm2") is not None


def _pm2_stop() -> None:
    if not _pm2_available():
        logger.warning("pm2 not found, skip stop")
        return
    proc = subprocess.run(
        ["pm2", "stop", "qihuo"],
        capture_output=True,
        text=True,
        check=False,
    )
    if proc.returncode != 0:
        logger.warning("pm2 stop qihuo: %s", proc.stderr.strip() or proc.stdout.strip())


def _pm2_restart() -> None:
    if not _pm2_available():
        logger.warning("pm2 not found, skip restart")
        return
    proc = subprocess.run(
        ["pm2", "restart", "qihuo"],
        capture_output=True,
        text=True,
        check=False,
    )
    if proc.returncode != 0:
        proc = subprocess.run(
            ["pm2", "start", "qihuo"],
            capture_output=True,
            text=True,
            check=False,
        )
    if proc.returncode != 0:
        raise RuntimeError(proc.stderr.strip() or proc.stdout.strip() or "pm2 restart 失败")


def _extract_member_to_path(tar: tarfile.TarFile, member_name: str, dest: Path) -> None:
    try:
        member = tar.getmember(member_name)
    except KeyError:
        return
    extracted = tar.extractfile(member)
    if not extracted:
        return
    dest.parent.mkdir(parents=True, exist_ok=True)
    with open(dest, "wb") as out:
        shutil.copyfileobj(extracted, out)


def _restore_uploads_dir(tar: tarfile.TarFile, root: str, restore_dir: Path) -> None:
    prefix = f"{root}/uploads" if root else "uploads"
    uploads_dest = restore_dir / "uploads"
    uploads_dest.mkdir(parents=True, exist_ok=True)
    found = False
    for member in tar.getmembers():
        if member.name == prefix or member.name.startswith(prefix + "/"):
            found = True
            rel = member.name[len(prefix) :].lstrip("/")
            if not rel:
                continue
            target = uploads_dest / rel
            if member.isdir():
                target.mkdir(parents=True, exist_ok=True)
            else:
                target.parent.mkdir(parents=True, exist_ok=True)
                extracted = tar.extractfile(member)
                if extracted:
                    with open(target, "wb") as out:
                        shutil.copyfileobj(extracted, out)
    if not found:
        logger.info("backup has no uploads/")


def _reload_env_file(env_path: Path) -> None:
    if not env_path.is_file():
        return
    try:
        from dotenv import load_dotenv

        load_dotenv(str(env_path), override=True)
    except Exception as exc:
        logger.warning("reload .env failed: %s", exc)


def _perform_restore(archive_path: Path, restore_dir: Path) -> dict:
    restore_dir.mkdir(parents=True, exist_ok=True)
    with tarfile.open(archive_path, "r:gz") as tar:
        manifest = _read_manifest_from_tar(tar)
        _validate_manifest(manifest)
        root = _manifest_root_prefix(tar)
        _validate_archive_contents(tar, root)

        env_member = f"{root}/.env" if root else ".env"
        env_restore_path = (manifest.get("env_restore_path") or "config/.env").strip()
        if manifest.get("includes_env") and _tar_has_member(tar, env_member):
            env_dest = restore_dir / env_restore_path
            _extract_member_to_path(tar, env_member, env_dest)
            _reload_env_file(env_dest)

        db_member = f"{root}/futures.db" if root else "futures.db"
        db_dest = Path(DB_PATH)
        if not db_dest.is_absolute():
            db_dest = restore_dir / db_dest.name
        _extract_member_to_path(tar, db_member, db_dest)
        _restore_uploads_dir(tar, root, restore_dir)

    return {
        "restore_dir": str(restore_dir),
        "includes_env": bool(manifest.get("includes_env")),
        "includes_uploads": bool(manifest.get("includes_uploads")),
    }


def run_restore_job(archive_path: Path) -> None:
    filename = archive_path.name
    restore_dir = restore_target_dir()
    try:
        _write_restore_status(
            "running",
            "正在停止服务…",
            filename=filename,
            step="stop",
            restore_dir=str(restore_dir),
        )
        _pm2_stop()

        _write_restore_status(
            "running",
            "正在恢复数据…",
            filename=filename,
            step="restore",
            restore_dir=str(restore_dir),
        )
        summary = _perform_restore(archive_path.resolve(), restore_dir)

        _write_restore_status(
            "running",
            "正在重启服务…",
            filename=filename,
            step="restart",
            restore_dir=str(restore_dir),
        )
        _pm2_restart()

        _write_restore_status(
            "done",
            "恢复完成，服务已重启",
            filename=filename,
            restore_dir=str(restore_dir),
            summary=summary,
        )
    except Exception as exc:
        logger.exception("restore failed: %s", exc)
        _write_restore_status(
            "error",
            str(exc),
            filename=filename,
            restore_dir=str(restore_dir),
        )
        try:
            _pm2_restart()
        except Exception as restart_exc:
            logger.warning("restart after restore error: %s", restart_exc)


def schedule_restore(filename: str) -> tuple[bool, str]:
    if _backup_lock.locked():
        return False, "备份进行中，请稍后再试"
    if restore_in_progress():
        return False, "恢复进行中，请稍后再试"
    try:
        path = resolve_backup_file(filename)
        inspect_backup_archive(path)
    except (ValueError, FileNotFoundError) as exc:
        return False, str(exc)

    _write_restore_status(
        "pending",
        "恢复任务已提交…",
        filename=filename,
        restore_dir=str(restore_target_dir()),
    )
    script = Path(__file__).resolve().parent / "restore_job.py"
    subprocess.Popen(
        [sys.executable, str(script), str(path.resolve())],
        start_new_session=True,
        cwd=str(_app_root()),
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL,
    )
    return True, "恢复已开始，服务将短暂中断后自动重启"


def get_backup_last_at(get_setting: Callable[[str, str], str]) -> str:
    return (get_setting(BACKUP_LAST_KEY, "") or "").strip()


def _backup_sqlite(src_path: str, dst_path: str) -> None:
    src = sqlite3.connect(src_path, timeout=30)
    try:
        try:
            src.execute("PRAGMA wal_checkpoint(TRUNCATE)")
        except sqlite3.OperationalError:
            pass
        dst = sqlite3.connect(dst_path)
        try:
            src.backup(dst)
            dst.commit()
        finally:
            dst.close()
    finally:
        src.close()


def _env_backup_info() -> tuple[Optional[Path], str]:
    """返回 (源 .env 路径, 恢复到应用目录的相对路径)。"""
    from modules.core.paths import CONFIG_DIR, ENV_FILE, LEGACY_ENV_FILE

    if ENV_FILE.is_file():
        return ENV_FILE, "config/.env"
    if LEGACY_ENV_FILE.is_file():
        return LEGACY_ENV_FILE, ".env"
    return None, "config/.env"


def _copy_env_into_backup(work: Path) -> tuple[bool, str]:
    env_src, env_restore_path = _env_backup_info()
    if env_src and env_src.is_file():
        shutil.copy2(env_src, work / ".env")
        return True, env_restore_path
    return False, env_restore_path


def _write_restore_script(dest: Path, *, env_restore_path: str = "") -> None:
    env_block = ""
    if env_restore_path:
        env_block = f"""
if [ -f "$SCRIPT_DIR/.env" ]; then
  ENV_DEST="$RESTORE_DIR/{env_restore_path}"
  mkdir -p "$(dirname "$ENV_DEST")"
  cp -f "$SCRIPT_DIR/.env" "$ENV_DEST"
  echo "已复制 .env -> $ENV_DEST"
fi
"""
    script = f"""#!/bin/bash
set -euo pipefail
RESTORE_DIR="${{RESTORE_DIR:-{default_restore_dir()}}}"
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
mkdir -p "$RESTORE_DIR/uploads"
{env_block}
if [ -f "$SCRIPT_DIR/futures.db" ]; then
  cp -f "$SCRIPT_DIR/futures.db" "$RESTORE_DIR/futures.db"
  echo "已复制 futures.db -> $RESTORE_DIR/futures.db"
fi
if [ -d "$SCRIPT_DIR/uploads" ]; then
  cp -a "$SCRIPT_DIR/uploads/." "$RESTORE_DIR/uploads/"
  echo "已复制 uploads -> $RESTORE_DIR/uploads/"
fi
echo ""
echo "恢复完成。目标目录: $RESTORE_DIR"
echo "下一步: pm2 restart qihuo"
echo "详见 RESTORE.md 与 docs/BACKUP.md"
"""
    dest.write_text(script, encoding="utf-8")


def create_backup(*, include_uploads: bool = True, include_env: bool = True) -> tuple[str, str]:
    """创建 tar.gz 备份，返回 (文件名, 说明)。"""
    if not os.path.isfile(DB_PATH):
        raise FileNotFoundError(f"数据库不存在: {DB_PATH}")

    with _backup_lock:
        stamp = datetime.now(TZ).strftime("%Y%m%d_%H%M%S")
        folder_name = f"qihuo_backup_{stamp}"
        filename = f"{folder_name}.tar.gz"
        out_path = backup_dir() / filename
        app_root = _app_root()
        upload_src = app_root / "uploads"

        with tempfile.TemporaryDirectory(prefix="qihuo_bak_") as tmp:
            work = Path(tmp) / folder_name
            work.mkdir()
            _backup_sqlite(DB_PATH, str(work / "futures.db"))

            if include_uploads and upload_src.is_dir():
                shutil.copytree(upload_src, work / "uploads", dirs_exist_ok=True)

            includes_env = False
            env_restore_path = "config/.env"
            if include_env:
                includes_env, env_restore_path = _copy_env_into_backup(work)
                if not includes_env:
                    logger.warning("backup: .env not found (checked config/.env and root .env)")

            manifest = {
                "app": "qihuo",
                "backend": "sqlite",
                "created_at": datetime.now(TZ).isoformat(timespec="seconds"),
                "db_path": DB_PATH,
                "includes_uploads": include_uploads and upload_src.is_dir(),
                "includes_env": includes_env,
                "env_restore_path": env_restore_path if includes_env else "",
                "default_restore_dir": default_restore_dir(),
                "files": sorted(p.name for p in work.iterdir()),
            }
            (work / "manifest.json").write_text(
                json.dumps(manifest, ensure_ascii=False, indent=2),
                encoding="utf-8",
            )
            (work / "RESTORE.md").write_text(RESTORE_MD, encoding="utf-8")
            _write_restore_script(
                work / "restore.sh",
                env_restore_path=env_restore_path if includes_env else "",
            )

            with tarfile.open(out_path, "w:gz") as tar:
                tar.add(work, arcname=folder_name)

        size_mb = out_path.stat().st_size / (1024 * 1024)
        env_note = "含 .env" if includes_env else "未含 .env"
        return filename, f"备份已生成 {filename}（{size_mb:.2f} MB，{env_note}）"


def list_backups(*, with_manifest: bool = True) -> list[dict]:
    items: list[dict] = []
    for path in sorted(backup_dir().glob("qihuo_backup_*.tar.gz"), reverse=True):
        if not BACKUP_FILENAME_RE.match(path.name):
            continue
        stat = path.stat()
        item = {
            "name": path.name,
            "size": stat.st_size,
            "size_mb": round(stat.st_size / (1024 * 1024), 2),
            "mtime": datetime.fromtimestamp(stat.st_mtime, TZ).isoformat(timespec="seconds"),
            "created_at": "",
            "includes_env": False,
            "includes_uploads": False,
        }
        if with_manifest:
            try:
                manifest = peek_manifest(path)
                item["created_at"] = (manifest.get("created_at") or "").strip()
                item["includes_env"] = bool(manifest.get("includes_env"))
                item["includes_uploads"] = bool(manifest.get("includes_uploads"))
            except Exception as exc:
                logger.debug("read manifest %s: %s", path.name, exc)
        items.append(item)
    return items


def resolve_backup_file(filename: str) -> Path:
    name = (filename or "").strip()
    if not BACKUP_FILENAME_RE.match(name):
        raise ValueError("无效的备份文件名")
    path = (backup_dir() / name).resolve()
    root = backup_dir().resolve()
    if not str(path).startswith(str(root) + os.sep) and path != root:
        raise ValueError("无效的备份路径")
    if not path.is_file():
        raise FileNotFoundError("备份文件不存在")
    return path


def prune_old_backups(keep: int) -> int:
    keep_n = max(1, int(keep or DEFAULT_KEEP_COUNT))
    files = list_backups()
    removed = 0
    for item in files[keep_n:]:
        try:
            resolve_backup_file(item["name"]).unlink()
            removed += 1
        except Exception as exc:
            logger.warning("prune backup %s: %s", item["name"], exc)
    return removed


def run_backup_job(
    *,
    get_setting: Callable[[str, str], str],
    set_setting: Callable[[str, str], None],
    include_uploads: bool = True,
    include_env: bool = True,
) -> tuple[str, str]:
    keep = DEFAULT_KEEP_COUNT
    try:
        keep = max(5, min(200, int(get_setting(BACKUP_KEEP_KEY, str(DEFAULT_KEEP_COUNT)) or DEFAULT_KEEP_COUNT)))
    except ValueError:
        pass
    filename, msg = create_backup(include_uploads=include_uploads, include_env=include_env)
    set_setting(BACKUP_LAST_KEY, datetime.now(TZ).isoformat(timespec="seconds"))
    removed = prune_old_backups(keep)
    if removed:
        msg = f"{msg}，已清理 {removed} 个旧备份"
    return filename, msg


def schedule_backup(
    *,
    get_setting: Callable[[str, str], str],
    set_setting: Callable[[str, str], None],
    include_uploads: bool = True,
    include_env: bool = True,
) -> tuple[bool, str]:
    if _backup_lock.locked():
        return False, "备份进行中，请稍后再试"
    if restore_in_progress():
        return False, "恢复进行中，请稍后再试"

    def _run() -> None:
        try:
            run_backup_job(
                get_setting=get_setting,
                set_setting=set_setting,
                include_uploads=include_uploads,
                include_env=include_env,
            )
        except Exception as exc:
            logger.exception("backup failed: %s", exc)

    threading.Thread(target=_run, daemon=True, name="qihuo-backup-run").start()
    return True, "已在后台开始备份，请稍后刷新本页查看"


def _should_auto_backup(get_setting: Callable[[str, str], str]) -> bool:
    if (get_setting(BACKUP_AUTO_KEY, "1") or "1").strip() not in ("1", "true", "yes"):
        return False
    try:
        hour = int(get_setting(BACKUP_HOUR_KEY, str(DEFAULT_AUTO_HOUR)) or DEFAULT_AUTO_HOUR)
    except ValueError:
        hour = DEFAULT_AUTO_HOUR
    hour = max(0, min(23, hour))
    now = datetime.now(TZ)
    if now.hour != hour:
        return False
    last = get_backup_last_at(get_setting)
    if last and last[:10] == now.date().isoformat():
        return False
    return True


def start_backup_worker(
    *,
    get_setting_fn: Callable[[str, str], str],
    set_setting_fn: Callable[[str, str], None],
    interval: int = CHECK_INTERVAL_SEC,
) -> None:
    """后台线程：按设定小时每日自动备份。"""

    def _loop() -> None:
        time.sleep(30)
        while True:
            try:
                if _should_auto_backup(get_setting_fn):
                    filename, msg = run_backup_job(
                        get_setting=get_setting_fn,
                        set_setting=set_setting_fn,
                        include_uploads=True,
                        include_env=True,
                    )
                    logger.info("auto backup: %s — %s", filename, msg)
            except Exception as exc:
                logger.warning("backup worker: %s", exc)
            time.sleep(max(300, interval))

    threading.Thread(target=_loop, daemon=True, name="qihuo-backup-worker").start()