from __future__ import annotations

import hashlib
import json
from pathlib import Path
import unittest

from govoplan_core.core.configuration_packages import (
    ConfigurationPackageManifest,
    ConfigurationPreflightContext,
    configuration_package_claim_issues,
    dry_run_configuration_package,
)


ROOT = Path(__file__).resolve().parents[1]
PACKAGE_ROOT = ROOT / "packages"


class ConfigurationPackageArtifactTests(unittest.TestCase):
    def test_product_package_manifests_are_portable_and_evidence_backed(self) -> None:
        paths = tuple(sorted(PACKAGE_ROOT.glob("*/*/package.json")))
        self.assertGreaterEqual(len(paths), 2)
        package_ids: set[str] = set()

        for path in paths:
            manifest = ConfigurationPackageManifest.from_mapping(
                json.loads(path.read_text(encoding="utf-8"))
            )
            self.assertNotIn(manifest.package_id, package_ids)
            package_ids.add(manifest.package_id)
            self.assertEqual((), configuration_package_claim_issues(manifest))
            for evidence in manifest.evidence:
                evidence_path = ROOT / evidence.reference
                self.assertTrue(
                    evidence_path.is_file(),
                    f"Missing evidence {evidence.reference} for {manifest.package_id}",
                )
                if evidence.checksum is not None:
                    self.assertEqual(
                        evidence.checksum,
                        "sha256:" + hashlib.sha256(evidence_path.read_bytes()).hexdigest(),
                        f"Stale evidence checksum for {manifest.package_id}: {evidence.reference}",
                    )
            for requirement in (
                *manifest.required_modules,
                *manifest.optional_modules,
            ):
                repository = ROOT.parent / (
                    "govoplan-" + requirement.module_id.replace("_", "-")
                )
                self.assertTrue(
                    repository.is_dir(),
                    f"Missing repository for {requirement.module_id}",
                )

            result = dry_run_configuration_package(
                manifest,
                (),
                ConfigurationPreflightContext(
                    installed_modules={
                        item.module_id: item.version or "workspace"
                        for item in manifest.required_modules
                    },
                    capabilities=frozenset(manifest.required_capabilities),
                ),
            )
            self.assertFalse(
                any(item.severity == "blocker" for item in result.diagnostics),
                tuple(item.to_dict() for item in result.diagnostics),
            )

        self.assertIn("product.governed-communication", package_ids)
        self.assertIn("product.governed-data-assurance", package_ids)
        self.assertIn("product.service-to-decision", package_ids)


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