from __future__ import annotations

import atexit
import io
import json
import multiprocessing
import os
import queue
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch


TEST_DATA_DIR = tempfile.TemporaryDirectory()
atexit.register(TEST_DATA_DIR.cleanup)
os.environ.setdefault("ARCO_BOT_BASE_PATH", "/bot")
os.environ.setdefault("ARCO_BOT_DB", str(Path(TEST_DATA_DIR.name) / "cpanel-test.sqlite3"))
os.environ.setdefault("ARCO_ADMIN_PASSWORD", "test-password")
os.environ.setdefault("ARCO_SECRET_KEY", "test-secret-key-with-enough-length")

import main  # noqa: E402
from main import AUTH_COOKIE, create_auth_token, normalize_base_path, safe_event_variables  # noqa: E402
from cpanel_app import application  # noqa: E402


def wsgi_request(
    path: str,
    *,
    method: str = "GET",
    payload: dict | list | None = None,
    script_name: str = "/bot",
    origin: str | None = None,
    cookie: str | None = None,
) -> tuple[str, dict[str, str], bytes]:
    response: dict[str, object] = {}
    raw_body = json.dumps(payload).encode("utf-8") if payload is not None else b""

    def start_response(status, headers, exc_info=None):
        response["status"] = status
        response["headers"] = dict(headers)

    environ = {
        "REQUEST_METHOD": method,
        "SCRIPT_NAME": script_name,
        "PATH_INFO": path,
        "QUERY_STRING": "",
        "SERVER_NAME": "localhost",
        "SERVER_PORT": "443",
        "SERVER_PROTOCOL": "HTTP/1.1",
        "wsgi.version": (1, 0),
        "wsgi.url_scheme": "https",
        "CONTENT_LENGTH": str(len(raw_body)),
        "CONTENT_TYPE": "application/json",
        "wsgi.input": io.BytesIO(raw_body),
        "wsgi.errors": io.StringIO(),
        "wsgi.multithread": False,
        "wsgi.multiprocess": False,
        "wsgi.run_once": False,
    }
    if origin:
        environ["HTTP_ORIGIN"] = origin
    if cookie:
        environ["HTTP_COOKIE"] = cookie
    body = b"".join(application(environ, start_response))
    return str(response["status"]), dict(response["headers"]), body


def wsgi_get(path: str, script_name: str = "/bot") -> tuple[str, dict[str, str], bytes]:
    return wsgi_request(path, script_name=script_name)


def forked_wsgi_health(result_queue) -> None:
    try:
        status, _, body = wsgi_get("/api/health")
        result_queue.put((status, json.loads(body)))
    except BaseException as exc:  # pragma: no cover - diagnostic child process
        result_queue.put(("error", repr(exc)))


class CpanelDeploymentTests(unittest.TestCase):
    def test_base_path_normalization(self):
        self.assertEqual(normalize_base_path("bot/"), "/bot")
        self.assertEqual(normalize_base_path("/"), "")
        with self.assertRaises(RuntimeError):
            normalize_base_path("/bot?<bad>")

    def test_sensitive_event_variables_are_masked(self):
        payload = safe_event_variables(
            {"customer_phone": "09123456789", "order_id": "1460469", "nested": {"mobile": "+989121112222"}}
        )
        self.assertEqual(payload["customer_phone"], "***6789")
        self.assertEqual(payload["nested"]["mobile"], "***2222")
        self.assertEqual(payload["order_id"], "1460469")

    def test_wsgi_health_endpoint(self):
        status, headers, body = wsgi_get("/api/health")
        self.assertTrue(status.startswith("200"))
        self.assertIn("application/json", headers["content-type"])
        payload = json.loads(body)
        self.assertTrue(payload["ok"])
        self.assertEqual(payload["phase"], 3)
        self.assertEqual(payload["version"], "3.1.0")
        self.assertEqual(payload["mode"], "all")
        self.assertEqual(payload["base_path"], "/bot")
        self.assertEqual(headers.get("x-content-type-options"), "nosniff")

    def test_wsgi_panel_uses_cpanel_prefix(self):
        status, _, body = wsgi_request("/", cookie=f"{AUTH_COOKIE}={create_auth_token()}")
        html = body.decode("utf-8")
        self.assertTrue(status.startswith("200"))
        self.assertIn('content="/bot"', html)
        self.assertIn('href="/bot/static/styles.css?v=3.1.0"', html)
        self.assertIn('src="/bot/static/app.js?v=3.1.0"', html)
        self.assertIn('id="sidebarToggle"', html)

    def test_admin_requires_login_but_widget_stays_public(self):
        status, headers, _ = wsgi_get("/")
        self.assertTrue(status.startswith("303"))
        self.assertIn("/bot/login", headers["location"])
        status, _, _ = wsgi_get("/api/journeys")
        self.assertTrue(status.startswith("401"))
        status, _, _ = wsgi_get("/api/widget/config")
        self.assertTrue(status.startswith("200"))

    def test_widget_mode_exposes_only_public_runtime(self):
        previous_mode = main.APP_MODE
        main.APP_MODE = "widget"
        try:
            status, _, body = wsgi_get("/api/health")
            self.assertTrue(status.startswith("200"))
            payload = json.loads(body)
            self.assertEqual(payload, {"ok": True, "phase": 3, "version": "3.1.0", "mode": "widget"})
            status, _, _ = wsgi_get("/api/widget/config")
            self.assertTrue(status.startswith("200"))
            status, _, _ = wsgi_get("/api/journeys")
            self.assertTrue(status.startswith("404"))
            status, _, _ = wsgi_get("/api/admin/integrations/woocommerce")
            self.assertTrue(status.startswith("404"))
            status, _, _ = wsgi_get("/api/admin/catalog/terms")
            self.assertTrue(status.startswith("404"))
            status, _, _ = wsgi_get("/docs")
            self.assertTrue(status.startswith("404"))
            status, _, _ = wsgi_get("/")
            self.assertTrue(status.startswith("404"))
        finally:
            main.APP_MODE = previous_mode

    def test_admin_mode_hides_widget_runtime(self):
        previous_mode = main.APP_MODE
        main.APP_MODE = "admin"
        try:
            status, _, _ = wsgi_get("/api/widget/config")
            self.assertTrue(status.startswith("404"))
            status, _, _ = wsgi_request("/", cookie=f"{AUTH_COOKIE}={create_auth_token()}")
            self.assertTrue(status.startswith("200"))
        finally:
            main.APP_MODE = previous_mode

    def test_widget_rate_limiter(self):
        previous_limit = main.WIDGET_RATE_LIMIT
        main.WIDGET_RATE_LIMIT = 2
        main._widget_rate_buckets.clear()
        try:
            self.assertTrue(main.widget_request_allowed("client-a", now=100))
            self.assertTrue(main.widget_request_allowed("client-a", now=101))
            self.assertFalse(main.widget_request_allowed("client-a", now=102))
            self.assertTrue(main.widget_request_allowed("client-a", now=161))
        finally:
            main.WIDGET_RATE_LIMIT = previous_limit
            main._widget_rate_buckets.clear()

    def test_login_sets_http_only_cookie(self):
        status, headers, body = wsgi_request(
            "/api/auth/login", method="POST", payload={"password": "test-password"}
        )
        self.assertTrue(status.startswith("200"))
        self.assertTrue(json.loads(body)["ok"])
        cookie = headers.get("set-cookie", "")
        self.assertIn(AUTH_COOKIE + "=", cookie)
        self.assertIn("HttpOnly", cookie)
        self.assertIn("Secure", cookie)

    def test_wsgi_serves_static_assets(self):
        status, headers, body = wsgi_get("/static/styles.css")
        self.assertTrue(status.startswith("200"))
        self.assertIn("text/css", headers["content-type"])
        self.assertGreater(len(body), 1000)

    def test_widget_script_is_public_and_isolated(self):
        status, headers, body = wsgi_get("/widget.js")
        self.assertTrue(status.startswith("200"))
        self.assertIn("javascript", headers["content-type"])
        self.assertIn(b"attachShadow", body)

    def test_catalog_admin_endpoint_requires_auth(self):
        status, _, _ = wsgi_get("/api/admin/catalog/terms")
        self.assertTrue(status.startswith("401"))
        status, _, body = wsgi_request("/api/admin/catalog/terms", cookie=f"{AUTH_COOKIE}={create_auth_token()}")
        self.assertTrue(status.startswith("200"))
        self.assertIsInstance(json.loads(body), list)

    def test_catalog_json_import_is_admin_only_and_atomic(self):
        valid = [{"taxonomy": "brand", "slug": "josera", "name_fa": "جوسرا", "aliases": ["Josera"]}]
        status, _, _ = wsgi_request("/api/admin/catalog/import", method="POST", payload=valid)
        self.assertTrue(status.startswith("401"))
        credential = f"{AUTH_COOKIE}={create_auth_token()}"
        status, _, _ = wsgi_request("/api/admin/catalog/import", method="POST", payload=valid, cookie=credential)
        self.assertTrue(status.startswith("200"))
        self.assertEqual(main.db.list_terms("brand")[0]["aliases"], ["Josera"])
        invalid = [valid[0], {"taxonomy": "tag", "slug": "bad/slug", "name_fa": "بد", "aliases": []}]
        status, _, _ = wsgi_request("/api/admin/catalog/import", method="POST", payload=invalid, cookie=credential)
        self.assertTrue(status.startswith("422"))
        self.assertEqual(main.db.list_terms("tag"), [])

    def test_catalog_test_endpoint_returns_normalized_live_results(self):
        product = {"title": "غذا", "url": "https://arcopet.com/p", "image": "", "price": "۱۰۰۰ تومان"}
        with patch("main.ProductCatalog") as mocked_catalog:
            mocked_catalog.return_value.search.return_value = {"count": 1, "products": [product]}
            status, _, body = wsgi_request("/api/admin/catalog/test", method="POST", payload={},
                                           cookie=f"{AUTH_COOKIE}={create_auth_token()}")
        self.assertTrue(status.startswith("200"), body)
        self.assertEqual(json.loads(body)["products"], [product])

    def test_widget_persists_product_cards_for_resume(self):
        main.db.publish("product_search")
        journey = main.db.get_journey("product_search", mode="published")
        session = main.db.create_session("product_search", "published", journey["definition"], journey["version"])
        prompt = main._advance_session(session)
        self.assertEqual(prompt["prompt"]["type"], "question")
        products = [{"title": "غذای جوسرا", "url": "https://arcopet.com/product/josera", "image": "", "price": "۱۰۰۰ تومان"}]
        with patch("main.ProductCatalog") as mocked_catalog:
            mocked_catalog.return_value.search.return_value = {"count": 1, "products": products}
            status, _, body = wsgi_request("/api/widget/runtime/sessions/" + session["id"] + "/answer",
                                           method="POST", payload={"value": "جوسرا"})
        self.assertTrue(status.startswith("200"), body)
        result = json.loads(body)
        self.assertEqual(result["status"], "completed")
        self.assertEqual(result["messages"][0]["products"], products)
        status, _, body = wsgi_get("/api/widget/runtime/sessions/" + session["id"])
        self.assertTrue(status.startswith("200"))
        history = json.loads(body)["history"]
        self.assertEqual(next(item["products"] for item in history if item.get("products")), products)

    def test_widget_reenables_options_after_loading(self):
        status, _, body = wsgi_get("/widget.js")
        self.assertTrue(status.startswith("200"))
        self.assertIn(b'root.querySelectorAll(".aw-option")', body)
        self.assertIn(b"button.disabled = loading", body)

    def test_journey_guide_requires_admin_and_downloads(self):
        status, _, _ = wsgi_get("/guide/journey-builder")
        self.assertTrue(status.startswith("303"))
        status, headers, body = wsgi_request(
            "/guide/journey-builder", cookie=f"{AUTH_COOKIE}={create_auth_token()}"
        )
        self.assertTrue(status.startswith("200"))
        self.assertIn("text/markdown", headers["content-type"])
        self.assertIn("راهنمای ساخت Journey".encode("utf-8"), body)

    def test_widget_config_and_published_runtime(self):
        status, headers, body = wsgi_request(
            "/api/widget/config", origin="https://arcopet.com"
        )
        self.assertTrue(status.startswith("200"))
        self.assertEqual(headers.get("access-control-allow-origin"), "https://arcopet.com")
        config = json.loads(body)
        self.assertEqual(config["start_journey"], "main_menu")

        status, _, body = wsgi_request(
            "/api/widget/runtime/main_menu/start",
            method="POST",
            payload={"page_url": "https://arcopet.com/", "visitor_id": "test-visitor"},
            origin="https://arcopet.com",
        )
        self.assertTrue(status.startswith("200"))
        result = json.loads(body)
        self.assertEqual(result["status"], "waiting_input")
        self.assertEqual(result["prompt"]["type"], "buttons")
        self.assertTrue(result["session_id"])

    def test_woocommerce_status_is_admin_only_and_secret_free(self):
        status, _, body = wsgi_request(
            "/api/admin/integrations/woocommerce",
            cookie=f"{AUTH_COOKIE}={create_auth_token()}",
        )
        self.assertTrue(status.startswith("200"))
        payload = json.loads(body)
        self.assertFalse(payload["configured"])
        self.assertEqual(payload["permission"], "read_only")
        self.assertNotIn("consumer_key", payload)
        self.assertNotIn("consumer_secret", payload)

    def test_passenger_fallback_exports_same_application(self):
        from passenger_wsgi import application as passenger_application

        self.assertIs(passenger_application, application)

    @unittest.skipUnless("fork" in multiprocessing.get_all_start_methods(), "fork is Linux-specific")
    def test_wsgi_adapter_survives_passenger_style_fork(self):
        # Start the adapter in the parent first, like a Passenger preloader.
        status, _, _ = wsgi_get("/api/health")
        self.assertTrue(status.startswith("200"))

        context = multiprocessing.get_context("fork")
        result_queue = context.Queue()
        process = context.Process(target=forked_wsgi_health, args=(result_queue,))
        process.start()
        process.join(5)
        if process.is_alive():
            process.terminate()
            process.join(2)
            self.fail("Forked Passenger worker hung while serving a request.")
        self.assertEqual(process.exitcode, 0)
        try:
            child_status, payload = result_queue.get(timeout=1)
        except queue.Empty:
            self.fail("Forked Passenger worker returned no response.")
        self.assertTrue(child_status.startswith("200"), payload)
        self.assertTrue(payload["ok"])


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