"""
demo.py —— 自适应日志解析系统：自愈闭环演示

演示整条自愈流程（全流程自动化）：
  初始系统只认基础 JSON 日志 →
  遇到没见过的新格式 → 解析【失败】被检测到 →
  把失败样本 + 报错交给 Agent → Agent【生成解析代码】→
  【自动测试】（数据结构断言）→ 通过后【热加载注册 + 持久化】→
  系统【正确解析】了新格式。

运行：
  python demo.py            # 完整演示（两种新格式，两次 Agent 调用，需 API Key）
  python demo.py --offline  # 离线演示：用预置解析器跑完整机制，无需 API Key
  python demo.py --quick    # 快速模式：只演示 1 种新格式，省一次 API 调用
  python demo.py --help     # 查看全部参数

命令行参数见文件底部的 build_arg_parser()。
"""

from __future__ import annotations

import argparse
import json
import os
import textwrap
from typing import List, Tuple

from engine import LogParserEngine, ParseError, builtin_json_parser
from agent import CodeGenAgent, OfflineCodeGenAgent
from tester import run_tests

HERE = os.path.dirname(os.path.abspath(__file__))
PARSERS_DIR = os.path.join(HERE, "parsers")

MAX_ATTEMPTS = 3  # Agent 生成→测试的最大迭代修复次数


# ---------------------------------------------------------------------------
# 演示用的三种递进日志格式
# ---------------------------------------------------------------------------
# 格式 1：基础 JSON 行 —— 初始系统就支持
JSON_LOGS = [
    '{"timestamp": "2026-07-17T10:22:31Z", "level": "INFO", "message": "Agent started task planning"}',
    '{"timestamp": "2026-07-17T10:22:33Z", "level": "DEBUG", "message": "Loaded 12 tools into context"}',
]

# 格式 2：自定义竖线分隔格式 —— Agent 没见过
#   时间戳|级别|模块|step=N|消息
PIPE_LOGS = [
    "2026-07-17T10:23:01Z|INFO|agent.planner|step=3|Generated plan with 5 actions",
    "2026-07-17T10:23:04Z|WARNING|agent.executor|step=4|Tool call retried once",
    "2026-07-17T10:23:07Z|ERROR|agent.executor|step=5|Tool web_search returned empty result",
]
PIPE_REQUIRED = ["timestamp", "level", "module", "step", "message"]

# 格式 3：嵌套括号格式 —— Agent 也没见过
#   [时间] (级别) <tool=名字> {k=v k=v} :: 消息
BRACKET_LOGS = [
    "[2026-07-17 10:24:55] (ERROR) <tool=web_search> {latency_ms=812 status=timeout} :: upstream request failed",
    "[2026-07-17 10:25:01] (INFO) <tool=code_run> {latency_ms=134 status=ok} :: executed snippet successfully",
    "[2026-07-17 10:25:09] (WARN) <tool=file_read> {latency_ms=45 status=partial} :: file truncated at 1MB",
]
BRACKET_REQUIRED = ["timestamp", "level", "tool", "message"]


# ---------------------------------------------------------------------------
# 小工具
# ---------------------------------------------------------------------------
def hr(title: str = "") -> None:
    print("\n" + "=" * 78)
    if title:
        print(title)
        print("=" * 78)


def try_parse_all(
    engine: LogParserEngine, logs: List[str]
) -> Tuple[bool, List[dict]]:
    """尝试解析一批日志，打印结果；返回 (是否全部成功, 成功解析出的结构化记录列表)。"""
    all_ok = True
    records: List[dict] = []
    for line in logs:
        try:
            result = engine.parse_line(line)
            records.append(result)
            print(f"  ✅ [{result['_parser']}] {result}")
        except ParseError:
            all_ok = False
            print(f"  ❌ 解析失败：{line}")
    return all_ok, records


def read_log_file(path: str) -> List[str]:
    """从外部日志文件读取日志（每行一条，忽略空行）。"""
    with open(path, "r", encoding="utf-8") as f:
        return [line.rstrip("\n") for line in f if line.strip()]


def write_output(path: str, records: List[dict]) -> None:
    """把解析出的结构化记录写成 JSONL（每行一条 JSON）。"""
    with open(path, "w", encoding="utf-8") as f:
        for rec in records:
            f.write(json.dumps(rec, ensure_ascii=False) + "\n")


# ---------------------------------------------------------------------------
# 自愈闭环：检测失败 → 生成 → 测试 → 热更新
# ---------------------------------------------------------------------------
def self_heal(
    engine: LogParserEngine,
    agent: "CodeGenAgent | OfflineCodeGenAgent",
    parser_name: str,
    samples: List[str],
    required_keys: List[str],
) -> bool:
    """针对一种新格式跑完整的自愈闭环，成功注册返回 True。"""
    # (a) 触发原因：拿一条样本让系统解析，确认确实失败
    failing_line = samples[0]
    try:
        engine.parse_line(failing_line)
        print("  （该格式已能解析，无需自愈）")
        return True
    except ParseError as exc:
        error_report = str(exc)
        print(f"  🔎 检测到无法解析的新格式，触发自愈。报错：{error_report}")

    target_path = os.path.join(PARSERS_DIR, f"{parser_name}.py")
    feedback = None

    for attempt in range(1, MAX_ATTEMPTS + 1):
        print(f"\n  --- 第 {attempt}/{MAX_ATTEMPTS} 次：Agent 生成解析代码 ---")
        code = agent.generate_parser_code(
            samples=samples,
            required_keys=required_keys,
            error_report=error_report,
            feedback=feedback,
        )
        print(textwrap.indent(code, "    | "))

        # 写入候选文件（parsers/），再热加载
        with open(target_path, "w", encoding="utf-8") as f:
            f.write(code)

        # 热加载生成的 parse 函数
        try:
            fn = LogParserEngine.load_parser_from_file(target_path)
        except Exception as exc:
            feedback = f"代码无法导入/执行：{type(exc).__name__}: {exc}"
            print(f"  ⚠️ 热加载失败：{feedback}")
            continue

        # (b) 自动测试：数据结构断言
        print("  🧪 自动测试（数据结构断言）：")
        test = run_tests(fn, samples, required_keys)
        print(textwrap.indent(test["report"], "    "))

        if test["passed"]:
            # (c) 通过 → 热更新注册进引擎，文件已持久化到 parsers/
            engine.register(parser_name, fn)
            print(f"  ✅ 自动测试通过，已热更新注册解析器 '{parser_name}' 并持久化到 parsers/{parser_name}.py")
            return True

        feedback = "自动测试未通过，失败详情如下：\n" + test["report"]
        print("  ↻ 测试未通过，把失败报告反馈给 Agent 重试。")

    # 全部尝试失败：删除无效文件
    if os.path.exists(target_path):
        os.remove(target_path)
    print(f"  ❌ {MAX_ATTEMPTS} 次尝试后仍未通过，放弃该格式。")
    return False


# ---------------------------------------------------------------------------
# 主流程
# ---------------------------------------------------------------------------
def main(args: argparse.Namespace) -> None:
    hr("自适应日志解析系统 —— 自愈闭环演示（实验 5-7）")
    print("初始系统只内置一个基础解析器：JSON 行解析器。")
    if args.quick:
        print("（--quick 快速模式：仅演示 1 种新格式，省一次 Agent/API 调用）")
    if args.offline:
        print("（--offline 离线模式：用预置解析器代替 OpenAI，无需 API Key，机制完全一致）")

    os.makedirs(PARSERS_DIR, exist_ok=True)  # 确保持久化目录存在（新克隆时可能只有 .gitkeep）

    engine = LogParserEngine()
    engine.register("builtin_json", builtin_json_parser)
    print(f"当前已注册解析器：{engine.parser_names}")

    # model=None 时回落到 MODEL 环境变量/默认 gpt-5.6-luna；离线模式不触碰 API
    agent = OfflineCodeGenAgent(args.model) if args.offline else CodeGenAgent(model=args.model)
    print(f"代码生成 Agent 使用模型：{agent.model}")

    # 步骤 0：基础 JSON 格式，系统本来就能解析
    hr("步骤 0：解析基础 JSON 日志（系统原生支持）")
    try_parse_all(engine, JSON_LOGS)

    # 步骤 1：自定义竖线分隔格式（Agent 没见过）
    hr("步骤 1：遇到新格式 A —— 自定义竖线分隔格式")
    print("原始日志样本：")
    for l in PIPE_LOGS:
        print(f"  {l}")
    print("\n(a) 先让系统解析，预期【失败】：")
    try_parse_all(engine, PIPE_LOGS)
    print("\n触发自愈闭环：")
    ok1 = self_heal(engine, agent, "pipe_parser", PIPE_LOGS, PIPE_REQUIRED)
    if ok1:
        print("\n(c) 热更新后重新解析同样的日志，预期【成功】：")
        try_parse_all(engine, PIPE_LOGS)

    # 步骤 2：嵌套括号格式（Agent 也没见过）—— 快速模式下跳过，省一次 API 调用
    ok2 = None
    if args.quick:
        hr("步骤 2：（--quick 模式已跳过新格式 B 的演示）")
    else:
        hr("步骤 2：遇到新格式 B —— 嵌套括号格式")
        print("原始日志样本：")
        for l in BRACKET_LOGS:
            print(f"  {l}")
        print("\n(a) 先让系统解析，预期【失败】：")
        try_parse_all(engine, BRACKET_LOGS)
        print("\n触发自愈闭环：")
        ok2 = self_heal(engine, agent, "bracket_parser", BRACKET_LOGS, BRACKET_REQUIRED)
        if ok2:
            print("\n(c) 热更新后重新解析同样的日志，预期【成功】：")
            try_parse_all(engine, BRACKET_LOGS)

    # 步骤 3：验证持久化复用 —— 新引擎直接加载 parsers/，无需再问 Agent
    hr("步骤 3：验证持久化复用（重启系统，直接加载已学会的解析器）")
    engine2 = LogParserEngine()
    engine2.register("builtin_json", builtin_json_parser)
    loaded = engine2.load_persisted(PARSERS_DIR)
    print(f"新引擎从 parsers/ 热加载了：{loaded}")
    if args.log_file:
        print(f"用学到的解析系统解析外部日志文件（不再调用 Agent）：{args.log_file}")
        mixed = read_log_file(args.log_file)
    else:
        print("直接解析之前的新格式（不再调用 Agent）：")
        mixed = [JSON_LOGS[0], PIPE_LOGS[0]]
        if not args.quick:
            mixed.append(BRACKET_LOGS[0])  # 快速模式没生成 bracket_parser，混合样本里也不放它
    all_ok, records = try_parse_all(engine2, mixed)

    if args.output:
        write_output(args.output, records)
        print(f"已将 {len(records)} 条结构化解析结果写入（JSONL）：{args.output}")

    hr("演示结束")
    print(f"新格式 A（竖线分隔）自愈结果：{'成功' if ok1 else '失败'}")
    if ok2 is None:
        print("新格式 B（嵌套括号）：--quick 模式已跳过")
    else:
        print(f"新格式 B（嵌套括号）自愈结果：{'成功' if ok2 else '失败'}")
    print(f"持久化复用（混合格式全部解析）：{'成功' if all_ok else '失败'}")
    print(f"已学会并持久化的解析器目录：{PARSERS_DIR}")


def build_arg_parser() -> argparse.ArgumentParser:
    """构造命令行参数解析器（提供 --help / --quick / --model）。"""
    parser = argparse.ArgumentParser(
        description="自适应日志解析系统：自愈闭环演示（检测失败 → Agent 生成解析代码 → "
        "自动测试 → 热加载注册 → 持久化复用）。默认走 OpenAI，需 OPENAI_API_KEY；"
        "加 --offline 用预置解析器演示同一套机制，无需 API Key。",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument(
        "--offline",
        action="store_true",
        help="离线模式：用预置（canned）解析器代码代替调用 OpenAI，无需 API Key，"
        "确定性地演示“失败检测→生成→测试→热重载→持久化”整条机制。",
    )
    parser.add_argument(
        "--quick",
        action="store_true",
        help="快速模式：只演示 1 种新格式（竖线分隔），跳过嵌套括号格式，省一次 Agent/API 调用。",
    )
    parser.add_argument(
        "--model",
        default=None,
        help="覆盖代码生成使用的模型；默认读取环境变量 MODEL，再回落到 gpt-5.6-luna。"
        "（--offline 下此项仅作展示，不影响预置解析器。）",
    )
    parser.add_argument(
        "--log-file",
        default=None,
        metavar="PATH",
        help="外部日志文件路径（每行一条日志）。给定后，步骤 3 改用学到的解析系统解析"
        "该文件，替代内置混合样本；用于验证学到的解析器可复用到真实日志流。",
    )
    parser.add_argument(
        "--output",
        default=None,
        metavar="PATH",
        help="把步骤 3 解析出的结构化结果以 JSONL（每行一条 JSON）写入该文件。",
    )
    return parser


if __name__ == "__main__":
    main(build_arg_parser().parse_args())