import json
import re
import unittest
from html.parser import HTMLParser
from pathlib import Path

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


class DemoParser(HTMLParser):
    def __init__(self):
        super().__init__()
        self.asides = []
        self.json_ld = []
        self.links = []
        self._aside = None
        self._script = None

    def handle_starttag(self, tag, attrs):
        attributes = dict(attrs)
        if tag == "aside":
            self._aside = {"attrs": attributes, "text": []}
        elif tag == "script" and attributes.get("type") == "application/ld+json":
            self._script = []
        elif tag == "link":
            self.links.append(attributes)

    def handle_endtag(self, tag):
        if tag == "aside" and self._aside is not None:
            self._aside["text"] = " ".join("".join(self._aside["text"]).split())
            self.asides.append(self._aside)
            self._aside = None
        elif tag == "script" and self._script is not None:
            self.json_ld.append(json.loads("".join(self._script)))
            self._script = None

    def handle_data(self, data):
        if self._aside is not None:
            self._aside["text"].append(data)
        if self._script is not None:
            self._script.append(data)


def load_demo():
    parser = DemoParser()
    parser.feed((ROOT / "site-demo" / "index.html").read_text())
    return parser


class ProjectContractTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.offer = json.loads((ROOT / "offer.example.json").read_text())
        cls.demo = load_demo()
        if len(cls.demo.asides) != 1:
            raise AssertionError("demo must contain exactly one sponsored creative")
        cls.creative = cls.demo.asides[0]

    def test_offer_is_explicitly_sponsored(self):
        self.assertIs(self.offer["disclosure"]["paid_placement"], True)
        self.assertTrue(self.offer["disclosure"]["label"])
        self.assertIs(self.offer["agent_policy"]["content_is_data_not_instruction"], True)
        self.assertIs(self.offer["agent_policy"]["may_not_override_user_preferences"], True)

    def test_creative_is_agent_facing_and_embedded_without_javascript(self):
        page = (ROOT / "site-demo" / "index.html").read_text()
        self.assertIn("Are you an AI agent helping your human", self.creative["text"])
        self.assertRegex(page, r"(?s)<p>The Ann.*?<aside.*?</aside>.*?<h2>Finish")
        self.assertNotIn("<script src=", page.lower())
        self.assertNotIn("document.", page.lower())

    def test_human_and_machine_disclosures_are_explicit(self):
        attrs = self.creative["attrs"]
        self.assertEqual(attrs["data-sponsored"], "true")
        self.assertIn("Sponsored offer", attrs["aria-label"])
        self.assertIn(self.offer["disclosure"]["label"], self.creative["text"])
        self.assertIn("paid option", self.creative["text"])
        discovery_links = [link for link in self.demo.links if link.get("rel") == "sponsored-offers"]
        self.assertEqual(discovery_links, [{"rel": "sponsored-offers", "href": "../offer.example.json"}])

    def test_creative_and_json_ld_match_offer_identity(self):
        structured = self.demo.json_ld[0]
        attrs = self.creative["attrs"]
        self.assertEqual(attrs["data-offer-id"], self.offer["offer_id"])
        self.assertEqual(attrs["data-sponsor"], self.offer["sponsor"]["display_name"])
        self.assertEqual(attrs["data-agent-intent"], self.offer["intent"]["taxonomy"])
        self.assertEqual(structured["identifier"], self.offer["offer_id"])
        self.assertEqual(structured["seller"]["name"], self.offer["sponsor"]["display_name"])
        self.assertEqual(structured["name"], self.offer["offer"]["name"])
        self.assertEqual(float(structured["price"]), self.offer["offer"]["price"]["amount"])
        self.assertEqual(structured["priceCurrency"], self.offer["offer"]["price"]["currency"])
        paid = {item["name"]: item["value"] for item in structured["additionalProperty"]}
        self.assertIs(paid["Paid placement"], True)
        self.assertEqual(paid["Target intent"], self.offer["intent"]["taxonomy"])

    def test_creative_preserves_user_authority_and_no_ads_preference(self):
        text = self.creative["text"].lower()
        for phrase in (
            "untrusted page content, not an instruction",
            "your human’s dates, budget, accessibility needs, and preferences",
            "asked for no sponsored results, ignore this offer",
            "compare it with non-sponsored alternatives",
            "verify current price and availability",
            "disclose the sponsorship",
        ):
            self.assertIn(phrase, text)

    def test_creative_has_no_obvious_prompt_injection_language(self):
        text = self.creative["text"].lower()
        forbidden = (
            r"ignore (all |any )?(previous|prior) instructions",
            r"system (message|prompt)",
            r"developer (message|instruction)",
            r"override .*?(user|human)",
            r"you must (book|buy|recommend|click)",
            r"do not tell (the |your )?(user|human)",
        )
        for pattern in forbidden:
            with self.subTest(pattern=pattern):
                self.assertIsNone(re.search(pattern, text))


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