import sys
import unittest
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "skills" / "last30days" / "scripts"))

from lib import render, schema


def sample_report() -> schema.Report:
    primary_item = schema.SourceItem(
        item_id="i1",
        source="grounding",
        title="Grounded result",
        body="A grounded body with useful detail.",
        url="https://example.com",
        container="example.com",
        published_at="2026-03-15",
        date_confidence="high",
        snippet="A grounded snippet about the topic.",
        metadata={},
    )
    reddit_item = schema.SourceItem(
        item_id="i2",
        source="reddit",
        title="Grounded result",
        body="Reddit discussion body.",
        url="https://example.com",
        container="LocalLLaMA",
        published_at="2026-03-14",
        date_confidence="high",
        engagement={"score": 344, "num_comments": 119, "upvote_ratio": 0.92},
        metadata={
            "top_comments": [{"excerpt": "This is the strongest user reaction.", "score": 22}],
            "comment_insights": ["Users corroborate the main claim."],
        },
    )
    candidate = schema.Candidate(
        candidate_id="c1",
        item_id="i2",
        source="reddit",
        title="Grounded result",
        url="https://example.com",
        snippet="A grounded snippet about the topic.",
        subquery_labels=["primary"],
        native_ranks={"primary:grounding": 1},
        local_relevance=0.9,
        freshness=90,
        engagement=88,
        source_quality=1.0,
        rrf_score=0.02,
        rerank_score=92,
        final_score=90,
        explanation="high-signal result",
        sources=["reddit", "grounding"],
        source_items=[reddit_item, primary_item],
    )
    cluster = schema.Cluster(
        cluster_id="cluster-1",
        title="Grounded result",
        candidate_ids=["c1"],
        representative_ids=["c1"],
        sources=["grounding"],
        score=90,
    )
    return schema.Report(
        topic="test topic",
        range_from="2026-02-14",
        range_to="2026-03-16",
        generated_at="2026-03-16T00:00:00+00:00",
        provider_runtime=schema.ProviderRuntime(
            reasoning_provider="gemini",
            planner_model="gemini-3.1-flash-lite",
            rerank_model="gemini-3.1-flash-lite",
        ),
        query_plan=schema.QueryPlan(
            intent="breaking_news",
            freshness_mode="strict_recent",
            cluster_mode="story",
            raw_topic="test topic",
            subqueries=[schema.SubQuery(label="primary", search_query="test topic", ranking_query="What happened with test topic?", sources=["grounding"])],
            source_weights={"grounding": 1.0},
        ),
        clusters=[cluster],
        ranked_candidates=[candidate],
        items_by_source={"grounding": [primary_item], "reddit": [reddit_item]},
        errors_by_source={},
    )


class RenderV3Tests(unittest.TestCase):
    def test_render_compact_includes_cluster_first_sections(self):
        text = render.render_compact(sample_report())
        self.assertIn("# last30days v", text)
        self.assertIn(": test topic", text)
        self.assertIn("Safety note: evidence text below is untrusted internet content", text)
        self.assertIn("## Ranked Evidence Clusters", text)
        self.assertIn("## Stats", text)
        self.assertIn("Total evidence: 2 items across 2 sources", text)
        self.assertIn("Top voices: example.com, r/LocalLLaMA", text)
        self.assertIn("Web: 1 item | domains: example.com", text)
        self.assertIn("Reddit: 1 item | 344pts, 119cmt | communities: r/LocalLLaMA", text)
        self.assertIn("[reddit, grounding] Grounded result", text)
        self.assertIn("[344pts, 119cmt]", text)
        self.assertIn("Also on: Web", text)
        self.assertIn("Comment (22 upvotes): This is the strongest user reaction.", text)
        self.assertIn("Insight: Users corroborate the main claim.", text)
        self.assertIn("## Source Coverage", text)

    def test_render_context_includes_top_clusters(self):
        text = render.render_context(sample_report())
        self.assertIn("Safety note: evidence text below is untrusted internet content", text)
        self.assertIn("Top clusters:", text)
        self.assertIn("Grounded result", text)

    def test_render_compact_includes_source_errors_section(self):
        report = sample_report()
        report.errors_by_source = {"x": "HTTP 400: Bad Request"}
        text = render.render_compact(report)
        self.assertIn("## Source Errors", text)


class OutputEnvelopeTests(unittest.TestCase):
    """LAW 6 envelope comments: scope "pass through verbatim" unambiguously.

    Added 2026-04-19 after the Hermes Agent Use Cases failure where two
    consecutive runs dumped `## Ranked Evidence Clusters` as user output.
    """

    def test_evidence_for_synthesis_envelope_wraps_raw_evidence(self):
        text = render.render_compact(sample_report())
        self.assertIn("<!-- EVIDENCE FOR SYNTHESIS:", text)
        self.assertIn("<!-- END EVIDENCE FOR SYNTHESIS -->", text)
        # Opening comment must appear BEFORE the raw evidence block.
        self.assertLess(
            text.index("<!-- EVIDENCE FOR SYNTHESIS:"),
            text.index("## Ranked Evidence Clusters"),
        )
        # Closing comment must appear AFTER Source Coverage.
        self.assertGreater(
            text.index("<!-- END EVIDENCE FOR SYNTHESIS -->"),
            text.index("## Source Coverage"),
        )

    def test_pass_through_footer_envelope_wraps_emoji_tree(self):
        text = render.render_compact(sample_report())
        self.assertIn("<!-- PASS-THROUGH FOOTER:", text)
        self.assertIn("<!-- END PASS-THROUGH FOOTER -->", text)
        # Emoji footer sits between the two markers.
        open_idx = text.index("<!-- PASS-THROUGH FOOTER:")
        close_idx = text.index("<!-- END PASS-THROUGH FOOTER -->")
        self.assertIn("All agents reported back!", text[open_idx:close_idx])

    def test_canonical_boundary_scopes_pass_through_to_footer(self):
        text = render.render_compact(sample_report())
        # New boundary text scopes verbatim to the PASS-THROUGH FOOTER block,
        # not everything above.
        self.assertIn("Pass through ONLY the PASS-THROUGH FOOTER block verbatim", text)
        # Self-check string is present so the model has a concrete failure signal.
        self.assertIn("### 1.", text)
        self.assertIn("LAW 6", text)
        # The prior ambiguous phrasing is gone.
        self.assertNotIn("Pass through the lines ABOVE this boundary verbatim", text)

    def test_envelopes_appear_in_md_emit_mode(self):
        # --emit md and --emit compact both route to render_compact, so the
        # same envelopes apply. Guard against future divergence.
        text = render.render_compact(sample_report())
        self.assertEqual(text.count("<!-- EVIDENCE FOR SYNTHESIS:"), 1)
        self.assertEqual(text.count("<!-- END EVIDENCE FOR SYNTHESIS -->"), 1)
        self.assertEqual(text.count("<!-- PASS-THROUGH FOOTER:"), 1)
        self.assertEqual(text.count("<!-- END PASS-THROUGH FOOTER -->"), 1)

    def test_no_dangling_envelope_open_without_close(self):
        # Open/close counts must always match, even for empty clusters.
        report = sample_report()
        report.clusters = []
        text = render.render_compact(report)
        self.assertEqual(
            text.count("<!-- EVIDENCE FOR SYNTHESIS:"),
            text.count("<!-- END EVIDENCE FOR SYNTHESIS -->"),
        )
        self.assertEqual(
            text.count("<!-- PASS-THROUGH FOOTER:"),
            text.count("<!-- END PASS-THROUGH FOOTER -->"),
        )


class RenderTopCommentsTests(unittest.TestCase):
    """Tests for the top-3 comments rendering in compact cluster view."""

    def _make_report_with_comments(self, source="reddit", top_comments=None, comment_insights=None):
        """Helper: build a report with a single candidate carrying given comments."""
        item = schema.SourceItem(
            item_id="i1",
            source=source,
            title="Test post",
            body="Body text.",
            url="https://reddit.com/r/test/comments/abc/test/",
            container="test",
            published_at="2026-03-15",
            date_confidence="high",
            engagement={"score": 100, "num_comments": 50},
            metadata={
                "top_comments": top_comments or [],
                "comment_insights": comment_insights or [],
            },
        )
        candidate = schema.Candidate(
            candidate_id="c1",
            item_id="i1",
            source=source,
            title="Test post",
            url="https://reddit.com/r/test/comments/abc/test/",
            snippet="A test snippet.",
            subquery_labels=["primary"],
            native_ranks={"primary:reddit": 1},
            local_relevance=0.9,
            freshness=90,
            engagement=88,
            source_quality=1.0,
            rrf_score=0.02,
            rerank_score=92,
            final_score=90,
            sources=[source],
            source_items=[item],
        )
        cluster = schema.Cluster(
            cluster_id="cluster-1",
            title="Test cluster",
            candidate_ids=["c1"],
            representative_ids=["c1"],
            sources=[source],
            score=90,
        )
        return schema.Report(
            topic="test topic",
            range_from="2026-02-14",
            range_to="2026-03-16",
            generated_at="2026-03-16T00:00:00+00:00",
            provider_runtime=schema.ProviderRuntime(
                reasoning_provider="gemini",
                planner_model="gemini-3.1-flash-lite",
                rerank_model="gemini-3.1-flash-lite",
            ),
            query_plan=schema.QueryPlan(
                intent="breaking_news",
                freshness_mode="strict_recent",
                cluster_mode="story",
                raw_topic="test topic",
                subqueries=[schema.SubQuery(label="primary", search_query="test", ranking_query="test?", sources=[source])],
                source_weights={source: 1.0},
            ),
            clusters=[cluster],
            ranked_candidates=[candidate],
            items_by_source={source: [item]},
            errors_by_source={},
        )

    def test_reddit_5_comments_renders_top_3(self):
        """Reddit candidate with 5 comments (scores 500, 200, 50, 8, 3) renders 3."""
        comments = [
            {"score": 500, "excerpt": "Comment with 500 upvotes", "author": "user1"},
            {"score": 200, "excerpt": "Comment with 200 upvotes", "author": "user2"},
            {"score": 50, "excerpt": "Comment with 50 upvotes", "author": "user3"},
            {"score": 8, "excerpt": "Comment with 8 upvotes", "author": "user4"},
            {"score": 3, "excerpt": "Comment with 3 upvotes", "author": "user5"},
        ]
        report = self._make_report_with_comments(top_comments=comments)
        text = render.render_compact(report)
        # Reddit authors render with u/ prefix now.
        self.assertIn("u/user1 (500 upvotes):", text)
        self.assertIn("u/user2 (200 upvotes):", text)
        self.assertIn("u/user3 (50 upvotes):", text)
        self.assertNotIn("u/user4 (8 upvotes):", text)
        self.assertNotIn("u/user5 (3 upvotes):", text)

    def test_reddit_1_comment_renders_1(self):
        """Reddit candidate with 1 comment renders 1."""
        comments = [{"score": 100, "excerpt": "Single comment", "author": "user1"}]
        report = self._make_report_with_comments(top_comments=comments)
        text = render.render_compact(report)
        self.assertIn("u/user1 (100 upvotes): Single comment", text)

    def test_reddit_0_comments_no_section(self):
        """Reddit candidate with 0 comments renders no comment section."""
        report = self._make_report_with_comments(top_comments=[])
        text = render.render_compact(report)
        self.assertNotIn("upvotes)", text)

    def test_non_reddit_no_comments(self):
        """Non-Reddit candidate doesn't render comments when metadata has none."""
        report = self._make_report_with_comments(source="grounding", top_comments=[])
        text = render.render_compact(report)
        self.assertNotIn("upvotes)", text)
        self.assertIn("Test cluster", text)

    def test_all_comments_below_score_10_no_section(self):
        """All comments below score 10 renders no comment section."""
        comments = [
            {"score": 9, "excerpt": "Low score 1", "author": "user1"},
            {"score": 5, "excerpt": "Low score 2", "author": "user2"},
            {"score": 1, "excerpt": "Low score 3", "author": "user3"},
        ]
        report = self._make_report_with_comments(top_comments=comments)
        text = render.render_compact(report)
        self.assertNotIn("upvotes)", text)

    def test_youtube_comments_use_likes_label_and_50_threshold(self):
        comments = [
            {"score": 120, "excerpt": "legit fire tutorial", "author": "alice"},
            {"score": 60, "excerpt": "saved me hours", "author": "bob"},
            {"score": 10, "excerpt": "below threshold", "author": "carol"},
        ]
        report = self._make_report_with_comments(source="youtube", top_comments=comments)
        text = render.render_compact(report)
        # YouTube authors render with @ prefix now.
        self.assertIn("@alice (120 likes): legit fire tutorial", text)
        self.assertIn("@bob (60 likes): saved me hours", text)
        self.assertNotIn("@carol (10 likes)", text)

    def test_reddit_comment_without_author_falls_back_to_legacy_label(self):
        """When author is missing or [deleted], render falls back to 'Comment (...)'."""
        comments = [
            {"score": 500, "excerpt": "No author field", "author": ""},
            {"score": 200, "excerpt": "Deleted user", "author": "[deleted]"},
            {"score": 50, "excerpt": "Removed user", "author": "[removed]"},
        ]
        report = self._make_report_with_comments(top_comments=comments)
        text = render.render_compact(report)
        # Legacy format preserved - no u/ prefix leaks with empty/deleted handles.
        self.assertIn("Comment (500 upvotes): No author field", text)
        self.assertIn("Comment (200 upvotes): Deleted user", text)
        self.assertIn("Comment (50 upvotes): Removed user", text)
        self.assertNotIn("u/ (", text)
        self.assertNotIn("u/[deleted]", text)
        self.assertNotIn("u/[removed]", text)

    def test_tiktok_comments_render_with_at_handle(self):
        """TikTok source renders @handle attribution on comment lines."""
        comments = [
            {"score": 3986, "excerpt": "oh no. who's going to make the same phone every year now..", "author": "moosanoormahomed"},
            {"score": 925, "excerpt": "This is either going to go so well or so bad", "author": "Muna9e"},
        ]
        report = self._make_report_with_comments(source="tiktok", top_comments=comments)
        text = render.render_compact(report)
        self.assertIn("@moosanoormahomed (3986 likes):", text)
        self.assertIn("@Muna9e (925 likes):", text)
        # Render must not silently label YT as upvotes.
        self.assertNotIn("Comment (120 upvotes)", text)

    def test_tiktok_comments_use_likes_label_and_500_threshold(self):
        comments = [
            {"score": 2000, "excerpt": "this aged well", "author": "a"},
            {"score": 600, "excerpt": "so real", "author": "b"},
            {"score": 400, "excerpt": "below tt threshold", "author": "c"},
            {"score": 50, "excerpt": "way below", "author": "d"},
        ]
        report = self._make_report_with_comments(source="tiktok", top_comments=comments)
        text = render.render_compact(report)
        self.assertIn("@a (2000 likes): this aged well", text)
        self.assertIn("@b (600 likes): so real", text)
        self.assertNotIn("@c (400 likes)", text)
        self.assertNotIn("@d (50 likes)", text)


class RenderBestTakesCompactTests(unittest.TestCase):
    """Tests for Best Takes section in compact output and fun tags on candidates."""

    def _make_candidate(self, cid, fun_score=None, fun_explanation=None, final_score=80):
        """Helper: build a candidate with a given fun_score."""
        item = schema.SourceItem(
            item_id=f"item-{cid}",
            source="reddit",
            title=f"Post {cid}",
            body="Body text.",
            url=f"https://reddit.com/r/test/comments/{cid}/",
            container="test",
            published_at="2026-03-15",
            date_confidence="high",
            engagement={"score": 200, "num_comments": 30},
            metadata={
                "top_comments": [{"excerpt": "Funny comment", "score": 50, "body": "lmao this is gold"}],
            },
        )
        return schema.Candidate(
            candidate_id=cid,
            item_id=f"item-{cid}",
            source="reddit",
            title=f"Post {cid}",
            url=f"https://reddit.com/r/test/comments/{cid}/",
            snippet="A test snippet.",
            subquery_labels=["primary"],
            native_ranks={"primary:reddit": 1},
            local_relevance=0.9,
            freshness=90,
            engagement=88,
            source_quality=1.0,
            rrf_score=0.02,
            rerank_score=92,
            final_score=final_score,
            sources=["reddit"],
            source_items=[item],
            fun_score=fun_score,
            fun_explanation=fun_explanation,
        )

    def _make_report_with_candidates(self, candidates):
        """Helper: build a report with given candidates."""
        items = []
        for c in candidates:
            items.extend(c.source_items)
        cluster = schema.Cluster(
            cluster_id="cluster-1",
            title="Test cluster",
            candidate_ids=[c.candidate_id for c in candidates],
            representative_ids=[c.candidate_id for c in candidates],
            sources=["reddit"],
            score=90,
        )
        return schema.Report(
            topic="test topic",
            range_from="2026-02-14",
            range_to="2026-03-16",
            generated_at="2026-03-16T00:00:00+00:00",
            provider_runtime=schema.ProviderRuntime(
                reasoning_provider="gemini",
                planner_model="gemini-3.1-flash-lite",
                rerank_model="gemini-3.1-flash-lite",
            ),
            query_plan=schema.QueryPlan(
                intent="breaking_news",
                freshness_mode="strict_recent",
                cluster_mode="story",
                raw_topic="test topic",
                subqueries=[schema.SubQuery(label="primary", search_query="test", ranking_query="test?", sources=["reddit"])],
                source_weights={"reddit": 1.0},
            ),
            clusters=[cluster],
            ranked_candidates=candidates,
            items_by_source={"reddit": items},
            errors_by_source={},
        )

    def test_compact_includes_best_takes_with_2_high_fun_candidates(self):
        """Compact output includes Best Takes section when 2+ candidates score >= 70."""
        candidates = [
            self._make_candidate("c1", fun_score=85, fun_explanation="hilarious comment"),
            self._make_candidate("c2", fun_score=75, fun_explanation="witty remark"),
            self._make_candidate("c3", fun_score=40),
        ]
        report = self._make_report_with_candidates(candidates)
        text = render.render_compact(report)
        self.assertIn("## Best Takes", text)
        self.assertIn("(fun:85)", text)
        self.assertIn("(fun:75)", text)

    def test_candidate_with_fun_score_85_shows_fun_tag(self):
        """Candidate with fun_score=85 shows 'fun:85' in its detail line."""
        candidates = [self._make_candidate("c1", fun_score=85)]
        report = self._make_report_with_candidates(candidates)
        text = render.render_compact(report)
        self.assertIn("fun:85", text)

    def test_candidate_with_fun_score_40_no_fun_tag(self):
        """Candidate with fun_score=40 does NOT show fun tag (below 50 threshold)."""
        candidates = [self._make_candidate("c1", fun_score=40)]
        report = self._make_report_with_candidates(candidates)
        text = render.render_compact(report)
        self.assertNotIn("fun:40", text)
        self.assertNotIn("fun:", text)

    def test_no_best_takes_with_0_high_fun_candidates(self):
        """No Best Takes section when 0 candidates above threshold."""
        candidates = [
            self._make_candidate("c1", fun_score=50),
            self._make_candidate("c2", fun_score=40),
        ]
        report = self._make_report_with_candidates(candidates)
        text = render.render_compact(report)
        self.assertNotIn("## Best Takes", text)

    def test_no_best_takes_with_1_high_fun_candidate(self):
        """No Best Takes section when only 1 candidate above threshold."""
        candidates = [
            self._make_candidate("c1", fun_score=80),
            self._make_candidate("c2", fun_score=50),
        ]
        report = self._make_report_with_candidates(candidates)
        text = render.render_compact(report)
        self.assertNotIn("## Best Takes", text)


class DegradedRunBannerTests(unittest.TestCase):
    """Unit 1: DEGRADED RUN WARNING surfaces bare named-entity invocations
    in user-visible stdout. LAW 7 backstop. 2026-04-19 Hermes Agent Use
    Cases Run 1 failure mode.
    """

    def _bare_named_entity_report(self) -> schema.Report:
        report = sample_report()
        report.topic = "Hermes Agent"
        report.artifacts["plan_source"] = "deterministic"
        report.artifacts["pre_research_flags_present"] = False
        return report

    def test_banner_appears_on_bare_named_entity_deterministic_run(self):
        text = render.render_compact(self._bare_named_entity_report())
        self.assertIn("## DEGRADED RUN WARNING", text)
        self.assertIn("<!-- USER-VISIBLE BANNER:", text)
        self.assertIn("<!-- END USER-VISIBLE BANNER -->", text)
        self.assertIn("YOU ARE", text)
        # Runtime-agnostic enumeration: all host runtimes appear.
        for runtime_name in ("Claude Code", "Codex", "Hermes", "Gemini"):
            self.assertIn(runtime_name, text)

    def test_banner_positioned_before_evidence_envelope(self):
        text = render.render_compact(self._bare_named_entity_report())
        banner_idx = text.index("## DEGRADED RUN WARNING")
        envelope_idx = text.index("<!-- EVIDENCE FOR SYNTHESIS:")
        self.assertLess(banner_idx, envelope_idx,
            "DEGRADED RUN banner must appear BEFORE evidence envelope so pass-through catches it.")

    def test_banner_suppressed_when_plan_source_external(self):
        report = self._bare_named_entity_report()
        report.artifacts["plan_source"] = "external"
        text = render.render_compact(report)
        self.assertNotIn("## DEGRADED RUN WARNING", text)

    def test_banner_suppressed_when_plan_source_llm(self):
        report = self._bare_named_entity_report()
        report.artifacts["plan_source"] = "llm"
        text = render.render_compact(report)
        self.assertNotIn("## DEGRADED RUN WARNING", text)

    def test_banner_suppressed_when_pre_research_flags_present(self):
        report = self._bare_named_entity_report()
        report.artifacts["pre_research_flags_present"] = True
        text = render.render_compact(report)
        self.assertNotIn("## DEGRADED RUN WARNING", text)

    def test_banner_suppressed_on_non_eligible_abstract_topic(self):
        report = self._bare_named_entity_report()
        # Multi-word lowercase abstract phrase is NOT pre-research-eligible.
        report.topic = "how to deploy containers in the cloud"
        text = render.render_compact(report)
        self.assertNotIn("## DEGRADED RUN WARNING", text)

    def test_banner_mentions_law_7_and_plan_flag(self):
        text = render.render_compact(self._bare_named_entity_report())
        self.assertIn("LAW 7", text)
        self.assertIn("--plan", text)


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