#!/usr/bin/env python3
"""Interactive, comment-preserving editor for MAA Online daily.toml."""

from __future__ import annotations

import argparse
import json
import os
import re
import shutil
import subprocess
import tempfile
import tomllib
from datetime import datetime
from pathlib import Path
from typing import Any

ROOT = Path(os.getenv("MAA_ONLINE_ROOT", Path(__file__).resolve().parents[1]))
DEFAULT_FILE = Path(os.getenv("MAA_ONLINE_CONFIG_FILE", Path(__file__).with_name("daily.toml")))
MAA_DRY_RUN = [
    str(ROOT / "bin/maa-online"),
    "run",
    "daily",
    "--dry-run",
    "--batch",
]
KEY_RE = re.compile(r"^(?P<indent>\s*)(?P<key>[A-Za-z0-9_]+)(?P<space>\s*=\s*)(?P<value>.*?)(?P<newline>\r?\n)?$")


def toml_literal(value: Any) -> str:
    if isinstance(value, bool):
        return "true" if value else "false"
    if isinstance(value, str):
        return json.dumps(value, ensure_ascii=False)
    if isinstance(value, int):
        return str(value)
    if isinstance(value, float):
        return repr(value)
    if isinstance(value, list):
        return "[" + ", ".join(toml_literal(item) for item in value) + "]"
    if isinstance(value, dict):
        pairs = [f"{toml_literal(str(key))} = {toml_literal(item)}" for key, item in value.items()]
        return "{ " + ", ".join(pairs) + " }"
    raise TypeError(f"不支持的值类型：{type(value).__name__}")


def parse_value(raw: str, current: Any) -> Any:
    text = raw.strip()
    if isinstance(current, bool):
        aliases = {
            "true": True, "yes": True, "y": True, "1": True, "是": True, "开": True,
            "false": False, "no": False, "n": False, "0": False, "否": False, "关": False,
        }
        value = aliases.get(text.lower())
        if value is None:
            raise ValueError("布尔值请输入 true/false、yes/no、是/否或开/关")
        return value

    if isinstance(current, str) and not text.startswith(('"', "'")):
        return text

    if isinstance(current, list) and not text.startswith("["):
        parts = [part.strip() for part in text.split(",") if part.strip()]
        if not parts:
            return []
        sample = current[0] if current else ""
        if isinstance(sample, int):
            return [int(part) for part in parts]
        return parts

    try:
        return tomllib.loads("value = " + text)["value"]
    except (tomllib.TOMLDecodeError, KeyError) as exc:
        raise ValueError(f"无法解析 TOML 值：{exc}") from exc


def same_kind(current: Any, value: Any) -> bool:
    if isinstance(current, bool):
        return isinstance(value, bool)
    if isinstance(current, int) and not isinstance(current, bool):
        return isinstance(value, int) and not isinstance(value, bool)
    if isinstance(current, float):
        return isinstance(value, (int, float)) and not isinstance(value, bool)
    return isinstance(value, type(current))


class ConfigEditor:
    def __init__(self, path: Path, maa_validate: bool = True):
        self.path = path.resolve()
        self.maa_validate = maa_validate and self.path == DEFAULT_FILE.resolve()
        self.original_text = self.path.read_text(encoding="utf-8")
        self.text = self.original_text

    def data(self) -> dict[str, Any]:
        return tomllib.loads(self.text)

    def sections(self) -> list[tuple[str, int | None, dict[str, Any]]]:
        data = self.data()
        global_values = {key: value for key, value in data.items() if key != "tasks"}
        result: list[tuple[str, int | None, dict[str, Any]]] = [("全局", None, global_values)]
        for index, task in enumerate(data.get("tasks", [])):
            label = f"{task.get('name', task.get('type', '任务'))} [{task.get('type', '?')}]"
            result.append((label, index, task.get("params", {})))
        return result

    def replace(self, task_index: int | None, key: str, value: Any) -> None:
        lines = self.text.splitlines(keepends=True)
        current_task = -1
        in_params = False
        for index, line in enumerate(lines):
            stripped = line.strip()
            if stripped == "[[tasks]]":
                current_task += 1
                in_params = False
                continue
            if stripped == "[tasks.params]":
                in_params = True
                continue
            if stripped.startswith("[") and stripped.endswith("]"):
                in_params = False

            matches_section = current_task == -1 if task_index is None else current_task == task_index and in_params
            if not matches_section:
                continue
            match = KEY_RE.match(line)
            if not match or match.group("key") != key:
                continue
            newline = match.group("newline") or ""
            lines[index] = f"{match.group('indent')}{key}{match.group('space')}{toml_literal(value)}{newline}"
            self.text = "".join(lines)
            self.data()  # 再次解析，确保生成结果仍是合法 TOML。
            return
        raise KeyError(f"找不到配置项：{key}")

    def save(self) -> Path:
        self.data()
        backup_dir = self.path.parent / "backups"
        backup_dir.mkdir(exist_ok=True)
        stamp = datetime.now().strftime("%Y%m%d%H%M%S")
        backup = backup_dir / f"{self.path.name}.{stamp}.bak"
        suffix = 1
        while backup.exists():
            backup = backup_dir / f"{self.path.name}.{stamp}.{suffix}.bak"
            suffix += 1
        shutil.copy2(self.path, backup)

        mode = self.path.stat().st_mode & 0o777
        fd, temp_name = tempfile.mkstemp(prefix=f".{self.path.name}.", dir=self.path.parent)
        try:
            with os.fdopen(fd, "w", encoding="utf-8", newline="") as handle:
                handle.write(self.text)
                handle.flush()
                os.fsync(handle.fileno())
            os.chmod(temp_name, mode)
            os.replace(temp_name, self.path)
        except Exception:
            Path(temp_name).unlink(missing_ok=True)
            raise

        if self.maa_validate:
            result = subprocess.run(MAA_DRY_RUN, text=True, capture_output=True, timeout=120)
            if result.returncode != 0:
                shutil.copy2(backup, self.path)
                detail = (result.stderr or result.stdout).strip()
                raise RuntimeError(f"MAA dry-run 失败，已自动回滚：\n{detail}")
            print(result.stdout.strip())

        self.original_text = self.text
        return backup

    @property
    def changed(self) -> bool:
        return self.text != self.original_text


def edit_section(editor: ConfigEditor, task_index: int | None, label: str) -> None:
    while True:
        section = next(values for section_label, index, values in editor.sections() if section_label == label and index == task_index)
        keys = list(section)
        print(f"\n=== {label} ===")
        for number, key in enumerate(keys, 1):
            print(f"{number:2}. {key} = {toml_literal(section[key])}")
        print(" b. 返回")
        choice = input("选择配置项：").strip().lower()
        if choice in {"b", "back", "返回", ""}:
            return
        try:
            key = keys[int(choice) - 1]
        except (ValueError, IndexError):
            print("无效选择。")
            continue

        current = section[key]
        print(f"当前值：{toml_literal(current)}")
        raw = input("新值（直接回车取消；列表可用逗号分隔）：")
        if not raw.strip():
            continue
        try:
            value = parse_value(raw, current)
            if not same_kind(current, value):
                raise ValueError(f"类型不匹配，需要 {type(current).__name__}")
            editor.replace(task_index, key, value)
            print(f"已暂存：{key} = {toml_literal(value)}")
        except (KeyError, TypeError, ValueError) as exc:
            print(f"修改失败：{exc}")


def interactive(editor: ConfigEditor) -> int:
    while True:
        print("\n=== MAA Online TOML 配置编辑器 ===")
        for number, (label, _, _) in enumerate(editor.sections(), 1):
            print(f"{number:2}. {label}")
        print(" s. 保存并验证" + (" *" if editor.changed else ""))
        print(" q. 退出")
        choice = input("请选择：").strip().lower()
        if choice in {"q", "quit", "退出"}:
            if editor.changed:
                confirm = input("存在未保存修改，确认丢弃？[y/N] ").strip().lower()
                if confirm not in {"y", "yes", "是"}:
                    continue
            return 0
        if choice in {"s", "save", "保存"}:
            if not editor.changed:
                print("没有需要保存的修改。")
                continue
            try:
                backup = editor.save()
                print(f"保存成功；备份：{backup}")
            except Exception as exc:
                print(f"保存失败：{exc}")
            continue
        try:
            label, task_index, _ = editor.sections()[int(choice) - 1]
        except (ValueError, IndexError):
            print("无效选择。")
            continue
        edit_section(editor, task_index, label)


def main() -> int:
    parser = argparse.ArgumentParser(description="交互式编辑 MAA Online TOML 配置")
    parser.add_argument("--file", type=Path, default=DEFAULT_FILE, help="要编辑的 TOML 文件")
    parser.add_argument("--no-maa-validate", action="store_true", help="保存时不运行 MAA dry-run")
    args = parser.parse_args()
    if not args.file.is_file():
        parser.error(f"配置文件不存在：{args.file}")
    editor = ConfigEditor(args.file, maa_validate=not args.no_maa_validate)
    try:
        return interactive(editor)
    except (EOFError, KeyboardInterrupt):
        print("\n已取消，未保存的修改不会写入文件。")
        return 130


if __name__ == "__main__":
    raise SystemExit(main())