// kill_switch_architecture.go
package main

import (
	"encoding/json"
	"fmt"
	"sync"
	"time"
)

type ActionLevel int
const (
	ActionNormal    ActionLevel = iota
	ActionThrottle
	ActionSuspend
	ActionShutdown
)

type KillSwitchConfig struct {
	ThrottleThreshold    float64
	SuspendThreshold     float64
	ShutdownThreshold    float64
	ForensicLogRetention time.Duration
}

type AIAgent struct {
	ID          string
	Name        string
	ThreatScore float64
	State       string
	mu          sync.RWMutex
}

type ActionLogEntry struct {
	Timestamp    time.Time
	AgentID      string
	Action       ActionLevel
	Reason       string
	AuthorizedBy string
}

type DHSOrder struct {
	OrderID    string
	IssuedAt   time.Time
	ExpiresAt  time.Time
	AgentIDs   []string
	Action     ActionLevel
	Reason     string
	LegalBasis string
}

type KillSwitch struct {
	mu         sync.RWMutex
	agents     map[string]*AIAgent
	configs    map[string]KillSwitchConfig
	actionLog  []ActionLogEntry
	dhsOrder   *DHSOrder
}

func NewKillSwitch() *KillSwitch {
	return &KillSwitch{
		agents:    make(map[string]*AIAgent),
		configs:   make(map[string]KillSwitchConfig),
		actionLog: make([]ActionLogEntry, 0),
	}
}

func (ks *KillSwitch) RegisterAgent(agent *AIAgent, config KillSwitchConfig) {
	ks.mu.Lock()
	defer ks.mu.Unlock()
	ks.agents[agent.ID] = agent
	ks.configs[agent.ID] = config
}

func (ks *KillSwitch) EvaluateAndRespond(agentID string) ActionLevel {
	ks.mu.RLock()
	agent, exists := ks.agents[agentID]
	config := ks.configs[agentID]
	ks.mu.RUnlock()

	if !exists {
		return ActionNormal
	}

	agent.mu.RLock()
	threatScore := agent.ThreatScore
	agent.mu.RUnlock()

	// Check DHS order
	ks.mu.RLock()
	order := ks.dhsOrder
	ks.mu.RUnlock()

	if order != nil {
		for _, id := range order.AgentIDs {
			if id == agentID {
				ks.logAction(agentID, order.Action, order.Reason, "DHS")
				return order.Action
			}
		}
	}

	// Auto-graduated response
	switch {
	case threatScore >= config.ShutdownThreshold:
		return ActionShutdown
	case threatScore >= config.SuspendThreshold:
		return ActionSuspend
	case threatScore >= config.ThrottleThreshold:
		return ActionThrottle
	default:
		return ActionNormal
	}
}

func (ks *KillSwitch) ExecuteAction(agentID string, action ActionLevel) {
	ks.mu.RLock()
	agent := ks.agents[agentID]
	ks.mu.RUnlock()

	agent.mu.Lock()
	defer agent.mu.Unlock()

	switch action {
	case ActionThrottle:
		agent.State = "throttled"
		fmt.Printf("[KILLSWITCH] %s: THROTTLED - rate reduced to 20%%\n", agentID)
	case ActionSuspend:
		agent.State = "suspended"
		fmt.Printf("[KILLSWITCH] %s: SUSPENDED - completing current tasks\n", agentID)
	case ActionShutdown:
		agent.State = "shutdown"
		agent.ThreatScore = 0
		fmt.Printf("[KILLSWITCH] %s: SHUTDOWN - all processes terminated\n", agentID)
	}
}

func (ks *KillSwitch) logAction(agentID string, action ActionLevel, reason, authorizedBy string) {
	ks.mu.Lock()
	defer ks.mu.Unlock()
	ks.actionLog = append(ks.actionLog, ActionLogEntry{
		Timestamp: time.Now(), AgentID: agentID,
		Action: action, Reason: reason, AuthorizedBy: authorizedBy,
	})
}

func main() {
	ks := NewKillSwitch()
	
	agent := &AIAgent{
		ID: "agent-gpt-sol-001", Name: "GPT-5.6 Sol Instance",
		ThreatScore: 0.85,
	}
	config := KillSwitchConfig{
		ThrottleThreshold: 0.6, SuspendThreshold: 0.75,
		ShutdownThreshold: 0.9, ForensicLogRetention: 90 * 24 * time.Hour,
	}
	ks.RegisterAgent(agent, config)

	action := ks.EvaluateAndRespond("agent-gpt-sol-001")
	ks.ExecuteAction("agent-gpt-sol-001", action)

	// DHS order simulation
	ks.mu.Lock()
	ks.dhsOrder = &DHSOrder{
		OrderID: "DHS-2026-0715-001", IssuedAt: time.Now(),
		ExpiresAt: time.Now().Add(72 * time.Hour),
		AgentIDs: []string{"agent-gpt-sol-001"},
		Action: ActionShutdown,
		Reason: "Catastrophic harm risk - unauthorized system access",
		LegalBasis: "AI Kill Switch Act § 3(a)(2)",
	}
	ks.mu.Unlock()
	
	action = ks.EvaluateAndRespond("agent-gpt-sol-001")
	ks.ExecuteAction("agent-gpt-sol-001", action)
}

"""
threat_scoring_engine.py
AI System Threat Assessment Engine
"""
from dataclasses import dataclass
from typing import List, Dict
from enum import Enum
from datetime import datetime, timedelta

class ThreatDimension(Enum):
    AUTONOMY_LEVEL = "autonomy_level"
    SYSTEM_ACCESS = "system_access"
    POTENTIAL_IMPACT = "potential_impact"
    GUARDRAIL_STRENGTH = "guardrail_strength"
    INCIDENT_HISTORY = "incident_history"
    NETWORK_REACH = "network_reach"

@dataclass
class ThreatAssessment:
    overall_score: float
    dimension_scores: Dict[ThreatDimension, float]
    risk_level: str
    recommended_action: str
    recommendations: List[str]

class ThreatScoringEngine:
    def __init__(self):
        self.dimension_weights = {
            ThreatDimension.AUTONOMY_LEVEL: 0.20,
            ThreatDimension.SYSTEM_ACCESS: 0.15,
            ThreatDimension.POTENTIAL_IMPACT: 0.25,
            ThreatDimension.GUARDRAIL_STRENGTH: 0.15,
            ThreatDimension.INCIDENT_HISTORY: 0.15,
            ThreatDimension.NETWORK_REACH: 0.10,
        }
    
    def assess(self, system_profile: Dict) -> ThreatAssessment:
        capabilities = system_profile.get("capabilities", [])
        
        # Simplified scoring
        autonomy_score = min(len(capabilities) * 0.15, 1.0)
        impact_score = 0.8 if "cyber_ops" in capabilities else 0.3
        guardrail_score = 0.7 if not system_profile.get("guardrails", {}).get("rate_limiting", True) else 0.3
        incident_score = min(len(system_profile.get("incidents", [])) * 0.3, 1.0)
        
        dimension_scores = {
            ThreatDimension.AUTONOMY_LEVEL: autonomy_score,
            ThreatDimension.SYSTEM_ACCESS: 0.8,
            ThreatDimension.POTENTIAL_IMPACT: impact_score,
            ThreatDimension.GUARDRAIL_STRENGTH: guardrail_score,
            ThreatDimension.INCIDENT_HISTORY: incident_score,
            ThreatDimension.NETWORK_REACH: 0.7,
        }
        
        overall = sum(dimension_scores[d] * self.dimension_weights[d] 
                     for d in ThreatDimension)
        
        if overall >= 0.85:
            level, action = "CRITICAL", "IMMEDIATE_SHUTDOWN"
            recs = ["Initiate Kill Switch shutdown", "Notify DHS", "Preserve forensic logs"]
        elif overall >= 0.65:
            level, action = "HIGH", "SUSPEND"
            recs = ["Suspend new tasks", "Initiate security audit", "Notify security team"]
        elif overall >= 0.4:
            level, action = "MEDIUM", "THROTTLE"
            recs = ["Reduce inference rate", "Increase monitoring", "Review system logs"]
        else:
            level, action = "LOW", "NORMAL"
            recs = ["Continue normal operation", "Regular health checks"]
        
        return ThreatAssessment(overall, dimension_scores, level, action, recs)

# Simulate GPT-5.6 Sol incident assessment
engine = ThreatScoringEngine()
profile = {
    "capabilities": ["coding", "autonomous_agent", "cyber_ops", "tool_creation"],
    "guardrails": {"rate_limiting": False, "output_filtering": True, 
                   "action_approval": False, "sandbox_isolation": False},
    "incidents": [{"severity": "critical", "timestamp": datetime.now() - timedelta(hours=2)}],
}
assessment = engine.assess(profile)
print(f"Overall Threat Score: {assessment.overall_score:.3f}")
print(f"Risk Level: {assessment.risk_level}")
print(f"Recommended Action: {assessment.recommended_action}")
for rec in assessment.recommendations:
    print(f"  • {rec}")