#!/usr/bin/env python3
"""
Protest Medic Encounter Logger - Minimal Data Version
Stores only anonymized treatment codes, not patient identities
"""
import json
import hashlib
from datetime import datetime
from pathlib import Path

class SecureEncounterLog:
    def __init__(self, encryption_key=None):
        self.encounters = []
        self.encryption_key = encryption_key  # Optional: AES key for storage encryption

    def log_encounter(self, treatment_codes, notes="", location="", timestamp=None):
        """
        Log encounter using treatment codes instead of patient identifiers

        treatment_codes: List of standardized codes (e.g., ["BLK", "TEAR", "HYP"])
        - BLK: Basic life support
        - TEAR: Tear gas exposure treatment
        - HYP: Heat-related illness
        - TRA: Trauma/wound care
        - MHA: Mental health acute crisis
        """
        if timestamp is None:
            timestamp = datetime.now().isoformat()

        # Create anonymized encounter record
        encounter = {
            "timestamp": timestamp,
            "location_code": self._anonymize_location(location),
            "treatments": treatment_codes,
            # Notes should NEVER contain:
            # - Names, physical descriptions that could identify individuals
            # - Specific conversation content
            # - Photos that could identify people
            "notes": notes,
            "incident_id": self._generate_incident_id(timestamp, location)
        }

        self.encounters.append(encounter)
        return encounter["incident_id"]

    def _anonymize_location(self, location):
        """Convert specific location to area code only"""
        if not location:
            return "UNK"
        # Return only neighborhood/area, not specific address
        return hashlib.sha256(location.encode()).hexdigest()[:8].upper()

    def _generate_incident_id(self, timestamp, location):
        """Generate non-sequential incident ID"""
        data = f"{timestamp}{location}".encode()
        return hashlib.sha256(data).hexdigest()[:12].upper()

    def export_encounters(self, filepath):
        """Export to encrypted JSON"""
        data = json.dumps(self.encounters, indent=2)

        if self.encryption_key:
            # Use cryptography library for actual encryption
            from cryptography.fernet import Fernet
            f = Fernet(self.encryption_key)
            encrypted = f.encrypt(data.encode())
            with open(filepath, 'wb') as f:
                f.write(encrypted)
        else:
            with open(filepath, 'w') as f:
                f.write(data)

# Usage example
logger = SecureEncounterLog()
incident_id = logger.log_encounter(
    treatment_codes=["TEAR", "BLK"],
    notes="Multiple patients at intersection. Tear gas exposure, eye irrigation performed.",
    location="Downtown Plaza"
)
print(f"Logged incident: {incident_id}")

# Signal group security checklist:
"""
1. Create NEW group for each event (don't reuse)
2. Enable disappearing messages (24-hour default)
3. Verify all member identities in person
4. Set group avatar to generic symbol (no identifying photos)
5. Add ONLY members who need to know
6. Never discuss specific patients by any identifying detail
7. Use code words:
   - "Patient" → "P" or "individual"
   - "Tear gas" → "gas" or "chemical"
   - "Arrested" → "taken" or "removed"
"""

# For group chats, establish protocol:
GROUP_PROTOCOL = """
Signal Security Protocol:
- Disappearing messages: 24 hours
- No names in messages - use incident codes
- Delete chat history after each event
- Verify group members in person at start of shift
- If device seized, no message content visible (Signal doesn't store)
"""