"""client.py 单测（CI 第二阶段覆盖率：基线 0%）。

不跑真实 codex 二进制：AppServer 只跟子进程的 stdin/stdout
说话，本文件用真实 os.pipe 作 stdout 通道（select + os.read
原样走）、BytesIO 作 stdin——JSON-RPC 成帧、审批自动回包、
wait_for 事件分发、initialize/close 都是被测代码的真实逻辑，
只把“子进程是 codex”换成管道。main() 的分支用一个记录型
FakeAppServer 测（断言它发出的请求参数与分支选择）。
"""

import io
import json
import os
import sys
import tempfile
import types
import unittest
from contextlib import redirect_stdout, redirect_stderr
from pathlib import Path
from unittest import mock

REPO_ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO_ROOT))

import client as client_mod


class FakeProc:
    """Popen 替身：stdout 是真实 pipe（可 select/os.read），
    stdin 是 BytesIO（可断言发出的每一行）。"""

    def __init__(self, chunks, wait_exc=None):
        self.r, self.w = os.pipe()
        for chunk in chunks:
            os.write(self.w, chunk)
        os.close(self.w)
        self.stdin = io.BytesIO()
        self.stdout = types.SimpleNamespace(fileno=lambda: self.r)
        self._wait_exc = wait_exc
        self.waited = False
        self.killed = False

    def poll(self):
        return None

    def wait(self, timeout=None):
        self.waited = True
        if self._wait_exc is not None:
            raise self._wait_exc
        return 0

    def kill(self):
        self.killed = True

    def close_fds(self):
        try:
            os.close(self.r)
        except OSError:
            pass


def _line(obj):
    return (json.dumps(obj) + "\n").encode()


class AppServerPipeTest(unittest.TestCase):
    def _server(self, chunks, codex_home=None, wait_exc=None):
        proc = FakeProc(chunks, wait_exc=wait_exc)
        self.addCleanup(proc.close_fds)
        with mock.patch.object(client_mod.subprocess, "Popen",
                               return_value=proc):
            srv = client_mod.AppServer(codex_home=codex_home)
        srv._proc = proc
        return srv, proc

    def test_request_and_notify_framing(self):
        srv, proc = self._server([])
        rid = srv.request("thread/list", {"a": 1})
        self.assertEqual(rid, 1)
        srv.notify("initialized", {})
        self.assertEqual(srv.next_id, 2)
        lines = proc.stdin.getvalue().decode().splitlines()
        self.assertEqual(json.loads(lines[0]),
                         {"jsonrpc": "2.0", "id": 1, "method": "thread/list",
                          "params": {"a": 1}})
        self.assertEqual(json.loads(lines[1]),
                         {"jsonrpc": "2.0", "method": "initialized",
                          "params": {}})

    def test_read_msg_answers_approval_then_returns_response(self):
        chunks = [_line({"jsonrpc": "2.0", "id": 9,
                         "method": "approval/request",
                         "params": {"x": 1}}),
                  _line({"jsonrpc": "2.0", "id": 1, "result": {"ok": True}})]
        srv, proc = self._server(chunks)
        srv.approval_policy = "deny"
        msg = srv._read_msg(5)
        self.assertEqual(msg, {"jsonrpc": "2.0", "id": 1,
                               "result": {"ok": True}})
        sent = proc.stdin.getvalue().decode().splitlines()
        self.assertEqual(json.loads(sent[0]),
                         {"jsonrpc": "2.0", "id": 9,
                          "result": {"decision": "deny"}})

    def test_read_msg_approval_auto(self):
        chunks = [_line({"jsonrpc": "2.0", "id": 7,
                         "method": "permission/request", "params": {}}),
                  _line({"jsonrpc": "2.0", "id": 1, "result": {}})]
        srv, proc = self._server(chunks)
        srv.approval_policy = "auto"
        with redirect_stderr(io.StringIO()):
            msg = srv._read_msg(5)
        self.assertEqual(msg["id"], 1)
        sent = proc.stdin.getvalue().decode().splitlines()
        self.assertEqual(json.loads(sent[0])["result"],
                         {"decision": "approve"})

    def test_wait_for_dispatches_events(self):
        chunks = [_line({"jsonrpc": "2.0", "method": "agent/message/delta",
                         "params": {"item": {"type": "agentMessage",
                                             "text": "hi"}}}),
                  _line({"jsonrpc": "2.0", "id": 3, "result": {"done": 1}})]
        srv, _ = self._server(chunks)
        seen = []
        msg = srv.wait_for(3, timeout=5, on_event=seen.append)
        self.assertEqual(msg["result"], {"done": 1})
        self.assertEqual(len(seen), 1)
        self.assertEqual(seen[0]["method"], "agent/message/delta")

    def test_wait_for_eof_returns_none(self):
        srv, _ = self._server([])
        self.assertIsNone(srv.wait_for(1, timeout=5))

    def test_initialize_success_and_error(self):
        chunks = [_line({"jsonrpc": "2.0", "id": 1,
                         "result": {"codexHome": "/tmp/ch",
                                    "platformOs": "linux"}})]
        srv, proc = self._server(chunks)
        info = srv.initialize()
        self.assertEqual(info["platformOs"], "linux")
        sent = proc.stdin.getvalue().decode().splitlines()
        self.assertEqual(json.loads(sent[0])["method"], "initialize")
        self.assertEqual(json.loads(sent[1])["method"], "initialized")

        srv2, _ = self._server(
            [_line({"jsonrpc": "2.0", "id": 1,
                    "error": {"code": -1, "message": "boom"}})])
        with self.assertRaises(RuntimeError):
            srv2.initialize()

    def test_codex_home_created(self):
        with tempfile.TemporaryDirectory() as tmp:
            home = os.path.join(tmp, "new-home")
            srv, proc = self._server([], codex_home=home)
            self.assertTrue(os.path.isdir(home))
            self.assertEqual(proc.stdin.getvalue(), b"")

    def test_close_waits_and_kills_on_timeout(self):
        srv, proc = self._server([])
        srv.close()
        self.assertTrue(proc.waited)
        self.assertFalse(proc.killed)
        import subprocess as _sp
        srv2, proc2 = self._server(
            [], wait_exc=_sp.TimeoutExpired("codex", 5))
        srv2.close()
        self.assertTrue(proc2.killed)


class HandleEventTest(unittest.TestCase):
    def test_agent_delta_printed(self):
        out = io.StringIO()
        with redirect_stdout(out):
            client_mod.handle_event(
                {"method": "agent/message/delta",
                 "params": {"item": {"type": "agentMessage",
                                     "text": "hello"}}})
        self.assertEqual(out.getvalue(), "hello")

    def test_turn_completed_and_error_paths(self):
        out, err = io.StringIO(), io.StringIO()
        with redirect_stdout(out), redirect_stderr(err):
            client_mod.handle_event(
                {"method": "turn/completed",
                 "params": {"status": "completed"}})
            # 首分支元组外、含 started 的方法走 stderr 分支。
            client_mod.handle_event(
                {"method": "session/started", "params": {}})
            client_mod.handle_event(
                {"method": "something", "params": {"error": "x"}})
        self.assertIn("[turn/completed]", out.getvalue())
        self.assertIn("[session/started]", err.getvalue())
        self.assertIn("[something]", err.getvalue())


class FakeAppServer:
    def __init__(self, codex_home=None, extra_args=None):
        self.codex_home = codex_home
        self.approval_policy = "deny"
        self.requests = []
        self.notifies = []
        self.responses = {}
        self.read_msgs = []
        self.closed = False

    def request(self, method, params=None):
        rid = len(self.requests) + 1
        self.requests.append((method, params))
        return rid

    def notify(self, method, params=None):
        self.notifies.append((method, params))

    def wait_for(self, rid, timeout=60, on_event=None):
        return self.responses.get(rid)

    def _read_msg(self, timeout):
        return self.read_msgs.pop(0) if self.read_msgs else None

    def initialize(self):
        return {"codexHome": "/tmp/ch", "platformOs": "linux"}

    def close(self):
        self.closed = True


class ClientMainTest(unittest.TestCase):
    def _run(self, argv, setup):
        fake = FakeAppServer()
        setup(fake)
        err = io.StringIO()
        with mock.patch.object(client_mod, "AppServer",
                               return_value=fake), \
                mock.patch.object(sys, "argv", argv), \
                redirect_stderr(err):
            out = io.StringIO()
            with redirect_stdout(out):
                client_mod.main()
        return fake, out.getvalue(), err.getvalue()

    def test_list_threads(self):
        def setup(fake):
            fake.responses[1] = {"result": {"threads": []}}
        fake, out, _ = self._run(
            ["client.py", "--list-threads", "--cwd", "/tmp"],
            setup)
        self.assertEqual(fake.requests[0][0], "thread/list")
        self.assertIn("threads", out)
        self.assertTrue(fake.closed)

    def test_start_and_turn_completed(self):
        def setup(fake):
            fake.responses[1] = {"result": {"thread": {"id": "th-9"},
                                            "model": "m"}}
            fake.read_msgs.append(
                {"method": "turn/completed", "params": {"ok": True}})
        fake, out, _ = self._run(
            ["client.py", "--prompt", "fix it", "--cwd", "/tmp",
             "--model", "gpt-x", "--sandbox", "read-only",
             "--approval-policy", "never"],
            setup)
        start = fake.requests[0]
        self.assertEqual(start[0], "thread/start")
        self.assertEqual(start[1]["approvalPolicy"], "never")
        self.assertEqual(start[1]["sandbox"], "read-only")
        self.assertEqual(start[1]["model"], "gpt-x")
        turn = fake.requests[1]
        self.assertEqual(turn[0], "turn/start")
        self.assertEqual(turn[1]["threadId"], "th-9")
        self.assertEqual(turn[1]["input"][0]["text"], "fix it")
        self.assertIn("[done]", out)
        self.assertTrue(fake.closed)

    def test_resume_failure_prints_and_returns(self):
        def setup(fake):
            fake.responses[1] = {"error": {"message": "gone"}}
        fake, out, err = self._run(
            ["client.py", "--thread-id", "th-1", "--cwd", "/tmp"],
            setup)
        self.assertEqual(fake.requests[0][0], "thread/resume")
        self.assertIn("thread/resume", err)
        self.assertTrue(fake.closed)

    def test_no_prompt_prints_thread_id(self):
        def setup(fake):
            fake.responses[1] = {"result": {"thread": {"id": "th-2"}}}
        _, out, _ = self._run(
            ["client.py", "--cwd", "/tmp"], setup)
        self.assertIn("thread_id=th-2", out)


if __name__ == "__main__":
    unittest.main()