import json
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch

from generate_surface import (
    check_test_parity,
    extract_tests,
    generate_tests,
    mask_csharp_comments,
    reviewed_tests,
    scan_parity_markers,
)


class ParityGenerationTests(unittest.TestCase):
    def test_reviewed_tests_include_owning_crate_unit_tests(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            rust_file = root / "crates" / "example" / "src" / "internal_semantics.rs"
            rust_file.parent.mkdir(parents=True)
            case_id = "Example.Tests.cs::ExampleTests.InternalMember::test"
            rust_file.write_text(
                f"// parity-case: {case_id} {'a' * 64} translated\n"
                "#[test]\nfn internal_member() {}\n"
            )

            review = reviewed_tests(root)[case_id]
            self.assertEqual(review["rust_file"], "crates/example/src/internal_semantics.rs")
            self.assertEqual(review["rust_test"], "internal_member")
            self.assertEqual(scan_parity_markers(root)[case_id][0], review)

    def test_comment_masking_preserves_offsets_and_ignores_fake_tests(self) -> None:
        source = '''var url = "https://example.com/[Test]"; // [Test]\n/* [TestCase(1)] */\n[Test]\n'''
        masked = mask_csharp_comments(source)
        self.assertEqual(len(masked), len(source))
        self.assertEqual(masked.count("\n"), source.count("\n"))
        self.assertIn('"https://example.com/[Test]"', masked)
        self.assertEqual(masked.count("[Test]"), 2)

        with tempfile.TemporaryDirectory() as temporary:
            upstream = Path(temporary)
            tests = upstream / "LibreMetaverse.Tests"
            tests.mkdir()
            (upstream / "LibreMetaverse.Rendering.Tests").mkdir()
            (tests / "Comments.cs").write_text(
                """public class Comments
{
    // [Test]
    // public void CommentedOut() {}
    [Test]
    [TestCase(1)]
    [TestCase(2)]
    public void Cases(int value) {}
}
"""
            )
            self.assertEqual([case["parameter_case"] for case in extract_tests(upstream)], ["1", "2"])

    def test_reviewed_rust_test_is_preserved_and_excluded_from_placeholders(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            upstream = root / "upstream"
            source = upstream / "LibreMetaverse.Tests" / "ExampleTests.cs"
            source.parent.mkdir(parents=True)
            (upstream / "LibreMetaverse.Rendering.Tests").mkdir()
            source.write_text(
                """namespace LibreMetaverse.Tests;
[Category("Example")]
public class ExampleTests
{
    [TestCase(1, Description = "one")]
    public void KeepsIdentity(int value) { Assert.That(value, Is.EqualTo(1)); }
    [Test]
    public void RemainsPending() { Assert.Pass(); }
}
"""
            )
            reviewed, _pending = extract_tests(upstream)
            output = root / "output"
            rust_file = output / "tests" / "compat" / "tests" / "example.rs"
            rust_file.parent.mkdir(parents=True)
            rust_file.write_text(
                f"// parity-case: {reviewed['id']} {reviewed['body_sha256']} translated\n"
                "#[test]\nfn translated_case() {}\n"
            )
            original = rust_file.read_bytes()

            with patch("generate_surface.EXPECTED_TESTS", 2):
                self.assertEqual(generate_tests(upstream, output), 2)
                self.assertEqual(rust_file.read_bytes(), original)
                generated = output / "tests/compat/tests/generated_parity.rs"
                self.assertNotIn(reviewed["id"], generated.read_text())
                catalog = json.loads((output / "tests/upstream-tests.json").read_text())
                self.assertEqual(catalog["tests"][0]["status"], "translated")
                self.assertEqual(catalog["tests"][0]["rust_test"], "translated_case")
                self.assertEqual(check_test_parity(output)["unreviewed"], 1)

                generated_text = generated.read_text()
                generated.write_text(generated_text.replace("// parity-case:", "// missing-case:", 1))
                with self.assertRaisesRegex(RuntimeError, "Missing Rust parity cases"):
                    check_test_parity(output)

                generated.write_text(generated_text)
                pending = catalog["tests"][1]
                duplicate = (
                    f"// parity-case: {pending['id']} {pending['body_sha256']} pending\n"
                    "#[test]\nfn duplicate_case() {}\n"
                )
                generated.write_text(duplicate + generated_text)
                with self.assertRaisesRegex(RuntimeError, "Duplicate Rust parity cases"):
                    check_test_parity(output)

                generated.write_text(generated_text.replace(pending["body_sha256"], "0" * 64, 1))
                with self.assertRaisesRegex(RuntimeError, "Drifted reviewed C# test bodies"):
                    check_test_parity(output)


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