# -*- coding: utf-8 -*-
"""修 Json.java 的深度计数 bug —— 它让"功能页永远连不上"。

我加 MAX_DEPTH 时只在 readObject/readArray 里做了 depth++，
**没有对应的 depth--**。于是 depth 单调递增：
一个回复里只要累计解析过 65 个对象（不是嵌套深度，是总数！）就抛
"JSON 嵌套太深"。

而 RemoteClient.readLoop 里对解析失败是 `continue`（静默丢弃），
所以客户端等不到回复，一路超时到报"连不上电脑"。

受影响的面：
    feature_list   152 个功能对象   -> 永远超时（用户报的"功能页连不上"）
    proc_list      200 个进程对象   -> 超时
    audio_list     音乐目录多文件   -> 超时
    voice_list / ping / info        -> 对象少，正常

修法：把真正的解析逻辑拆成 inner 方法，用 try/finally 保证进出配对。
"""
from __future__ import annotations

import sys
from pathlib import Path

JSON = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote\android\src"
            r"\com\lanremote\watch\Json.java")


def main() -> int:
    text = JSON.read_text(encoding="utf-8")

    # ---- readObject：拆成 wrapper + inner ----
    old_obj = "        private Map<String, Object> readObject() {"
    new_obj = '''        private Map<String, Object> readObject() {
            if (depth >= MAX_DEPTH) {
                throw new IllegalArgumentException("JSON 嵌套太深");
            }
            depth++;
            try {
                return readObjectInner();
            } finally {
                // 必须配对减去！只加不减会让计数器单调递增，
                // 于是"回复里有 65 个对象"就被误判成嵌套太深，
                // 而调用方会静默丢弃这条回复 -> 表现为"连不上电脑"。
                depth--;
            }
        }

        private Map<String, Object> readObjectInner() {'''
    if old_obj not in text:
        print("  [失败] 找不到 readObject")
        return 1
    text = text.replace(old_obj, new_obj, 1)
    print("  readObject: 已拆成 wrapper + inner")

    # readObjectInner 里那个 depth++ 要去掉（已经挪到 wrapper）
    marker = "            pos++;                       // '{'\n            depth++;\n"
    if marker in text:
        text = text.replace(marker,
                            "            pos++;                       // '{'\n", 1)
        print("  readObjectInner: 去掉多余的 depth++")

    # ---- readArray 同样处理 ----
    old_arr = "        private List<Object> readArray() {"
    new_arr = '''        private List<Object> readArray() {
            if (depth >= MAX_DEPTH) {
                throw new IllegalArgumentException("JSON 嵌套太深");
            }
            depth++;
            try {
                return readArrayInner();
            } finally {
                depth--;
            }
        }

        private List<Object> readArrayInner() {'''
    if old_arr not in text:
        print("  [失败] 找不到 readArray")
        return 1
    text = text.replace(old_arr, new_arr, 1)
    print("  readArray: 已拆成 wrapper + inner")

    marker2 = "            pos++;                       // '['\n            depth++;\n"
    if marker2 in text:
        text = text.replace(marker2,
                            "            pos++;                       // '['\n", 1)
        print("  readArrayInner: 去掉多余的 depth++")

    # ---- readValue 里那个检查可以保留（wrapper 里已经查得更严）----
    JSON.write_text(text, encoding="utf-8")

    # 检查有没有残留的裸 depth++
    lines = text.splitlines()
    stray = [i + 1 for i, l in enumerate(lines)
             if l.strip() == "depth++;" and "try {" not in lines[i - 1]]
    print(f"  残留的裸 depth++: {stray if stray else '无'}")

    print()
    count_inc = text.count("depth++;")
    count_dec = text.count("depth--;")
    print(f"  depth++ 出现 {count_inc} 次，depth-- 出现 {count_dec} 次")
    print(f"  {'配对正确' if count_inc == count_dec else '!! 不配对，还有问题'}")
    return 0 if count_inc == count_dec else 1


if __name__ == "__main__":
    sys.exit(main())