from __future__ import annotations

import json
import tempfile
import unittest
from pathlib import Path

from core import JourneyValidationError, render_template, run_until_input, validate_journey
from database import Database


ROOT = Path(__file__).resolve().parents[1]


def load_example(name: str) -> dict:
    return json.loads((ROOT / "examples" / name).read_text(encoding="utf-8"))


class JourneyValidationTests(unittest.TestCase):
    def test_examples_are_valid(self):
        for path in sorted((ROOT / "examples").glob("*.json")):
            with self.subTest(path=path.name):
                result = validate_journey(json.loads(path.read_text(encoding="utf-8")))
                self.assertTrue(result["valid"])
                self.assertEqual(result["warnings"], [])

    def test_missing_reference_is_rejected(self):
        definition = load_example("03-order-tracking.json")
        definition["nodes"][1]["next"] = "missing_node"
        with self.assertRaises(JourneyValidationError):
            validate_journey(definition)

    def test_unknown_action_is_rejected(self):
        definition = load_example("03-order-tracking.json")
        action = next(node for node in definition["nodes"] if node["type"] == "action")
        action["action"] = "http.request"
        with self.assertRaises(JourneyValidationError):
            validate_journey(definition)

    def test_nested_variables_render_in_messages_and_inputs(self):
        variables = {"order": {"number": "1460469"}, "phone": "09123456789"}
        self.assertEqual(render_template("سفارش {{order.number}}", variables), "سفارش 1460469")
        self.assertEqual(
            render_template({"phone": "{{phone}}"}, variables),
            {"phone": "09123456789"},
        )


class DatabaseAndRuntimeTests(unittest.TestCase):
    def setUp(self):
        self.temp_dir = tempfile.TemporaryDirectory()
        self.db = Database(Path(self.temp_dir.name) / "test.sqlite3")
        self.db.initialize()
        for path in sorted((ROOT / "examples").glob("*.json")):
            self.db.create_journey(json.loads(path.read_text(encoding="utf-8")))
        for key in ("main_menu", "food_finder", "order_tracking", "supplement_finder"):
            self.db.publish(key)

    def tearDown(self):
        self.temp_dir.cleanup()

    def test_publish_keeps_separate_draft(self):
        item = self.db.get_journey("main_menu")
        self.assertEqual(item["published_version"], 1)
        self.assertEqual(item["draft_version"], 2)
        self.assertFalse(item["has_unpublished_changes"])
        item["definition"]["journey"]["description"] = "changed"
        updated = self.db.update_draft("main_menu", item["definition"])
        self.assertTrue(updated["has_unpublished_changes"])
        published = self.db.get_journey("main_menu", mode="published")
        self.assertNotEqual(published["definition"]["journey"]["description"], "changed")

    def test_settings_are_persisted_as_json(self):
        expected = {"enabled": True, "theme": "dark", "start_journey": "main_menu"}
        self.db.set_setting("widget", expected)
        self.assertEqual(self.db.get_setting("widget"), expected)
        self.assertEqual(self.db.get_setting("missing", {"fallback": True}), {"fallback": True})

    def test_runtime_enters_sub_journey(self):
        item = self.db.get_journey("main_menu")

        def load(key: str, version: int | None = None):
            target = self.db.get_journey(key, version=version)
            return target["definition"], target["version"]

        first = run_until_input(
            item["definition"],
            item["definition"]["journey"]["start"],
            {},
            [],
            "main_menu",
            item["version"],
            load_journey=load,
        )
        self.assertEqual(first.prompt["type"], "buttons")
        second = run_until_input(
            item["definition"],
            first.node_id,
            first.variables,
            first.stack,
            first.journey_key,
            first.version,
            answer="food_finder",
            load_journey=load,
        )
        self.assertEqual(second.journey_key, "food_finder")
        self.assertEqual(second.prompt["type"], "buttons")
        self.assertEqual(second.variables["main_intent"], "food_finder")

    def test_order_action_success_branch(self):
        item = self.db.get_journey("order_tracking")
        definition = item["definition"]
        first = run_until_input(
            definition, definition["journey"]["start"], {}, [], "order_tracking", item["version"]
        )
        second = run_until_input(
            definition,
            first.node_id,
            first.variables,
            first.stack,
            first.journey_key,
            first.version,
            answer="1460469",
        )
        final = run_until_input(
            definition,
            second.node_id,
            second.variables,
            second.stack,
            second.journey_key,
            second.version,
            answer="09123456789",
            execute_action=lambda action, inputs: {
                "ok": True,
                "data": {"summary": f"سفارش {inputs['order_id']} ارسال شد."},
            },
        )
        self.assertEqual(final.status, "completed")
        self.assertEqual(final.messages[-1]["text"], "سفارش 1460469 ارسال شد.")
        self.assertEqual(final.actions[0]["action"], "woocommerce.get_order")
        self.assertTrue(final.actions[0]["ok"])

    def test_order_action_error_branch(self):
        item = self.db.get_journey("order_tracking")
        definition = item["definition"]
        first = run_until_input(
            definition, definition["journey"]["start"], {}, [], "order_tracking", item["version"]
        )
        second = run_until_input(
            definition,
            first.node_id,
            first.variables,
            first.stack,
            first.journey_key,
            first.version,
            answer="1460469",
        )
        result = run_until_input(
            definition,
            second.node_id,
            second.variables,
            second.stack,
            second.journey_key,
            second.version,
            answer="09123456789",
            execute_action=lambda *_: {
                "ok": False,
                "error": {"code": "order_not_found", "message": "مطابقت ندارد."},
            },
        )
        self.assertEqual(result.prompt["type"], "buttons")
        self.assertEqual(result.node_id, "retry_options")
        self.assertEqual(result.variables["order_error"]["code"], "order_not_found")


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