from athena.core.permissions import (
    get_permissions,
    Permission,
    Sensitivity,
    Action
)

perms = get_permissions()
perms.check("smart_search")  # Raises PermissionDenied if blocked
perms.label("session_content")  # Returns Sensitivity.INTERNAL
perms.set_secret_mode(True)  # Activates demo/external mode

class Permission(str, Enum):
    READ = "read"          # Can query / read data
    WRITE = "write"        # Can modify session logs, checkpoints
    ADMIN = "admin"        # Can modify config, clear caches, manage sessions
    DANGEROUS = "dangerous" # Can delete data, run shell commands

DANGEROUS > ADMIN > WRITE > READ

_PERMISSION_LEVEL = {
    Permission.READ: 0,
    Permission.WRITE: 1,
    Permission.ADMIN: 2,
    Permission.DANGEROUS: 3,
}

class Sensitivity(str, Enum):
    PUBLIC = "public"      # Safe for external sharing, demos, GitHub
    INTERNAL = "internal"  # Normal operational data, session logs
    SECRET = "secret"      # API keys, credentials, personal finances, trading

SECRET_PATTERNS = [
    "api_key", "api-key", "apikey",
    "secret_key", "secret-key",
    "password", "passwd",
    "SUPABASE_KEY", "GOOGLE_API_KEY", "ANTHROPIC_API_KEY",
    "private_key", "access_token", "bearer",
    "trading", "eurusd", "forex",
    "P&L", "profit_loss",
    "bank_account", "credit_card",
    ".env",
]

INTERNAL_PATTERNS = [
    "session_log",
    "checkpoint",
    "canonical",
    "memory_bank",
    "decision_ledger",
    "user_profile",
    "userContext",
]

TOOL_REGISTRY: dict[str, dict[str, Any]] = {
    "smart_search": {
        "permission": Permission.READ,
        "sensitivity": Sensitivity.INTERNAL,
        "description": "Search knowledge base",
    },
    "quicksave": {
        "permission": Permission.WRITE,
        "sensitivity": Sensitivity.INTERNAL,
        "description": "Save checkpoint to session log",
    },
    "health_check": {
        "permission": Permission.READ,
        "sensitivity": Sensitivity.PUBLIC,
        "description": "System health audit",
    },
    "recall_session": {
        "permission": Permission.READ,
        "sensitivity": Sensitivity.INTERNAL,
        "description": "Read session log content",
    },
    "clear_cache": {
        "permission": Permission.ADMIN,
        "sensitivity": Sensitivity.INTERNAL,
        "description": "Clear search cache",
    },
    "update_canonical": {
        "permission": Permission.ADMIN,
        "sensitivity": Sensitivity.SECRET,
        "description": "Modify canonical memory",
    },
}

from athena.core.permissions import get_permissions

perms = get_permissions()

@dataclass
class PermissionEngine:
    # Current caller's maximum permission level
    caller_level: Permission = Permission.WRITE
    
    # Secret mode — when True, blocks access to INTERNAL and SECRET data
    secret_mode: bool = False
    
    # Audit log
    audit_log: list[dict] = field(default_factory=list)
    
    # State file for persistence
    _state_path: Path | None = None
    
    # Granular permission engine
    _granular: GranularPermissionEngine | None = None

def check(self, tool_name: str) -> bool:
    """
    Check if the current caller has permission to execute a tool.
    Raises PermissionDenied if not.
    Returns True if allowed.
    """

from athena.core.permissions import get_permissions, PermissionDenied

perms = get_permissions()
try:
    perms.check("smart_search")  # OK if caller_level >= READ
    perms.check("clear_cache")   # Raises if caller_level < ADMIN
except PermissionDenied as e:
    print(f"Blocked: {e}")

def check_sensitivity(self, tool_name: str) -> bool:
    """
    Check if tool output is allowed under current sensitivity mode.
    In secret_mode, only PUBLIC tools are allowed.
    Raises SecretModeViolation if blocked.
    """

perms.set_secret_mode(True)

try:
    perms.check_sensitivity("health_check")  # OK (PUBLIC)
    perms.check_sensitivity("smart_search")  # Raises (INTERNAL)
except SecretModeViolation as e:
    print(f"Blocked in demo mode: {e}")

def gate(self, tool_name: str, input_str: str = "*") -> bool:
    """
    Combined gate — checks permission, sensitivity, AND granular rules.
    This is the main entry point for the MCP middleware.
    """

perms.gate("bash", "git status")  # OK
perms.gate("bash", "rm -rf /")    # Raises PermissionDenied
perms.gate("read", ".env")       # Raises PermissionDenied

def label(self, content: str) -> Sensitivity:
    """Auto-classify content sensitivity based on pattern matching."""

perms.label("ANTHROPIC_API_KEY=sk-...")  # Sensitivity.SECRET
perms.label("session_log content")       # Sensitivity.INTERNAL
perms.label("public documentation")      # Sensitivity.PUBLIC

def redact(self, content: str) -> str:
    """
    Redact secret patterns from content.
    Used when secret_mode is active but data must still flow.
    """

perms.set_secret_mode(True)
text = "API key: GOOGLE_API_KEY=abc123"
redacted = perms.redact(text)
print(redacted)  # "API key: [REDACTED]=abc123"

def set_secret_mode(self, enabled: bool) -> dict:
    """Toggle secret/demo mode."""

result = perms.set_secret_mode(True)
print(result)

{
    "secret_mode": True,
    "effect": "Only PUBLIC tools accessible",
    "blocked_tools": [
        "smart_search",
        "quicksave",
        "recall_session",
        "governance_status",
        "clear_cache",
        "update_canonical",
        "run_evaluator"
    ]
}

def set_caller_level(self, level: Permission) -> dict:
    """Set the caller's permission level."""

from athena.core.permissions import Permission

result = perms.set_caller_level(Permission.ADMIN)
print(result)

{
    "caller_level": "admin",
    "accessible_tools": [
        "smart_search",
        "quicksave",
        "health_check",
        "recall_session",
        "governance_status",
        "list_memory_paths",
        "clear_cache",
        "run_evaluator"
    ]
}

class Action(str, Enum):
    ALLOW = "allow"  # Run without approval
    ASK = "ask"      # Prompt for approval
    DENY = "deny"    # Block the action

class GranularPermissionEngine:
    """
    Glob-based permission engine with allow/ask/deny per tool.
    Rules are evaluated in order; last matching rule wins.
    """

DEFAULT_GRANULAR_RULES = [
    {"tool": "*", "pattern": "*", "action": "allow"},
    {"tool": "read", "pattern": "*.env", "action": "deny"},
    {"tool": "read", "pattern": "*.env.*", "action": "deny"},
    {"tool": "read", "pattern": "*.env.example", "action": "allow"},
    {"tool": "bash", "pattern": "rm *", "action": "deny"},
    {"tool": "bash", "pattern": "git *", "action": "allow"},
    {"tool": "doom_loop", "pattern": "*", "action": "ask"},
    {"tool": "external_directory", "pattern": "*", "action": "ask"},
]

@dataclass
class GranularRule:
    tool: str      # Tool name or "*" for all
    pattern: str   # Glob pattern for tool input
    action: Action # allow, ask, or deny
    
    def matches(self, tool_name: str, input_str: str) -> bool:
        """Check if this rule matches the given tool and input."""
        tool_match = self.tool == "*" or fnmatch.fnmatch(tool_name, self.tool)
        pattern_match = fnmatch.fnmatch(input_str, self.pattern)
        return tool_match and pattern_match

rule = GranularRule(
    tool="bash",
    pattern="git *",
    action=Action.ALLOW
)

rule.matches("bash", "git status")  # True
rule.matches("bash", "rm file")     # False
rule.matches("read", "git status")  # False

perms = get_permissions()
perms._granular.add_rule(
    tool="bash",
    pattern="docker *",
    action=Action.ASK
)

class PermissionDenied(Exception):
    """Raised when a tool call lacks required capability."""
    
    def __init__(self, tool: str, required: Permission, granted: Permission):
        self.tool = tool
        self.required = required
        self.granted = granted

try:
    perms.check("clear_cache")
except PermissionDenied as e:
    print(f"Tool: {e.tool}")
    print(f"Required: {e.required}")
    print(f"Granted: {e.granted}")

class SecretModeViolation(Exception):
    """Raised when secret data is accessed in public/demo mode."""
    
    def __init__(self, tool: str, data_sensitivity: Sensitivity):
        self.tool = tool
        self.data_sensitivity = data_sensitivity

status = perms.get_status()
print(status)

{
    "caller_level": "write",
    "secret_mode": False,
    "registered_tools": 18,
    "accessible_tools": [
        "smart_search",
        "quicksave",
        "health_check",
        "recall_session",
        "governance_status",
        "list_memory_paths"
    ],
    "blocked_tools": [
        "clear_cache",
        "update_canonical",
        "run_evaluator"
    ],
    "audit_entries": 42,
    "granular_rules": [
        {"tool": "*", "pattern": "*", "action": "allow"},
        {"tool": "read", "pattern": "*.env", "action": "deny"}
    ]
}

manifest = perms.get_tool_manifest()
for tool in manifest:
    print(f"{tool['tool']}: {tool['permission']} / {tool['sensitivity']}")

[
    {
        "tool": "smart_search",
        "permission": "read",
        "sensitivity": "internal",
        "description": "Search knowledge base",
        "accessible": True
    },
    ...
]

_state_path = PROJECT_ROOT / ".agent" / "state" / "permissions.json"

{
  "secret_mode": false,
  "caller_level": "write",
  "last_updated": "2026-03-03T14:32:15.123456"
}

rules_path = PROJECT_ROOT / ".agent" / "state" / "permission_rules.json"

perms.audit_log
# [
#   {
#     "timestamp": "2026-03-03T14:32:15.123456",
#     "action": "check",
#     "target": "smart_search",
#     "required": "read",
#     "granted": "write",
#     "allowed": True
#   },
#   ...
# ]