"""任务间互发消息服务端单测：POST /tasks/<id>/messages 与
GET /tasks/<id>/messages。

不跑真实模型、不联网：本地临时端口 + 临时 SQLite，与
test_task_links.py 同款骨架。覆盖鉴权、权限、校验、三种
投递结果（排队 / 复活 / 拒绝）与发出列表。
"""

import http.client
import json
import os
import sqlite3
import sys
import tempfile
import threading
import unittest
from pathlib import Path

try:
    from cloud.auth import AuthStore
    from cloud.server import create_server
except ImportError:  # discover -s cloud/tests 时把项目根目录补进 sys.path
    sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
    from cloud.auth import AuthStore
    from cloud.server import create_server


class PeerMessageServerTestCase(unittest.TestCase):
    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory()
        self.db_path = os.path.join(self.tmp.name, "control.db")
        self.auth = AuthStore(self.db_path)
        self.owner_id, self.owner_key = self.auth.create_user("owner")
        self.outsider_id, self.outsider_key = self.auth.create_user("outsider")
        self.server = create_server(self.db_path, "127.0.0.1", 0)
        self.port = self.server.server_address[1]
        self.thread = threading.Thread(
            target=self.server.serve_forever, daemon=True)
        self.thread.start()
        self.trace_dir = os.path.join(self.tmp.name, "host-traces")
        os.makedirs(self.trace_dir, exist_ok=True)
        self.server.trace_dir = self.trace_dir
        status, self.project = self._req(
            "POST", "/projects", {"name": "demo"}, self.owner_key)
        self.assertEqual(status, 201)
        status, self.project2 = self._req(
            "POST", "/projects", {"name": "other"}, self.owner_key)
        self.assertEqual(status, 201)

    def tearDown(self):
        self.server.shutdown()
        self.server.server_close()
        self.thread.join(timeout=5)
        try:
            self.auth.conn.close()
        except Exception:
            pass
        self.tmp.cleanup()

    def _req(self, method, path, body=None, key=None):
        conn = http.client.HTTPConnection(
            "127.0.0.1", self.port, timeout=10)
        hdrs = {}
        payload = None
        if body is not None:
            payload = json.dumps(body).encode("utf-8")
            hdrs["Content-Type"] = "application/json"
        if key is not None:
            hdrs["X-API-Key"] = key
        try:
            conn.request(method, path, body=payload, headers=hdrs)
            resp = conn.getresponse()
            data = resp.read()
        finally:
            conn.close()
        try:
            parsed = json.loads(data.decode("utf-8")) if data else None
        except ValueError:
            parsed = None
        return resp.status, parsed

    def _create_task(self, project_id, **extra):
        body = {"project_id": project_id, "prompt": "做事"}
        body.update(extra)
        status, task = self._req("POST", "/tasks", body, self.owner_key)
        self.assertEqual(status, 201, task)
        return task

    def _set_status(self, task_id, status):
        conn = sqlite3.connect(self.db_path)
        try:
            conn.execute("UPDATE tasks SET status = ? WHERE id = ?",
                         (status, task_id))
            conn.commit()
        finally:
            conn.close()

    def _task_row(self, task_id):
        conn = sqlite3.connect(self.db_path)
        try:
            return conn.execute(
                "SELECT status, resume_message FROM tasks WHERE id = ?",
                (task_id,)).fetchone()
        finally:
            conn.close()

    def _followups(self, task_id):
        _status, body = self._req(
            "GET", "/tasks/%s/followups" % task_id, None, self.owner_key)
        return body["followups"]

    def test_delivered_to_running_target(self):
        sender = self._create_task(self.project["id"])
        target = self._create_task(self.project["id"])
        self._set_status(target["id"], "running")
        status, body = self._req(
            "POST", "/tasks/%s/messages" % target["id"],
            {"from_task_id": sender["id"], "body": "请评审"},
            self.owner_key)
        self.assertEqual(status, 201, body)
        self.assertEqual(body["delivery"], "delivered")
        self.assertIsNotNone(body["followup_id"])
        fus = self._followups(target["id"])
        self.assertEqual(len(fus), 1)
        self.assertEqual(fus[0]["body"], "请评审")
        self.assertEqual(fus[0]["sender_task_id"], sender["id"])
        self.assertEqual(fus[0]["status"], "pending")

    def test_revived_completed_target(self):
        sender = self._create_task(self.project["id"])
        target = self._create_task(self.project["id"])
        self._set_status(target["id"], "completed")
        status, body = self._req(
            "POST", "/tasks/%s/messages" % target["id"],
            {"from_task_id": sender["id"], "body": "回来一下"},
            self.owner_key)
        self.assertEqual(status, 201, body)
        self.assertEqual(body["delivery"], "revived")
        self.assertIsNone(body["followup_id"])
        row = self._task_row(target["id"])
        self.assertEqual(row[0], "queued")
        self.assertIn("回来一下", row[1])
        self.assertIn(sender["id"], row[1])

    def test_direct_mode_writes_trace(self):
        sender = self._create_task(self.project["id"])
        target = self._create_task(self.project["id"])
        self._set_status(target["id"], "running")
        status, body = self._req(
            "POST", "/tasks/%s/messages" % target["id"],
            {"from_task_id": sender["id"], "body": "急事",
             "mode": "direct"},
            self.owner_key)
        self.assertEqual(status, 201, body)
        self.assertEqual(body["delivery"], "delivered")
        names = os.listdir(self.trace_dir)
        self.assertEqual(len(names), 1)
        with open(os.path.join(self.trace_dir, names[0]),
                  encoding="utf-8") as f:
            entry = json.loads(f.read().strip())
        self.assertEqual(entry["phase"], "followup-direct")
        self.assertIn("急事", entry["text"])
        self.assertIn(sender["id"], entry["text"])

    def test_validation_and_not_found(self):
        sender = self._create_task(self.project["id"])
        target = self._create_task(self.project["id"])
        base = "/tasks/%s/messages" % target["id"]
        status, _ = self._req("POST", base, {"body": "x"}, self.owner_key)
        self.assertEqual(status, 400)
        status, _ = self._req(
            "POST", base, {"from_task_id": sender["id"]}, self.owner_key)
        self.assertEqual(status, 400)
        status, _ = self._req(
            "POST", base,
            {"from_task_id": sender["id"], "body": "x", "mode": "smoke"},
            self.owner_key)
        self.assertEqual(status, 400)
        status, _ = self._req(
            "POST", base, {"from_task_id": "nope", "body": "x"},
            self.owner_key)
        self.assertEqual(status, 404)
        status, _ = self._req(
            "POST", "/tasks/nope/messages",
            {"from_task_id": sender["id"], "body": "x"}, self.owner_key)
        self.assertEqual(status, 404)
        status, _ = self._req(
            "POST", base, {"from_task_id": sender["id"], "body": "x"},
            None)
        self.assertEqual(status, 401)

    def test_forbidden_for_outsider(self):
        sender = self._create_task(self.project["id"])
        target = self._create_task(self.project["id"])
        status, _ = self._req(
            "POST", "/tasks/%s/messages" % target["id"],
            {"from_task_id": sender["id"], "body": "x"}, self.outsider_key)
        self.assertEqual(status, 403)

    def test_cross_project_rejected(self):
        sender = self._create_task(self.project["id"])
        target = self._create_task(self.project2["id"])
        self._set_status(target["id"], "running")
        status, body = self._req(
            "POST", "/tasks/%s/messages" % target["id"],
            {"from_task_id": sender["id"], "body": "x"}, self.owner_key)
        self.assertEqual(status, 409, body)
        self.assertIn("cross-project", body["error"])

    def test_self_and_goal_rejected(self):
        task = self._create_task(self.project["id"])
        self._set_status(task["id"], "running")
        status, body = self._req(
            "POST", "/tasks/%s/messages" % task["id"],
            {"from_task_id": task["id"], "body": "x"}, self.owner_key)
        self.assertEqual(status, 409)
        goal = self._create_task(self.project["id"],
                                 verify_command="true")
        self._set_status(goal["id"], "running")
        sender = self._create_task(self.project["id"])
        status, _ = self._req(
            "POST", "/tasks/%s/messages" % goal["id"],
            {"from_task_id": sender["id"], "body": "x"}, self.owner_key)
        self.assertEqual(status, 409)

    def test_list_outgoing_messages(self):
        sender = self._create_task(self.project["id"])
        target = self._create_task(self.project["id"])
        self._set_status(target["id"], "running")
        status, _ = self._req(
            "POST", "/tasks/%s/messages" % target["id"],
            {"from_task_id": sender["id"], "body": "请评审"},
            self.owner_key)
        self.assertEqual(status, 201)
        status, body = self._req(
            "GET", "/tasks/%s/messages" % sender["id"], None, self.owner_key)
        self.assertEqual(status, 200)
        self.assertEqual(len(body["messages"]), 1)
        self.assertEqual(body["messages"][0]["task_id"], target["id"])
        self.assertEqual(body["messages"][0]["sender_task_id"], sender["id"])
        status, body = self._req(
            "GET", "/tasks/%s/messages" % sender["id"], None,
            self.outsider_key)
        self.assertEqual(status, 403)


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