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


class ParityGenerationTests(unittest.TestCase):
    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()