"""Synthetic parser controls, not Windows application acceptance evidence."""

import copy
import json
import re
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
import xml.etree.ElementTree as ET

import windows_acceptance as acceptance


class WindowsAcceptanceTests(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory()
        self.addCleanup(self.temp.cleanup)
        self.path = Path(self.temp.name)
        self.manifest = {
            "schema_version": 1,
            "projects": ["Example.Tests"],
            "groups": [{
                "id": "example", "title": "Example",
                "required_tests": [{"project": "Example.Tests", "method": "Example.Tests.Form.Accept", "minimum_cases": 2}],
                "remaining_acceptance": ["Visual/operator check"],
            }],
        }
        self.rows = [("Example.Tests.Form.Accept", "Passed"), ("Example.Tests.Form.Accept", "Passed")]

    def write_trx(self, rows=None, total=None, summary="Completed"):
        rows = self.rows if rows is None else rows
        root = ET.Element("TestRun", xmlns="http://microsoft.com/schemas/VisualStudio/TeamTest/2010")
        definitions = ET.SubElement(root, "TestDefinitions")
        results = ET.SubElement(root, "Results")
        for index, (method, outcome) in enumerate(rows):
            test = ET.SubElement(definitions, "UnitTest", id=str(index))
            class_name, name = method.rsplit(".", 1)
            ET.SubElement(test, "TestMethod", className=class_name, name=name)
            result = ET.SubElement(results, "UnitTestResult", testId=str(index), executionId=str(index),
                                   testName=f"{method}(case: {index})", outcome=outcome)
            if outcome != "Passed":
                ET.SubElement(ET.SubElement(result, "Output"), "StdOut").text = "fixture reason"
        result_summary = ET.SubElement(root, "ResultSummary", outcome=summary)
        ET.SubElement(result_summary, "Counters", total=str(len(rows) if total is None else total),
                      executed=str(sum(r[1] != "NotExecuted" for r in rows)),
                      passed=str(sum(r[1] == "Passed" for r in rows)),
                      failed=str(sum(r[1] == "Failed" for r in rows)), notExecuted="0")
        path = self.path / "Example.Tests.trx"
        ET.ElementTree(root).write(path, encoding="utf-8", xml_declaration=True)
        return path

    def evaluate(self):
        return acceptance.evaluate(self.manifest, self.path)

    def test_repository_overlay_manifest_methods_exist_in_the_source(self):
        root = Path(__file__).resolve().parents[1]
        manifest = json.loads((root / "scripts/windows-acceptance.json").read_text(encoding="utf-8"))
        source = (root / "OpenNest.WinForms.Tests/PlateOverlapOverlayTests.cs").read_text(encoding="utf-8-sig")
        prefix = "OpenNest.WinForms.Tests.PlateOverlapOverlayTests."
        required = {test["method"] for group in manifest["groups"] for test in group["required_tests"]
                    if test["method"].startswith(prefix)}
        declared = {prefix + name for name in re.findall(r"\bpublic\s+(?:async\s+)?(?:void|Task)\s+(\w+)\s*\(", source)}
        self.assertTrue(required, "The overlay acceptance mapping must not disappear")
        self.assertFalse(required - declared, f"Stale overlay test names: {sorted(required - declared)}")

    def test_complete_theory_passes_and_retains_manual_gate(self):
        self.write_trx()
        report = self.evaluate()
        self.assertEqual("passed", report["automated_status"])
        self.assertEqual(2, report["groups"][0]["result_count"])
        self.assertEqual(["Visual/operator check"], report["groups"][0]["remaining_acceptance"])
        self.assertEqual(2, report["suites"]["Example.Tests"]["total"])

    def test_missing_or_malformed_file_fails(self):
        self.assertEqual("failed", self.evaluate()["automated_status"])
        (self.path / "Example.Tests.trx").write_text("<broken", encoding="utf-8")
        self.assertEqual("failed", self.evaluate()["automated_status"])

    def test_missing_method_or_theory_row_fails(self):
        for rows in ([self.rows[0]], [("Example.Tests.Other.Accept", "Passed")] * 2):
            with self.subTest(rows=rows):
                self.write_trx(rows)
                self.assertEqual("failed", self.evaluate()["automated_status"])

    def test_skip_failed_aborted_and_unknown_required_results_fail(self):
        for outcome in ("NotExecuted", "Failed", "Aborted", "TimedOut", "Unknown"):
            with self.subTest(outcome=outcome):
                self.write_trx([self.rows[0], (self.rows[1][0], outcome)])
                report = self.evaluate()
                self.assertEqual("failed", report["automated_status"])
                self.assertEqual("fixture reason", report["groups"][0]["tests"][1]["detail"])

    def test_unmapped_failed_test_still_fails_gate(self):
        self.write_trx(self.rows + [("Example.Tests.Other.Failure", "Failed")])
        self.assertEqual("failed", self.evaluate()["automated_status"])

    def test_unmapped_skip_is_explicit_not_a_pass(self):
        self.write_trx(self.rows + [("Example.Tests.Other.Optional", "NotExecuted")])
        report = self.evaluate()
        self.assertEqual("passed", report["automated_status"])
        suite = report["suites"]["Example.Tests"]
        self.assertEqual({"NotExecuted": 1, "Passed": 2}, suite["outcomes"])
        self.assertEqual("fixture reason", suite["results"][2]["detail"])

    def test_empty_or_inconsistent_counters_fail(self):
        for rows, total in (([], 0), (self.rows, 3)):
            self.write_trx(rows, total)
            self.assertEqual("failed", self.evaluate()["automated_status"])
        path = self.write_trx()
        path.write_text(path.read_text().replace('passed="2"', 'passed="1"'))
        self.assertEqual("failed", self.evaluate()["automated_status"])

    def test_contradictory_or_incomplete_counters_fail(self):
        changes = [("executed", "999"), ("executed", "-1"), ("executed", "0"),
                   ("executed", "bad"), ("executed", None), ("notExecuted", "1"),
                   ("completed", "999")]
        changes += [(key, "1") for key in ("aborted", "error", "timeout", "inconclusive",
                    "passedButRunAborted", "notRunnable", "disconnected", "warning",
                    "inProgress", "pending", "unknownCounter")]
        for key, value in changes:
            with self.subTest(counter=key, value=value):
                path = self.write_trx()
                tree = ET.parse(path)
                counters = tree.getroot().find(".//{*}Counters")
                assert counters is not None
                if value is None:
                    counters.attrib.pop(key)
                else:
                    counters.set(key, value)
                tree.write(path, encoding="utf-8", xml_declaration=True)
                self.assertEqual("failed", self.evaluate()["automated_status"])

    def test_aborted_run_fails_even_with_passed_rows(self):
        self.write_trx(summary="Aborted")
        self.assertEqual("failed", self.evaluate()["automated_status"])

    def test_failed_summary_and_bad_counters_retain_readable_evidence(self):
        rows = self.rows + [("Example.Tests.Other.Failure", "Failed"),
                            ("Example.Tests.Other.Optional", "NotExecuted")]
        for mode in ("Failed", "Aborted", "bad-counter", "missing-summary"):
            with self.subTest(mode=mode):
                path = self.write_trx(rows, summary=mode if mode in ("Failed", "Aborted") else "Completed")
                tree = ET.parse(path)
                root = tree.getroot()
                summary = root.find("{*}ResultSummary")
                assert summary is not None
                if mode == "bad-counter":
                    counters = summary.find("{*}Counters")
                    assert counters is not None
                    counters.set("total", "999")
                ET.SubElement(ET.SubElement(summary, "Output"), "StdOut").text = "runner failure detail"
                if mode == "missing-summary":
                    root.remove(summary)
                tree.write(path, encoding="utf-8", xml_declaration=True)
                report = self.evaluate()
                self.assertEqual("failed", report["automated_status"])
                self.assertIn("Example.Tests", report["suites"])
                suite = report["suites"]["Example.Tests"]
                self.assertEqual(4, suite["total"])
                self.assertEqual({"Passed": 2, "Failed": 1, "NotExecuted": 1}, suite["outcomes"])
                self.assertTrue(suite["validation_errors"])
                self.assertEqual("fixture reason", suite["results"][2]["detail"])
                self.assertEqual("fixture reason", suite["results"][3]["detail"])
                if mode != "missing-summary":
                    self.assertIn("runner failure detail", suite["summary_output"])
                self.assertEqual("failed", report["groups"][0]["automated_status"])

    def test_duplicate_or_unmapped_execution_fails(self):
        for old, new in (('executionId="1"', 'executionId="0"'),
                         ('testId="1"', 'testId="not-defined"'), ('id="1"', 'id="0"')):
            path = self.write_trx()
            path.write_text(path.read_text().replace(old, new))
            self.assertEqual("failed", self.evaluate()["automated_status"])

    def test_invalid_manifests_are_rejected(self):
        original = copy.deepcopy(self.manifest)
        for change in (
            lambda m: m.update(projects=[]),
            lambda m: m.update(groups=[]),
            lambda m: m["groups"].append(copy.deepcopy(m["groups"][0])),
            lambda m: m["groups"][0].update(required_tests=[]),
            lambda m: m["groups"][0]["required_tests"][0].update(minimum_cases=0),
            lambda m: m["groups"][0]["required_tests"][0].update(project="Unknown.Tests"),
        ):
            self.manifest = copy.deepcopy(original)
            change(self.manifest)
            with self.assertRaises(ValueError):
                self.evaluate()

    def test_cli_refuses_linux_runtime_and_dirty_source(self):
        self.write_trx()
        manifest = self.path / "manifest.json"
        manifest.write_text(json.dumps(self.manifest), encoding="utf-8")
        args = ["--results", str(self.path), "--manifest", str(manifest)]
        for system, dirty in (("Linux", ""), ("Windows", " M source.cs")):
            with self.subTest(system=system, dirty=dirty), \
                    patch.object(acceptance.platform, "system", return_value=system), \
                    patch.object(acceptance.platform, "platform", return_value="Synthetic parser fixture"), \
                    patch.object(acceptance.subprocess, "check_output", side_effect=["a" * 40, "b" * 40, dirty]), \
                    patch.dict(acceptance.os.environ, {"GITHUB_STEP_SUMMARY": ""}), \
                    patch("builtins.print"):
                self.assertEqual(1, acceptance.main(args))
                report = json.loads((self.path / "windows-acceptance.json").read_text())
                self.assertEqual("failed", report["automated_status"])
                self.assertTrue(report["errors"])


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