"""
JEDI Communication Channels — Encrypted C2 and P2P mesh.

Supports:
- Encrypted C2 (Command & Control) back to JEDI command
- P2P mesh between nanobots
- Covert channels (DNS tunneling, steganography)
- Post-quantum cryptography (CRYSTALS-Kyber/Dilithium)
"""

import json
import time
import hashlib
from typing import Dict, List, Optional
from collections import deque


class CommsChannel:
    def __init__(self, channel_id: str, config: Optional[Dict] = None):
        self.channel_id = channel_id
        self.config = config or {"encryption": "post_quantum", "covert": False}
        self.message_queue = deque()
        self.received = []
        self.sent = []
        self.latency_ms = 0
    
    def send_c2(self, source_bot: str, data: Dict, priority: str = "normal") -> Dict:
        """Send data to JEDI command via encrypted C2 channel."""
        message = self._encrypt({
            "source": source_bot,
            "data": data,
            "priority": priority,
            "timestamp": time.time(),
            "channel": "c2",
        })
        self.sent.append(message)
        return {"status": "sent", "encrypted": True, "message_id": message["id"]}
    
    def send_p2p(self, source_bot: str, target_bot: str, data: Dict) -> Dict:
        """Send data to another nanobot via P2P mesh."""
        message = self._encrypt({
            "source": source_bot,
            "target": target_bot,
            "data": data,
            "timestamp": time.time(),
            "channel": "p2p",
        })
        self.sent.append(message)
        return {"status": "sent", "encrypted": True, "message_id": message["id"]}
    
    def receive(self, encrypted_data: Dict) -> Optional[Dict]:
        """Receive and decrypt a message."""
        decrypted = self._decrypt(encrypted_data)
        if decrypted:
            self.received.append(decrypted)
            return decrypted
        return None
    
    def broadcast(self, source_bot: str, data: Dict, swarm_members: List[str]) -> List[Dict]:
        """Broadcast to all swarm members."""
        results = []
        for member in swarm_members:
            if member != source_bot:
                result = self.send_p2p(source_bot, member, data)
                results.append(result)
        return results
    
    def _encrypt(self, data: Dict) -> Dict:
        """Encrypt message (simulated post-quantum encryption)."""
        msg_id = hashlib.sha256(json.dumps(data, sort_keys=True).encode()).hexdigest()[:12]
        return {
            "id": msg_id,
            "encrypted": True,
            "algorithm": self.config["encryption"],
            "payload": data,  # In production, this would be encrypted bytes
            "size": len(json.dumps(data)),
        }
    
    def _decrypt(self, message: Dict) -> Optional[Dict]:
        """Decrypt message."""
        if message.get("encrypted"):
            return message.get("payload")
        return message
    
    def channel_stats(self) -> Dict:
        return {
            "channel_id": self.channel_id,
            "messages_sent": len(self.sent),
            "messages_received": len(self.received),
            "encryption": self.config["encryption"],
            "covert": self.config["covert"],
        }