"""Tests for governance/risk_scorer.py."""

import sys
from pathlib import Path

sys.path.insert(0, str(Path.home() / "repos" / "darkplex-core"))

from cortex.governance.risk_scorer import RiskScorer, RiskResult, _classify_level


class TestClassifyLevel:
    def test_low(self):
        assert _classify_level(0) == "low"
        assert _classify_level(3) == "low"

    def test_elevated(self):
        assert _classify_level(4) == "elevated"
        assert _classify_level(6) == "elevated"

    def test_high(self):
        assert _classify_level(7) == "high"
        assert _classify_level(8) == "high"

    def test_critical(self):
        assert _classify_level(9) == "critical"
        assert _classify_level(10) == "critical"


class TestRiskResult:
    def test_acceptable(self):
        r = RiskResult(value=3, level="low", factors={})
        assert r.is_acceptable

    def test_not_acceptable(self):
        r = RiskResult(value=7, level="high", factors={})
        assert not r.is_acceptable


class TestRiskScorer:
    def setup_method(self):
        self.scorer = RiskScorer()

    def test_default_low_risk(self):
        result = self.scorer.score({"hour": 12})
        assert result.level == "low"
        assert result.is_acceptable

    def test_public_internal(self):
        result = self.scorer.score({"data_type": "public", "target": "internal", "hour": 12})
        assert result.value <= 3

    def test_confidential_external(self):
        result = self.scorer.score({"data_type": "confidential", "target": "external", "hour": 12})
        assert result.value >= 7

    def test_restricted_critical(self):
        result = self.scorer.score({"data_type": "restricted", "target": "external", "hour": 12})
        assert result.level in ("high", "critical")

    def test_off_hours_bonus(self):
        day = self.scorer.score({"data_type": "internal", "hour": 12})
        night = self.scorer.score({"data_type": "internal", "hour": 2})
        assert night.value > day.value

    def test_admin_role_reduces_risk(self):
        admin = self.scorer.score({"agent_role": "admin", "hour": 12})
        external = self.scorer.score({"agent_role": "external", "hour": 12})
        assert admin.value < external.value

    def test_factors_populated(self):
        result = self.scorer.score({"data_type": "internal", "target": "external", "hour": 10})
        assert "data_type" in result.factors
        assert "target" in result.factors
        assert "agent_role" in result.factors
        assert "time_of_day" in result.factors

    def test_clamped_0_10(self):
        # Even with extreme values, should be 0-10
        result = self.scorer.score({"data_type": "restricted", "target": "external", "agent_role": "external", "hour": 3})
        assert 0 <= result.value <= 10