from __future__ import annotations

import json
import tempfile
import unittest
from pathlib import Path
from urllib.parse import parse_qs, urlsplit

from catalog import ProductCatalog, fetch_terms_page, resolve_term
from core import JourneyValidationError, run_until_input, validate_journey
from database import Database
from integrations import IntegrationError, WooCommerceConfig


class FakeResponse:
    def __init__(self, payload):
        self.raw = json.dumps(payload, ensure_ascii=False).encode("utf-8")

    def __enter__(self):
        return self

    def __exit__(self, *args):
        return False

    def read(self, size):
        return self.raw[:size]


class CatalogTests(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory()
        self.db = Database(Path(self.temp.name) / "shared.sqlite3")
        self.db.initialize()
        self.config = WooCommerceConfig("https://arcopet.com", "", "", timeout=3)

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

    def test_synced_terms_preserve_admin_names_and_aliases_across_connections(self):
        self.db.sync_terms("brand", [{"slug": "josera", "name_fa": "Josera"}])
        self.db.save_term("brand", "josera", "جوسرا", ["Josera", "جوزرا"])
        self.db.sync_terms("brand", [{"slug": "josera", "name_fa": "Josera New"}])
        other_process_db = Database(self.db.path)
        result = other_process_db.list_terms("brand")
        self.assertEqual(result[0]["name_fa"], "جوسرا")
        self.assertEqual(resolve_term("brand", "جوزرا", result), "josera")

    def test_product_search_uses_exact_bank_slugs_and_limits_cards(self):
        self.db.save_term("category", "cat-food", "غذای گربه", ["غذا گربه"])
        calls = []

        def transport(request, timeout):
            calls.append((request.full_url, timeout))
            return FakeResponse({"products": [
                {"name": f"غذا {index}", "permalink": f"https://arcopet.com/product/{index}/",
                 "stock_status": "instock", "price": "1000", "image": "https://arcopet.com/p.jpg"}
                for index in range(1, 7)
            ] + [{"name": "ناموجود", "permalink": "https://arcopet.com/out/", "stock_status": "outofstock"}]})

        result = ProductCatalog(self.config, transport).search({"category": "غذا گربه", "q": "خشک"}, self.db.list_terms())
        params = parse_qs(urlsplit(calls[0][0]).query)
        self.assertEqual(params["category"], ["cat-food"])
        self.assertEqual(params["instock"], ["1"])
        self.assertEqual(params["per_page"], ["4"])
        self.assertEqual(calls[0][1], 3)
        self.assertEqual(result["count"], 4)
        self.assertEqual(len(result["products"]), 4)

    def test_products_cannot_link_outside_store_or_appear_if_out_of_stock(self):
        payload = [{"title": "بدون موجودی", "url": "https://arcopet.com/no", "in_stock": False},
                   {"title": "لینک نامعتبر", "url": "javascript:alert(1)", "in_stock": True},
                   {"title": "فروشگاه دیگر", "url": "https://evil.example/p", "in_stock": True},
                   {"title": "محصول سالم", "url": "https://www.arcopet.com/product/ok", "in_stock": True}]
        result = ProductCatalog(self.config, lambda *_: FakeResponse({"data": {"items": payload}})).search({}, [])
        self.assertEqual([item["title"] for item in result["products"]], ["محصول سالم"])

    def test_invalid_terms_and_unlisted_filters_never_reach_catalog(self):
        catalog = ProductCatalog(self.config, lambda *_: self.fail("untrusted filter reached store"))
        for filters in ({"category": "ناموجود"}, {"url": "https://example.com"}, {"q": "x" * 200}):
            with self.assertRaises(IntegrationError):
                catalog.search(filters, [])

    def test_single_page_sync_matches_woocommerce_terms(self):
        class WCStub:
            def _request(self, path, with_headers=False):
                self.path = path
                return ([{"name": "غذای گربه", "slug": "cat-food"}], "2")

        wc = WCStub()
        items, has_more = fetch_terms_page("category", 2, wc)
        self.assertEqual(items[0]["slug"], "cat-food")
        self.assertFalse(has_more)
        self.assertIn("per_page=100&page=2", wc.path)

    def test_sample_journey_success_empty_error_branches(self):
        definition = json.loads((Path(__file__).resolve().parents[1] / "examples/05-product-search.json").read_text(encoding="utf-8"))
        self.assertTrue(validate_journey(definition)["valid"])
        first = run_until_input(definition, "start", {}, [], "product_search", 1)
        self.assertEqual(first.prompt["type"], "question")
        for outcome, expected_node in (
            ({"ok": True, "data": {"count": 1, "products": [{"title": "غذا", "url": "https://arcopet.com/p"}]}}, "end"),
            ({"ok": True, "data": {"count": 0, "products": []}}, "retry"),
            ({"ok": False, "error": {"code": "catalog_unavailable", "message": "قطع"}}, "end"),
        ):
            seen = []
            result = run_until_input(definition, first.node_id, {}, [], "product_search", 1, answer="جوسرا",
                                     execute_action=lambda action, filters: (seen.append(filters) or outcome))
            self.assertEqual(seen[0]["q"], "جوسرا")
            self.assertEqual(result.node_id, None if expected_node == "end" else expected_node)
            self.assertEqual(sum(message["type"] == "products" for message in result.messages), int(bool(outcome["ok"] and outcome["data"]["products"])))

    def test_product_finder_needs_three_paths(self):
        definition = json.loads((Path(__file__).resolve().parents[1] / "examples/05-product-search.json").read_text(encoding="utf-8"))
        node = next(item for item in definition["nodes"] if item["id"] == "lookup")
        del node["on_empty"]
        with self.assertRaises(JourneyValidationError):
            validate_journey(definition)


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