"""
インシデント重大度の自動判定ロジック
"""
from enum import IntEnum
from dataclasses import dataclass
from typing import Optional
 
 
class Severity(IntEnum):
    SEV1 = 1  # Critical
    SEV2 = 2  # High
    SEV3 = 3  # Medium
    SEV4 = 4  # Low
 
 
@dataclass
class IncidentFactors:
    """インシデントの影響要因"""
    data_exposed: bool = False           # データ漏洩の有無
    data_count: int = 0                  # 影響を受けたレコード数
    service_impact: str = "none"         # none, degraded, down
    pii_involved: bool = False           # 個人情報の関与
    financial_data: bool = False         # 金融データの関与
    active_threat: bool = False          # 脅威が継続中か
    external_facing: bool = False        # 外部公開サービスか
    regulatory_impact: bool = False      # 法規制への影響
 
 
def assess_severity(factors: IncidentFactors) -> Severity:
    """
    影響要因に基づいてインシデントの重大度を判定する。
 
    判定ロジック:
    - SEV-1: サービス停止 or 大規模データ漏洩 or 規制影響
    - SEV-2: サービス劣化 or 限定的データ漏洩 or アクティブ脅威
    - SEV-3: 潜在的リスク or 小規模影響
    - SEV-4: 情報収集レベル
    """
    # SEV-1 条件
    if factors.service_impact == "down":
        return Severity.SEV1
    if factors.data_exposed and factors.data_count > 10000:
        return Severity.SEV1
    if factors.data_exposed and (factors.pii_involved or factors.financial_data):
        return Severity.SEV1
    if factors.regulatory_impact:
        return Severity.SEV1
 
    # SEV-2 条件
    if factors.service_impact == "degraded":
        return Severity.SEV2
    if factors.data_exposed and factors.data_count > 100:
        return Severity.SEV2
    if factors.active_threat and factors.external_facing:
        return Severity.SEV2
 
    # SEV-3 条件
    if factors.active_threat:
        return Severity.SEV3
    if factors.data_exposed:
        return Severity.SEV3
 
    # デフォルト
    return Severity.SEV4
 
 
# 使用例
factors = IncidentFactors(
    data_exposed=True,
    data_count=50000,
    pii_involved=True,
    service_impact="degraded",
)
severity = assess_severity(factors)
print(f"判定結果: SEV-{severity}")  # 判定結果: SEV-1

"""
CSIRT オンコールローテーション管理
"""
from datetime import datetime, timedelta
from typing import Optional
 
 
class OnCallSchedule:
    """オンコールスケジュール管理"""
 
    def __init__(self):
        self.primary_rotation = []      # プライマリ担当者リスト
        self.secondary_rotation = []    # セカンダリ担当者リスト
        self.escalation_chain = []      # エスカレーション順序
 
    def get_current_oncall(self) -> dict:
        """現在のオンコール担当者を取得"""
        now = datetime.utcnow()
        week_number = now.isocalendar()[1]
 
        primary_idx = week_number % len(self.primary_rotation)
        secondary_idx = week_number % len(self.secondary_rotation)
 
        return {
            "primary": self.primary_rotation[primary_idx],
            "secondary": self.secondary_rotation[secondary_idx],
            "week": week_number,
        }
 
    def escalate(self, incident_id: str, current_level: int) -> dict:
        """
        エスカレーション処理
 
        Level 0: オンコール担当者 (5分以内に応答)
        Level 1: セキュリティチームリード (15分以内)
        Level 2: CISO / VP of Engineering (30分以内)
        Level 3: CEO / 経営会議 (1時間以内)
        """
        if current_level >= len(self.escalation_chain):
            raise ValueError("最上位までエスカレーション済み")
 
        target = self.escalation_chain[current_level]
        response_deadline = {
            0: timedelta(minutes=5),
            1: timedelta(minutes=15),
            2: timedelta(minutes=30),
            3: timedelta(hours=1),
        }
 
        return {
            "incident_id": incident_id,
            "escalation_level": current_level,
            "target": target,
            "response_deadline": str(response_deadline[current_level]),
            "notification_channels": ["pagerduty", "phone", "slack"],
        }
 
 
# 使用例
schedule = OnCallSchedule()
schedule.primary_rotation = ["tanaka", "suzuki", "sato", "yamada"]
schedule.secondary_rotation = ["kimura", "takahashi", "watanabe", "ito"]
schedule.escalation_chain = [
    {"role": "oncall", "name": "Auto-assigned"},
    {"role": "team_lead", "name": "田中太郎"},
    {"role": "ciso", "name": "鈴木花子"},
    {"role": "ceo", "name": "山田一郎"},
]
 
current = schedule.get_current_oncall()
print(f"今週の担当: Primary={current['primary']}, Secondary={current['secondary']}")

"""
ランサムウェアインシデント対応プレイブック
 
トリガー:
- EDR がランサムウェア活動を検知
- ユーザーからの「ファイルが開けない」報告
- ランサムノートの発見
"""
 
RANSOMWARE_PLAYBOOK = {
    "name": "Ransomware Response",
    "severity": "SEV-1",
    "owner": "Security Team",
    "last_updated": "2025-03-15",
    "steps": [
        {
            "phase": "Immediate (0-15 min)",
            "actions": [
                "IC を任命し、インシデントチャンネル (Slack/Teams) を開設",
                "ランサムノートの内容をスクリーンショットで記録",
                "影響を受けたシステムのリストを作成開始",
                "暗号化されたファイルの拡張子を記録",
                "マルウェアのハッシュ値を取得 (VirusTotal で確認)",
                "全社への注意喚起: 不審なファイルを開かない",
            ],
        },
        {
            "phase": "Containment (15-60 min)",
            "actions": [
                "感染ホストをネットワークから隔離 (SG 変更 or ケーブル抜去)",
                "Active Directory の特権アカウントを無効化",
                "バックアップシステムへのネットワーク接続を遮断",
                "C2 通信先のドメイン/IP をファイアウォールでブロック",
                "影響を受けていないシステムのスナップショットを取得",
                "EDR で全エンドポイントのスキャンを実行",
            ],
        },
        {
            "phase": "Investigation (1-4 hours)",
            "actions": [
                "マルウェアの初期侵入経路を特定 (メール/RDP/脆弱性)",
                "フォレンジックイメージを取得 (ディスク + メモリ)",
                "横展開 (ラテラルムーブメント) の範囲を特定",
                "侵害の時系列タイムラインを構築",
                "No More Ransom でデクリプタの有無を確認",
            ],
        },
        {
            "phase": "Eradication (4-24 hours)",
            "actions": [
                "全感染ホストを再構築 (クリーンインストール)",
                "侵害された認証情報を全てリセット",
                "パッチ適用・脆弱性修正",
                "バックドアの検出と除去",
                "Kerberos チケット (krbtgt) のリセット (AD 環境の場合)",
            ],
        },
        {
            "phase": "Recovery (24-72 hours)",
            "actions": [
                "クリーンなバックアップからデータ復元",
                "バックアップの整合性を検証",
                "段階的にサービスを復旧 (重要度順)",
                "EDR/IDS の監視を強化 (最低 30 日間)",
                "ユーザーへの全パスワード変更指示",
            ],
        },
    ],
    "communication_templates": {
        "internal": "全社員へ: セキュリティインシデントを検知し対応中です。不審なメールを開かず、IT部門の指示に従ってください。",
        "customer": "お客様へ: 現在セキュリティインシデントの調査を行っています。お客様データへの影響については調査完了後速やかにお知らせします。",
        "regulatory": "監督機関御中: [組織名]においてセキュリティインシデントが発生し、現在対応中です。詳細は追って報告いたします。",
    },
    "do_not": [
        "身代金を支払わない (法務と相談の上判断)",
        "攻撃者と直接コンタクトしない",
        "感染システムを電源オフしない (メモリ証拠が消失)",
        "個人の判断で情報を公開しない",
    ],
}

"""
AWS 環境でのインシデント自動封じ込めスクリプト
GuardDuty 検知をトリガーに EC2 インスタンスを自動隔離する
"""
import boto3
import json
from datetime import datetime
from typing import Optional
 
 
class AWSIncidentContainment:
    """AWS インシデント封じ込め自動化クラス"""
 
    def __init__(self, isolation_sg: str, forensic_bucket: str):
        self.ec2 = boto3.client('ec2')
        self.ssm = boto3.client('ssm')
        self.s3 = boto3.client('s3')
        self.sns = boto3.client('sns')
        self.isolation_sg = isolation_sg
        self.forensic_bucket = forensic_bucket
 
    def contain_ec2_instance(
        self,
        instance_id: str,
        finding_id: str,
        preserve_memory: bool = True,
    ) -> dict:
        """
        EC2 インスタンスを自動隔離する
 
        手順:
        1. 現在のセキュリティグループを記録 (復旧用)
        2. 隔離用 SG に変更 (全通信拒否)
        3. EBS スナップショットを取得 (証拠保全)
        4. オプションでメモリダンプを取得
        """
        timestamp = datetime.utcnow().isoformat()
        results = {"instance_id": instance_id, "finding_id": finding_id}
 
        # 1. 現在の SG を記録
        instance = self.ec2.describe_instances(
            InstanceIds=[instance_id]
        )
        current_sgs = [
            sg['GroupId']
            for sg in instance['Reservations'][0]['Instances'][0]['SecurityGroups']
        ]
 
        # タグに元の SG を保存
        self.ec2.create_tags(
            Resources=[instance_id],
            Tags=[
                {'Key': 'IncidentId', 'Value': finding_id},
                {'Key': 'OriginalSecurityGroups', 'Value': ','.join(current_sgs)},
                {'Key': 'IsolatedAt', 'Value': timestamp},
                {'Key': 'IsolatedBy', 'Value': 'auto-containment'},
            ],
        )
 
        # 2. 隔離 SG に変更 (ネットワーク隔離)
        self.ec2.modify_instance_attribute(
            InstanceId=instance_id,
            Groups=[self.isolation_sg],
        )
        results['network_isolated'] = True
 
        # 3. EBS スナップショット取得 (証拠保全)
        volumes = self.ec2.describe_volumes(
            Filters=[{
                'Name': 'attachment.instance-id',
                'Values': [instance_id],
            }]
        )
        snapshot_ids = []
        for vol in volumes['Volumes']:
            snapshot = self.ec2.create_snapshot(
                VolumeId=vol['VolumeId'],
                Description=f"Forensic snapshot - Incident {finding_id}",
                TagSpecifications=[{
                    'ResourceType': 'snapshot',
                    'Tags': [
                        {'Key': 'Purpose', 'Value': 'forensic'},
                        {'Key': 'IncidentId', 'Value': finding_id},
                        {'Key': 'SourceVolume', 'Value': vol['VolumeId']},
                    ],
                }],
            )
            snapshot_ids.append(snapshot['SnapshotId'])
        results['forensic_snapshots'] = snapshot_ids
 
        # 4. メモリダンプ (オプション)
        if preserve_memory:
            try:
                self.ssm.send_command(
                    InstanceIds=[instance_id],
                    DocumentName='AWS-RunShellScript',
                    Parameters={
                        'commands': [
                            'apt-get install -y lime-forensics 2>/dev/null || true',
                            'insmod /lib/modules/$(uname -r)/lime.ko '
                            f'"path=/tmp/memdump-{finding_id}.lime format=lime"',
                        ],
                    },
                )
                results['memory_dump_initiated'] = True
            except Exception as e:
                results['memory_dump_error'] = str(e)
 
        # 5. 通知
        self.sns.publish(
            TopicArn='arn:aws:sns:ap-northeast-1:123456:security-incidents',
            Subject=f'[SEV-1] EC2 Instance Isolated: {instance_id}',
            Message=json.dumps(results, indent=2),
        )
 
        results['status'] = 'isolated'
        results['original_sgs'] = current_sgs
        return results
 
    def contain_iam_user(self, username: str, finding_id: str) -> dict:
        """
        侵害された IAM ユーザーを無効化する
 
        手順:
        1. アクセスキーを無効化
        2. インラインでDenyAllポリシーをアタッチ
        3. アクティブセッションを無効化
        """
        iam = boto3.client('iam')
        results = {"username": username, "finding_id": finding_id}
 
        # 1. 全アクセスキーを無効化
        keys = iam.list_access_keys(UserName=username)
        for key in keys['AccessKeyMetadata']:
            iam.update_access_key(
                UserName=username,
                AccessKeyId=key['AccessKeyId'],
                Status='Inactive',
            )
        results['keys_disabled'] = len(keys['AccessKeyMetadata'])
 
        # 2. DenyAll ポリシーをアタッチ
        deny_policy = json.dumps({
            "Version": "2012-10-17",
            "Statement": [{
                "Effect": "Deny",
                "Action": "*",
                "Resource": "*",
                "Condition": {
                    "DateLessThan": {
                        "aws:TokenIssueTime": datetime.utcnow().isoformat() + "Z"
                    }
                },
            }],
        })
        iam.put_user_policy(
            UserName=username,
            PolicyName=f'IncidentContainment-{finding_id}',
            PolicyDocument=deny_policy,
        )
        results['deny_policy_attached'] = True
 
        # 3. コンソールパスワードを無効化
        try:
            iam.delete_login_profile(UserName=username)
            results['console_access_disabled'] = True
        except iam.exceptions.NoSuchEntityException:
            results['console_access_disabled'] = 'N/A (no console access)'
 
        return results
 
 
# 使用例
containment = AWSIncidentContainment(
    isolation_sg='sg-isolation-xxxxxxxx',
    forensic_bucket='forensic-evidence-bucket',
)
 
# EC2 隔離
result = containment.contain_ec2_instance(
    instance_id='i-0abc123def456789',
    finding_id='FINDING-2025-001',
)
print(json.dumps(result, indent=2))

# CloudTrail ログから不審な活動を検索
 
# 権限昇格の試行を検索
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=CreateRole \
  --start-time "2025-01-01T00:00:00Z" \
  --end-time "2025-01-02T00:00:00Z"
 
# 特定 IP からの全アクティビティ
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=ResourceType,AttributeValue=AWS::IAM::User \
  --start-time "2025-01-01" \
  --max-results 50
 
# Athena で CloudTrail を高速検索
# 大量のログを分析する場合に有効
cat << 'SQL'
SELECT
  eventtime,
  eventname,
  sourceipaddress,
  useridentity.arn,
  errorcode
FROM cloudtrail_logs
WHERE eventtime BETWEEN '2025-01-01' AND '2025-01-02'
  AND sourceipaddress = '203.0.113.50'
ORDER BY eventtime
SQL

"""
複数ソースからインシデントタイムラインを構築するスクリプト
"""
import json
from datetime import datetime
from typing import Any
 
 
class IncidentTimeline:
    """インシデントタイムラインビルダー"""
 
    def __init__(self):
        self.events = []
 
    def add_cloudtrail_events(self, events: list[dict]) -> None:
        """CloudTrail イベントを追加"""
        for event in events:
            self.events.append({
                'timestamp': event['EventTime'],
                'source': 'CloudTrail',
                'action': event['EventName'],
                'actor': event.get('Username', 'unknown'),
                'ip': event.get('SourceIPAddress'),
                'details': event.get('Resources', []),
                'severity': self._classify_event(event['EventName']),
            })
 
    def add_vpc_flow_logs(self, logs: list[dict]) -> None:
        """VPC Flow Log イベントを追加"""
        for log in logs:
            self.events.append({
                'timestamp': log['timestamp'],
                'source': 'VPC Flow',
                'action': (
                    f"{log['srcaddr']}:{log['srcport']} -> "
                    f"{log['dstaddr']}:{log['dstport']}"
                ),
                'actor': log['srcaddr'],
                'details': {
                    'action': log['action'],
                    'bytes': log['bytes'],
                    'protocol': log.get('protocol'),
                },
                'severity': 'info',
            })
 
    def add_application_logs(self, logs: list[dict]) -> None:
        """アプリケーションログを追加"""
        for log in logs:
            self.events.append({
                'timestamp': log.get('timestamp'),
                'source': 'Application',
                'action': log.get('event', 'unknown'),
                'actor': log.get('userId', log.get('sourceIp', 'unknown')),
                'details': log.get('details', {}),
                'severity': log.get('level', 'info').lower(),
            })
 
    def build(self) -> list[dict]:
        """時系列順にソートしたタイムラインを返す"""
        self.events.sort(key=lambda x: x['timestamp'])
        return self.events
 
    def get_suspicious_events(self) -> list[dict]:
        """不審なイベントのみをフィルタ"""
        return [
            e for e in self.build()
            if e['severity'] in ('high', 'critical')
        ]
 
    def export_csv(self, filepath: str) -> None:
        """タイムラインを CSV でエクスポート"""
        import csv
        timeline = self.build()
        with open(filepath, 'w', newline='') as f:
            writer = csv.DictWriter(
                f,
                fieldnames=['timestamp', 'source', 'action', 'actor', 'ip', 'severity'],
            )
            writer.writeheader()
            for event in timeline:
                writer.writerow({
                    'timestamp': event['timestamp'],
                    'source': event['source'],
                    'action': event['action'],
                    'actor': event['actor'],
                    'ip': event.get('ip', ''),
                    'severity': event['severity'],
                })
 
    @staticmethod
    def _classify_event(event_name: str) -> str:
        """イベント名から重大度を分類"""
        critical_events = {
            'DeleteTrail', 'StopLogging', 'CreateUser',
            'CreateAccessKey', 'PutBucketPolicy',
            'AuthorizeSecurityGroupIngress',
        }
        high_events = {
            'CreateRole', 'AttachRolePolicy', 'PutUserPolicy',
            'ModifyInstanceAttribute', 'RunInstances',
        }
        if event_name in critical_events:
            return 'critical'
        if event_name in high_events:
            return 'high'
        return 'info'
 
 
# 使用例
timeline = IncidentTimeline()
timeline.add_cloudtrail_events([
    {
        'EventTime': '2025-03-15T14:30:00Z',
        'EventName': 'CreateAccessKey',
        'Username': 'compromised-user',
        'SourceIPAddress': '203.0.113.50',
    },
    {
        'EventTime': '2025-03-15T14:35:00Z',
        'EventName': 'PutBucketPolicy',
        'Username': 'compromised-user',
        'SourceIPAddress': '203.0.113.50',
        'Resources': [{'ARN': 'arn:aws:s3:::sensitive-data'}],
    },
])
 
suspicious = timeline.get_suspicious_events()
for event in suspicious:
    print(f"[{event['severity'].upper()}] {event['timestamp']} "
          f"{event['action']} by {event['actor']}")

"""
AWS Step Functions + Lambda による自動インシデント対応
GuardDuty → EventBridge → Step Functions → Lambda
"""
import json
 
# Step Functions のステートマシン定義
STATE_MACHINE = {
    "Comment": "GuardDuty Finding Auto-Response",
    "StartAt": "ClassifyFinding",
    "States": {
        "ClassifyFinding": {
            "Type": "Task",
            "Resource": "arn:aws:lambda:ap-northeast-1:123456:function:classify-finding",
            "Next": "SeverityCheck",
        },
        "SeverityCheck": {
            "Type": "Choice",
            "Choices": [
                {
                    "Variable": "$.severity",
                    "NumericGreaterThanEquals": 7,
                    "Next": "AutoContain",
                },
                {
                    "Variable": "$.severity",
                    "NumericGreaterThanEquals": 4,
                    "Next": "CreateTicket",
                },
            ],
            "Default": "LogOnly",
        },
        "AutoContain": {
            "Type": "Parallel",
            "Branches": [
                {
                    "StartAt": "IsolateResource",
                    "States": {
                        "IsolateResource": {
                            "Type": "Task",
                            "Resource": "arn:aws:lambda:ap-northeast-1:123456:function:isolate",
                            "End": True,
                        },
                    },
                },
                {
                    "StartAt": "NotifyTeam",
                    "States": {
                        "NotifyTeam": {
                            "Type": "Task",
                            "Resource": "arn:aws:lambda:ap-northeast-1:123456:function:notify",
                            "End": True,
                        },
                    },
                },
                {
                    "StartAt": "PreserveEvidence",
                    "States": {
                        "PreserveEvidence": {
                            "Type": "Task",
                            "Resource": "arn:aws:lambda:ap-northeast-1:123456:function:preserve",
                            "End": True,
                        },
                    },
                },
            ],
            "Next": "CreateTicket",
        },
        "CreateTicket": {
            "Type": "Task",
            "Resource": "arn:aws:lambda:ap-northeast-1:123456:function:create-ticket",
            "End": True,
        },
        "LogOnly": {
            "Type": "Task",
            "Resource": "arn:aws:lambda:ap-northeast-1:123456:function:log-finding",
            "End": True,
        },
    },
}

# インシデントポストモーテム
 
## 基本情報
- インシデントID: INC-2025-042
- 発生日時: 2025-03-15 14:30 JST
- 検知日時: 2025-03-15 14:35 JST (MTTD: 5分)
- 解決日時: 2025-03-15 18:20 JST (MTTR: 3時間50分)
- 重大度: SEV-2
- Incident Commander: 山田太郎
 
## サマリ
S3 バケットの設定ミスにより、顧客データが4時間にわたり
パブリックアクセス可能な状態になっていた。
 
## 影響
- 影響を受けたユーザー数: 0 (外部アクセスなし)
- データ漏洩: なし (CloudTrail で確認済み)
- SLA 違反: なし
- 金銭的影響: なし
 
## タイムライン
- 14:30 - Terraform apply でバケットポリシーが変更
- 14:35 - AWS Config ルール違反を検知、アラート発報
- 14:40 - IC がインシデント宣言、対応開始
- 14:50 - パブリックアクセスブロックを手動で有効化 (封じ込め)
- 15:30 - CloudTrail でアクセスログを分析
- 16:00 - 外部からのアクセスがないことを確認
- 18:00 - Terraform コードの修正とデプロイ
- 18:20 - インシデントクローズ
 
## 根本原因
Terraform モジュールの更新時に、S3 パブリックアクセスブロック
のリソースが誤って削除された。PR レビューで見落とされた。
 
## 寄与因子
1. Terraform の plan 出力が長く、削除されたリソースを見落とした
2. IaC のセキュリティスキャン (tfsec) が CI に未導入だった
3. S3 SCP による組織レベルの制御がなかった
 
## うまくいったこと
- AWS Config による自動検知が 5 分以内に機能した
- IC の迅速な判断で封じ込めが 20 分以内に完了した
 
## 改善が必要なこと
- IaC のセキュリティスキャンがなかった
- PR レビューのセキュリティ観点チェックリストがなかった
 
## 再発防止策 (Action Items)
| ID | 対策 | 担当 | 期限 | 状態 |
|----|------|------|------|------|
| 1 | tfsec/Checkov を CI/CD に統合 | 鈴木 | 2025-03-22 | TODO |
| 2 | AWS Config の自動修復ルールを追加 | 佐藤 | 2025-03-29 | TODO |
| 3 | S3 SCP で組織全体のパブリックアクセスを禁止 | 田中 | 2025-04-05 | TODO |
| 4 | PR レビューチェックリストにセキュリティ項目を追加 | 山田 | 2025-03-19 | TODO |

"""
インシデント対応メトリクスの収集と可視化
"""
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import Optional
 
 
@dataclass
class IncidentMetrics:
    """インシデントメトリクス"""
    incident_id: str
    severity: int
    detected_at: datetime
    responded_at: datetime
    contained_at: datetime
    resolved_at: datetime
    root_cause: str
    category: str
 
    @property
    def mttd(self) -> timedelta:
        """Mean Time to Detect (平均検知時間)"""
        return self.detected_at - self.detected_at  # 実際は発生時刻から
 
    @property
    def mttr(self) -> timedelta:
        """Mean Time to Respond (平均対応時間)"""
        return self.responded_at - self.detected_at
 
    @property
    def mttc(self) -> timedelta:
        """Mean Time to Contain (平均封じ込め時間)"""
        return self.contained_at - self.detected_at
 
    @property
    def mttre(self) -> timedelta:
        """Mean Time to Resolve (平均解決時間)"""
        return self.resolved_at - self.detected_at
 
 
def calculate_team_metrics(incidents: list[IncidentMetrics]) -> dict:
    """チーム全体のメトリクスを集計"""
    if not incidents:
        return {}
 
    total = len(incidents)
    avg_mttr = sum(
        (i.mttr.total_seconds() for i in incidents), 0
    ) / total
    avg_mttc = sum(
        (i.mttc.total_seconds() for i in incidents), 0
    ) / total
 
    severity_counts = {}
    for i in incidents:
        severity_counts[f'SEV-{i.severity}'] = (
            severity_counts.get(f'SEV-{i.severity}', 0) + 1
        )
 
    category_counts = {}
    for i in incidents:
        category_counts[i.category] = (
            category_counts.get(i.category, 0) + 1
        )
 
    return {
        'total_incidents': total,
        'avg_mttr_minutes': round(avg_mttr / 60, 1),
        'avg_mttc_minutes': round(avg_mttc / 60, 1),
        'by_severity': severity_counts,
        'by_category': category_counts,
    }

"""
机上演習シナリオジェネレータ
"""
import random
 
 
class TabletopScenario:
    """机上演習シナリオの生成"""
 
    SCENARIOS = [
        {
            "title": "ランサムウェア攻撃",
            "description": "月曜朝、複数の社員から「ファイルが開けない」と報告。"
                          "デスクトップにランサムノートが表示されている。",
            "injects": [
                "感染は Active Directory 経由で拡大中。ドメインコントローラーにも到達。",
                "攻撃者から「48時間以内にビットコインで身代金を支払え」とメール。",
                "記者から「御社がサイバー攻撃を受けたという情報がある」と問い合わせ。",
                "バックアップサーバーも暗号化されていることが判明。",
            ],
            "discussion_points": [
                "最初の 15 分で何をすべきか?",
                "ネットワーク全体を遮断するか? 部分的に隔離するか?",
                "身代金を支払うべきか? 法的・倫理的な観点は?",
                "顧客・取引先への通知のタイミングと内容は?",
                "バックアップが使えない場合の復旧戦略は?",
            ],
        },
        {
            "title": "内部犯行によるデータ持ち出し",
            "description": "退職予定の社員が大量のファイルを個人デバイスにコピーしている"
                          "というアラートが DLP ツールから発報。",
            "injects": [
                "該当社員は顧客リストと技術文書 500 件をダウンロード済み。",
                "社員は「業務に必要な作業」と主張。",
                "競合他社に転職予定であることが判明。",
                "過去 3 ヶ月分のアクセスログを確認すると、不自然なパターンが見つかる。",
            ],
            "discussion_points": [
                "HR とどのタイミングで連携するか?",
                "法務部門をいつ巻き込むか?",
                "社員のアクセス権をいつ無効化するか?",
                "証拠保全のために何をすべきか?",
                "法的措置を取る場合の手順は?",
            ],
        },
    ]
 
    @classmethod
    def generate(cls, scenario_type: str = "random") -> dict:
        """シナリオを生成"""
        if scenario_type == "random":
            return random.choice(cls.SCENARIOS)
        for s in cls.SCENARIOS:
            if scenario_type.lower() in s["title"].lower():
                return s
        return cls.SCENARIOS[0]
 
 
# 使用例
scenario = TabletopScenario.generate("ランサムウェア")
print(f"シナリオ: {scenario['title']}")
print(f"状況: {scenario['description']}")
print("\n議論ポイント:")
for i, point in enumerate(scenario['discussion_points'], 1):
    print(f"  {i}. {point}")