"""Проверки прогона DeepSeek Harness без модели и без Docker: двойники 1С, Jira и GitHub отвечают на вопросы задач,
серверы MCP говорят по протоколу и ведут органайзер с памятью, прогонщик составляет просьбу, узнаёт вопрос, разбирает
события агента и пишет органайзер и действия в формате записи прогона.

    python -m unittest discover -s runners/dsh -p "test_*.py"
"""

from __future__ import annotations

import json
import sys
import tempfile
import threading
import unittest
import urllib.error
import urllib.request
from http.server import ThreadingHTTPServer
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))
sys.path.insert(0, str(Path(__file__).parent / "desk"))
import github  # noqa: E402
import jira  # noqa: E402
import onec  # noqa: E402
import run  # noqa: E402
import server  # noqa: E402

BASE = "http://base/trade/odata/standard.odata/"


def _get(twin_answer, url):
    status, _, body = twin_answer(url)
    return status, json.loads(body)


class OneC(unittest.TestCase):
    """Вопросы задач 8.01–8.04 по стандартному интерфейсу OData."""

    base = onec.OneCBase()

    def test_stock_balance_is_counted_from_movements(self):
        status, body = _get(self.base.answer, BASE + "AccumulationRegister_ТоварыНаСкладах/Balance(Condition='Номенклатура_Key eq guid"
                                                      "''a1000000-0000-0000-0000-000000000001'' and Склад_Key eq guid''50000000-0000-0000-0000-000000000001''')")
        self.assertEqual(200, status)
        self.assertEqual(18, body["value"][0]["КоличествоBalance"])

    def test_march_turnovers_and_sales(self):
        _, turnovers = _get(self.base.answer, BASE + "AccumulationRegister_ТоварыНаСкладах/Turnovers(StartPeriod=datetime'2024-03-01T00:00:00',"
                                                     "EndPeriod=datetime'2024-03-31T23:59:59')?$filter=Номенклатура_Key eq guid'a1000000-0000-0000-0000-000000000001'")
        self.assertEqual(22, turnovers["value"][0]["КоличествоРасход"])
        _, sales = _get(self.base.answer, BASE + "Document_РеализацияТоваровУслуг?$filter=Date ge datetime'2024-03-01T00:00:00' and "
                                                 "Date lt datetime'2024-04-01T00:00:00'&$select=Number,Контрагент_Key&$inlinecount=allpages")
        self.assertEqual(["c1000000-0000-0000-0000-000000000001", "c2000000-0000-0000-0000-000000000002"], [s["Контрагент_Key"] for s in sales["value"]])
        self.assertEqual("2", sales["odata.count"])

    def test_refusals_like_the_platform(self):
        self.assertEqual(404, _get(self.base.answer, BASE + "Catalog_Нет")[0])
        status, body = _get(self.base.answer, BASE + "Catalog_Контрагенты?$filter=Контрагент/ИНН eq '1'")
        self.assertEqual(400, status)
        self.assertIn("Переход по ссылке", body["odata.error"]["message"]["value"])
        self.assertEqual(400, _get(self.base.answer, BASE + "Catalog_Контрагенты?$filter=Нет eq 1")[0])

    def test_number_text_compares_as_number_and_functions(self):
        _, body = _get(self.base.answer, BASE + "Document_РеализацияТоваровУслуг?$filter=Number eq '000000001'&$select=Number")
        self.assertEqual(["000000001"], [x["Number"] for x in body["value"]])
        _, items = _get(self.base.answer, BASE + "Catalog_Номенклатура?$filter=substringof('щебень', Description)&$orderby=Description desc")
        self.assertEqual(["Щебень 5-20", "Щебень 20-40"], [x["Description"] for x in items["value"]])

    def test_metadata_lists_hundreds_of_sets(self):
        status, _, body = self.base.answer(BASE + "$metadata")
        self.assertEqual(200, status)
        self.assertEqual(186, body.count("<EntitySet "))


class Jira(unittest.TestCase):
    def test_deep_comment_last_comment_and_log_value(self):
        _, page = _get(jira.answer, "https://jira.example/rest/api/2/issue/DEV-7/comment?startAt=100&maxResults=50")
        self.assertEqual(130, page["total"])
        self.assertIn("45 секунд", page["comments"][16]["body"])
        self.assertEqual("Марина", page["comments"][-1]["author"]["displayName"])
        _, issue = _get(jira.answer, "https://jira.example/rest/api/2/issue/DEV-8")
        self.assertIn("gateway.timeout=38s", issue["fields"]["description"].split("\n")[1900])
        self.assertEqual(404, _get(jira.answer, "https://jira.example/rest/api/2/issue/DEV-9")[0])


class GitHub(unittest.TestCase):
    repository = github.Repository()

    def test_files_through_the_tool_come_decoded(self):
        desk = server.Desk(Path(tempfile.mkdtemp()), "Europe/Moscow", "github")
        prices = json.loads(desk.call("github", "api_get", {"path": "repos/acme/warehouse/contents/data/prices.csv"}).split("\n", 1)[1])
        self.assertIn("ART-03517;Гравий речной фракции 42;м3;7345", prices["text"])
        changelog = json.loads(desk.call("github", "api_get", {"path": "repos/acme/warehouse/contents/CHANGELOG.md"}).split("\n", 1)[1])
        self.assertEqual("Выпуск 9.14: добавлена выгрузка остатков в формате XLSX", changelog["text"].rstrip("\n").split("\n")[-1])
        deploy = json.loads(desk.call("github", "api_get", {"path": "repos/acme/warehouse/contents/infra/k8s/prod/deploy.yaml"}).split("\n", 1)[1])
        self.assertIn("replicas: 14", deploy["text"])

    def test_tree_and_routes(self):
        status, tree = _get(self.repository.answer, "https://api.github.com/repos/acme/warehouse/git/trees/main?recursive=1")
        self.assertEqual(200, status)
        self.assertIn("infra/k8s/prod/deploy.yaml", {x["path"] for x in tree["tree"]})
        self.assertEqual(404, _get(self.repository.answer, "https://api.github.com/repos/acme/warehouse/contents/nope.txt")[0])


class Mcp(unittest.TestCase):
    """Протокол MCP поверх HTTP: рукопожатие, перечень и вызов инструментов, состояние в файле."""

    def setUp(self):
        self.folder = Path(tempfile.mkdtemp())
        self.desk = server.Desk(self.folder, "Europe/Moscow", "onec")
        self.httpd = ThreadingHTTPServer(("127.0.0.1", 0), server.make_handler(self.desk))
        threading.Thread(target=self.httpd.serve_forever, daemon=True).start()
        self.url = f"http://127.0.0.1:{self.httpd.server_port}/mcp/"

    def tearDown(self):
        self.httpd.shutdown()
        self.httpd.server_close()

    def _post(self, server_name, message):
        request = urllib.request.Request(self.url + server_name, json.dumps(message).encode(), {"Content-Type": "application/json",
                                                                                                  "Accept": "application/json, text/event-stream"})
        with urllib.request.urlopen(request) as response:
            body = response.read()
            return response.status, dict(response.headers), json.loads(body) if body else None

    def _call(self, server_name, name, arguments):
        _, _, body = self._post(server_name, {"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": name, "arguments": arguments}})
        return body["result"]

    def test_handshake_and_tools(self):
        status, headers, body = self._post("memory", {"jsonrpc": "2.0", "id": 1, "method": "initialize",
                                                      "params": {"protocolVersion": "2099-01-01", "capabilities": {}, "clientInfo": {"name": "t"}}})
        self.assertEqual(200, status)
        self.assertEqual("2025-06-18", body["result"]["protocolVersion"])
        self.assertIn("Mcp-Session-Id", headers)
        self.assertEqual(202, self._post("memory", {"jsonrpc": "2.0", "method": "notifications/initialized"})[0])
        _, _, tools = self._post("organizer", {"jsonrpc": "2.0", "id": 2, "method": "tools/list"})
        self.assertIn("create_reminder", {t["name"] for t in tools["result"]["tools"]})
        _, _, onec_tools = self._post("onec", {"jsonrpc": "2.0", "id": 2, "method": "tools/list"})
        self.assertEqual(["odata_get"], [t["name"] for t in onec_tools["result"]["tools"]])
        with self.assertRaises(urllib.error.HTTPError) as missing:
            self._post("jira", {"jsonrpc": "2.0", "id": 2, "method": "tools/list"})
        self.assertEqual(404, missing.exception.code)
        _, _, unknown = self._post("memory", {"jsonrpc": "2.0", "id": 9, "method": "server/discover"})
        self.assertEqual(-32601, unknown["error"]["code"])

    def test_organizer_and_memory_go_to_the_state_file(self):
        self._call("memory", "remember", {"text": "Сестру зовут Аня"})
        self.assertIn("Сестру зовут Аня", self._call("memory", "recall", {})["content"][0]["text"])
        self._call("organizer", "create_reminder", {"text": "Встреча с подрядчиком", "at": "2027-01-20T14:00"})
        self._call("organizer", "create_reminder", {"text": "Выпить витамины", "at": "09:00", "repeat": "daily"})
        self._call("organizer", "create_board_task", {"title": "Проверить отчёт по смете", "due": "2027-01-23"})
        self._call("organizer", "create_note", {"title": "Идея по проекту", "text": "экспорт в PDF"})
        failed = self._call("organizer", "create_reminder", {"text": "x", "at": "завтра"})
        self.assertTrue(failed["isError"])
        state = run.organizer(self.folder / "state.json")
        self.assertEqual({"title": "Встреча с подрядчиком", "at_local": "2027-01-20T14:00", "local_time": "14:00", "recurring": False},
                         {k: state["reminders"][0][k] for k in ("title", "at_local", "local_time", "recurring")})
        self.assertEqual(("09:00", True), (state["reminders"][1]["local_time"], state["reminders"][1]["recurring"]))
        self.assertEqual("2027-01-23T00:00", state["board_tasks"][0]["due_local"])
        self.assertEqual([{"title": "Идея по проекту", "text": "экспорт в PDF"}], state["notes"])

    def test_system_answer_is_kept_for_the_judge(self):
        text = self._call("onec", "odata_get", {"path": "Catalog_Склады?$format=json"})["content"][0]["text"]
        self.assertTrue(text.startswith("HTTP 200\n"))
        recorded = run.actions([("mcp__onec__odata_get", '{"path": "Catalog_Склады"}'), ("bash", '{"command": "ls"}')], self.folder / "calls.jsonl")
        self.assertEqual(text, recorded[0]["result"])
        self.assertEqual(("shell", None), (recorded[1]["kind"], recorded[1].get("result")))


class Runner(unittest.TestCase):
    TASK = {"messages": [{"text": "Сделай", "attachments": [{"name": "a.pdf"}], "chat": "main"}], "bases": [("Договоры", [])],
            "my": [{"name": "x"}], "expects_question": False}

    def test_request_names_the_folders(self):
        self.assertEqual("Сделай\n\nВ рабочей папке: приложенные к этому сообщению файлы лежат в папке «Вложения»; документы базы знаний "
                         "«Договоры» лежат в папке «База знаний «Договоры»»; файлы хранилища человека лежат в папке «Мои файлы». "
                         "Готовые файлы сохраняй в рабочую папку.", run.request(self.TASK, self.TASK["messages"][0]))

    def test_reply_only_after_the_last_message_unless_prepared(self):
        task = {**self.TASK, "messages": [{}, {}]}
        self.assertEqual([None, run.DEFAULT_REPLY], [run.reply_after(task, 0), run.reply_after(task, 1)])
        self.assertIsNone(run.reply_after({**task, "expects_question": True}, 1))
        self.assertEqual("Подписывает директор", run.reply_after({**task, "reply_if_asked": "Подписывает директор"}, 0))

    def test_question_is_a_question_mark_without_new_documents(self):
        self.assertTrue(run.asked("Не хватает подписанта.\n\n**Кто подписывает письмо?**\n", {"a.docx": "1"}, {"a.docx": "1"}))
        self.assertFalse(run.asked("Готово. Подписать?", {}, {"a.docx": "1"}))
        self.assertFalse(run.asked("Готово.", {}, {}))

    def test_events_of_a_turn(self):
        events = "\n".join(json.dumps(e) for e in [
            {"type": "session", "sessionId": "s1"}, {"type": "tool_call", "tool": "bash", "input": {"command": "ls «Мои файлы»"}},
            {"type": "status", "phase": "step_end", "usage": {"inputTokens": 10, "outputTokens": 2}},
            {"type": "status", "phase": "turn_end", "reason": {"kind": "stop"}}, {"type": "final", "text": "Готово"}]) + "\nне JSON"
        step = run.read_events(events)
        self.assertEqual(("Готово", 1, 10, 2, "stop", "s1"), (step["answer"], step["calls"], step["prompt"], step["completion"], step["ended"], step["session"]))
        self.assertEqual([("bash", '{"command": "ls «Мои файлы»"}')], step["tools"])

    def test_patch_connects_the_task_servers(self):
        text = run.patch("http://gate:8000/v1", "m", "desk1", {"system": "jira"}, 64000, 8192)
        self.assertIn("url: http://desk1:8080/mcp/jira", text)
        self.assertIn("url: http://desk1:8080/mcp/memory", text)
        self.assertNotIn("/mcp/onec", text)

    def test_delivered_file_names_are_safe_and_unique(self):
        folder = Path(tempfile.mkdtemp())
        record = {"files": []}
        run.add_file(record, folder, "Отчёты/Итог: март.docx", b"1")
        run.add_file(record, folder, "Отчёты_Итог_ март.docx", b"2")
        self.assertEqual(["files/Отчёты_Итог_ март.docx", "files/Отчёты_Итог_ март (2).docx"], [f["path"] for f in record["files"]])

    def test_run_in_parts_keeps_the_first_start_and_all_tasks(self):
        root = Path(tempfile.mkdtemp())
        args = run.argparse.Namespace(model="qwen", image="dsh:1", context=64000, max_tokens=8192)
        self.assertIsNone(run.write_manifest(root, args, ["a", "b"]))
        first = json.loads((root / "run.json").read_text(encoding="utf-8"))["started"]
        self.assertIsNone(run.write_manifest(root, args, ["b", "c"]))
        manifest = json.loads((root / "run.json").read_text(encoding="utf-8"))
        self.assertEqual((first, ["a", "b", "c"]), (manifest["started"], manifest["tasks"]))

    def test_other_model_in_the_same_run_is_refused(self):
        root = Path(tempfile.mkdtemp())
        run.write_manifest(root, run.argparse.Namespace(model="qwen", image="dsh:1", context=64000, max_tokens=8192), ["a"])
        refusal = run.write_manifest(root, run.argparse.Namespace(model="other", image="dsh:1", context=64000, max_tokens=8192), ["b"])
        self.assertIn("новый прогон", refusal)
        self.assertEqual(["a"], json.loads((root / "run.json").read_text(encoding="utf-8"))["tasks"])


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