import csv
import io
import json
import unittest
from pathlib import Path
from uuid import uuid4

import triage


ROOT = Path(__file__).parent


def load_fixture(name):
    return json.loads((ROOT / name).read_text(encoding="utf-8"))


class TriageTests(unittest.TestCase):
    def setUp(self):
        self.inventory = load_fixture("inventory.json")
        self.targets = load_fixture("targets.json")
        self.results = load_fixture("query-results.json")

    def rows(self, family="all", results=None, inventory=None):
        return triage.classify(
            self.inventory if inventory is None else inventory,
            self.targets,
            self.results if results is None else results,
            family,
        )

    def test_demo_fixture_has_candidate_nonmatch_missing_and_failed(self):
        rows = self.rows()
        self.assertEqual([row["mark"] for row in rows], ["×", "○", "?", "?"])
        self.assertIn("今回の候補なし", rows[0]["reason"])
        self.assertIn("一次候補", rows[1]["reason"])
        self.assertIn("データなし", rows[2]["reason"])
        self.assertIn("失敗", rows[3]["reason"])

    def test_exact_match_requires_all_four_identity_fields(self):
        result = dict(self.results[0], advisory_ids=[])
        result["platform"] = "different platform"
        rows = self.rows(family="ASA", results=[result])
        self.assertEqual([row["mark"] for row in rows], ["?", "?"])

    def test_complete_valid_full_result_without_id_is_only_a_nonmatch(self):
        results = [dict(self.results[0], advisory_ids=[])]
        row = self.rows(family="ASA", results=results)[0]
        self.assertEqual(row["mark"], "×")
        self.assertIn("今回の候補なし", row["reason"])

    def test_id_substring_is_not_an_exact_id_match(self):
        results = [dict(self.results[0], advisory_ids=["demo-0010"])]
        self.assertEqual(self.rows(family="ASA", results=results)[0]["mark"], "×")

    def test_same_version_from_another_platform_or_mode_is_not_reused(self):
        base = self.results[0]
        for changes in ({"platform": "other platform"}, {"mode": "transparent"}):
            with self.subTest(changes=changes):
                result = dict(base, **changes)
                self.assertEqual(self.rows(family="ASA", results=[result])[0]["mark"], "?")

    def test_failed_incomplete_and_invalid_version_are_unknown(self):
        base = self.results[0]
        for changes in (
            {"status": "failed"},
            {"all_pages": False},
            {"version_valid": False},
        ):
            with self.subTest(changes=changes):
                row = self.rows(family="ASA", results=[dict(base, **changes)])[0]
                self.assertEqual(row["mark"], "?")

    def test_no_result_empty_result_and_duplicate_result_are_unknown(self):
        self.assertEqual(self.rows(family="IOS", results=[])[0]["mark"], "?")
        duplicate = [self.results[0], dict(self.results[0])]
        self.assertEqual(self.rows(family="ASA", results=duplicate)[0]["mark"], "?")

    def test_malformed_result_document_and_record_never_become_negative(self):
        self.assertEqual(self.rows(results={"error": "not normalized"})[0]["mark"], "?")
        malformed = [dict(self.results[0], version_valid="true")]
        self.assertTrue(all(row["mark"] == "?" for row in self.rows(results=malformed)))
        missing_field = [dict(self.results[0])]
        del missing_field[0]["all_pages"]
        self.assertTrue(all(row["mark"] == "?" for row in self.rows(results=missing_field)))

    def test_invalid_inventory_and_targets_are_rejected(self):
        with self.assertRaises(triage.InputError):
            self.rows(inventory=[{"family": "ASA", "version": "9.18.4"}])
        with self.assertRaises(triage.InputError):
            triage.classify(self.inventory, [{"ticket": "T", "advisory_id": "demo-001"}], self.results)

    def test_family_filter_returns_only_requested_family(self):
        rows = self.rows(family="Nexus")
        self.assertEqual(len(rows), 1)
        self.assertEqual(rows[0]["family"], "Nexus")
        self.assertEqual(rows[0]["mark"], "?")

    def test_csv_has_bom_header_order_and_quotes_multiline_values(self):
        row = self.rows()[0]
        row["title"] = "ignored extra"  # Writer selects only the documented columns.
        row["reason"] = "line one, with comma\nline two"
        output = ROOT / f".test-tickets-{uuid4().hex}.csv"
        try:
            triage.write_csv(output, [row])
            raw = output.read_bytes()
            self.assertTrue(raw.startswith(b"\xef\xbb\xbf"))
            parsed = list(csv.DictReader(io.StringIO(raw.decode("utf-8-sig"))))
            self.assertEqual(tuple(parsed[0]), triage.CSV_FIELDS)
            self.assertEqual(parsed[0]["reason"], row["reason"])
        finally:
            output.unlink(missing_ok=True)

    def test_csv_formula_prefix_and_existing_file_refusal(self):
        row = self.rows()[0]
        row["ticket"] = "=HYPERLINK(\"https://bad.invalid\")"
        output = ROOT / f".test-tickets-{uuid4().hex}.csv"
        try:
            triage.write_csv(output, [row])
            with output.open(encoding="utf-8-sig", newline="") as handle:
                parsed = list(csv.DictReader(handle))
            self.assertEqual(parsed[0]["ticket"], "'" + row["ticket"])
            with self.assertRaises(FileExistsError):
                triage.write_csv(output, [row])
        finally:
            output.unlink(missing_ok=True)


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