core_components/signal_processing.py

#!/usr/bin/env python3
"""
Advanced Signal Processing and Modulation System
===============================================

This module implements comprehensive digital signal processing including:
- Multiple modulation schemes (BFSK, BPSK, QPSK, QAM16, OFDM, DSSS)
- Forward Error Correction (FEC) coding
- Framing, security, and watermarking
- Audio and IQ signal generation
- Visualization and analysis tools

Author: Assistant
License: MIT
"""

import binascii
import hashlib
import math
import struct
import time
import wave
from dataclasses import dataclass
from enum import Enum, auto
from pathlib import Path
from typing import Any, Dict, List, Optional, Sequence, Tuple, Union

import numpy as np
from scipy import signal as sp_signal
from scipy.fft import rfft, rfftfreq

try:
    import matplotlib.pyplot as plt
    HAS_MATPLOTLIB = True
except ImportError:
    HAS_MATPLOTLIB = False

try:
    import sounddevice as sd
    HAS_AUDIO = True
except ImportError:
    HAS_AUDIO = False

try:
    from Crypto.Cipher import AES
    from Crypto.Random import get_random_bytes
    from Crypto.Protocol.KDF import PBKDF2
    HAS_CRYPTO = True
except ImportError:
    HAS_CRYPTO = False

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# =========================================================
# Enums and Configuration
# =========================================================

class ModulationScheme(Enum):
    BFSK = auto()
    BPSK = auto()
    QPSK = auto()
    QAM16 = auto()
    AFSK = auto()
    OFDM = auto()
    DSSS_BPSK = auto()

class FEC(Enum):
    NONE = auto()
    HAMMING74 = auto()
    REED_SOLOMON = auto()   # stub
    LDPC = auto()           # stub
    TURBO = auto()          # stub

@dataclass
class ModConfig:
    sample_rate: int = 48000
    symbol_rate: int = 1200
    amplitude: float = 0.7
    f0: float = 1200.0     # BFSK 0
    f1: float = 2200.0     # BFSK 1
    fc: float = 1800.0     # PSK/QAM audio carrier (for WAV)
    clip: bool = True
    # OFDM parameters
    ofdm_subc: int = 64
    cp_len: int = 16
    # DSSS parameters
    dsss_chip_rate: int = 4800

@dataclass
class FrameConfig:
    use_crc32: bool = True
    use_crc16: bool = False
    preamble: bytes = b"\x55" * 8  # 01010101 * 8
    version: int = 1

@dataclass
class SecurityConfig:
    password: Optional[str] = None           # AES-GCM if provided
    watermark: Optional[str] = None          # prepended SHA256[0:8]
    hmac_key: Optional[str] = None           # HMAC-SHA256 appended

@dataclass
class OutputPaths:
    wav: Optional[Path] = None
    iq: Optional[Path] = None
    meta: Optional[Path] = None
    png: Optional[Path] = None

# =========================================================
# Utility Functions
# =========================================================

def now_ms() -> int:
    return int(time.time() * 1000)

def crc32_bytes(data: bytes) -> bytes:
    return binascii.crc32(data).to_bytes(4, "big")

def crc16_ccitt(data: bytes) -> bytes:
    poly, crc = 0x1021, 0xFFFF
    for b in data:
        crc ^= b << 8
        for _ in range(8):
            crc = ((crc << 1) ^ poly) & 0xFFFF if (crc & 0x8000) else ((crc << 1) & 0xFFFF)
    return crc.to_bytes(2, "big")

def to_bits(data: bytes) -> List[int]:
    return [(byte >> i) & 1 for byte in data for i in range(7, -1, -1)]

def from_bits(bits: Sequence[int]) -> bytes:
    if len(bits) % 8 != 0:
        bits = list(bits) + [0] * (8 - len(bits) % 8)
    out = bytearray()
    for i in range(0, len(bits), 8):
        byte = 0
        for b in bits[i:i+8]:
            byte = (byte << 1) | (1 if b else 0)
        out.append(byte)
    return bytes(out)

def chunk_bits(bits: Sequence[int], n: int) -> List[List[int]]:
    return [list(bits[i:i+n]) for i in range(0, len(bits), n)]

def safe_json(obj: Any) -> str:
    import json
    def enc(x):
        if isinstance(x, (np.floating,)):
            return float(x)
        if isinstance(x, (np.integer,)):
            return int(x)
        if isinstance(x, (np.ndarray,)):
            return x.tolist()
        if isinstance(x, complex):
            return {"real": float(x.real), "imag": float(x.imag)}
        return str(x)
    return json.dumps(obj, ensure_ascii=False, indent=2, default=enc)

# =========================================================
# FEC Implementation
# =========================================================

def hamming74_encode(data_bits: List[int]) -> List[int]:
    """Hamming (7,4) encoding"""
    if len(data_bits) % 4 != 0:
        data_bits = data_bits + [0] * (4 - len(data_bits) % 4)
    
    out = []
    for i in range(0, len(data_bits), 4):
        d0, d1, d2, d3 = data_bits[i:i+4]
        p1 = d0 ^ d1 ^ d3
        p2 = d0 ^ d2 ^ d3
        p3 = d1 ^ d2 ^ d3
        out += [p1, p2, d0, p3, d1, d2, d3]
    
    return out

def hamming74_decode(coded_bits: List[int]) -> Tuple[List[int], int]:
    """Hamming (7,4) decoding with error correction"""
    if len(coded_bits) % 7 != 0:
        coded_bits = coded_bits + [0] * (7 - len(coded_bits) % 7)
    
    decoded = []
    errors_corrected = 0
    
    for i in range(0, len(coded_bits), 7):
        r = coded_bits[i:i+7]  # received codeword
        p1, p2, d0, p3, d1, d2, d3 = r
        
        # Calculate syndrome
        s1 = p1 ^ d0 ^ d1 ^ d3
        s2 = p2 ^ d0 ^ d2 ^ d3
        s3 = p3 ^ d1 ^ d2 ^ d3
        
        syndrome = s1 + 2*s2 + 4*s3
        
        # Correct single-bit errors
        if syndrome != 0:
            errors_corrected += 1
            if syndrome <= 7:
                r[syndrome - 1] ^= 1  # flip the error bit
        
        # Extract data bits
        decoded.extend([r[2], r[4], r[5], r[6]])  # d0, d1, d2, d3
    
    return decoded, errors_corrected

def fec_encode(bits: List[int], scheme: FEC) -> List[int]:
    if scheme == FEC.NONE:
        return list(bits)
    elif scheme == FEC.HAMMING74:
        return hamming74_encode(bits)
    elif scheme in (FEC.REED_SOLOMON, FEC.LDPC, FEC.TURBO):
        raise NotImplementedError(f"{scheme.name} encoding not implemented")
    else:
        raise ValueError("Unknown FEC scheme")

def fec_decode(bits: List[int], scheme: FEC) -> Tuple[List[int], Dict[str, Any]]:
    if scheme == FEC.NONE:
        return list(bits), {"errors_corrected": 0}
    elif scheme == FEC.HAMMING74:
        decoded, errors = hamming74_decode(bits)
        return decoded, {"errors_corrected": errors}
    else:
        raise NotImplementedError(f"{scheme.name} decoding not implemented")

# =========================================================
# Security and Framing
# =========================================================

def aes_gcm_encrypt(plaintext: bytes, password: str) -> bytes:
    if not HAS_CRYPTO:
        raise RuntimeError("pycryptodome required for encryption")
    
    salt = get_random_bytes(16)
    key = PBKDF2(password, salt, dkLen=32, count=200_000)
    nonce = get_random_bytes(12)
    cipher = AES.new(key, AES.MODE_GCM, nonce=nonce)
    ciphertext, tag = cipher.encrypt_and_digest(plaintext)
    
    return b"AGCM" + salt + nonce + tag + ciphertext

def aes_gcm_decrypt(encrypted: bytes, password: str) -> bytes:
    if not HAS_CRYPTO:
        raise RuntimeError("pycryptodome required for decryption")
    
    if not encrypted.startswith(b"AGCM"):
        raise ValueError("Invalid encrypted format")
    
    data = encrypted[4:]  # skip "AGCM" header
    salt = data[:16]
    nonce = data[16:28]
    tag = data[28:44]
    ciphertext = data[44:]
    
    key = PBKDF2(password, salt, dkLen=32, count=200_000)
    cipher = AES.new(key, AES.MODE_GCM, nonce=nonce)
    
    return cipher.decrypt_and_verify(ciphertext, tag)

def apply_hmac(data: bytes, hkey: str) -> bytes:
    import hmac
    key = hashlib.sha256(hkey.encode("utf-8")).digest()
    mac = hmac.new(key, data, hashlib.sha256).digest()
    return data + b"HMAC" + mac

def verify_hmac(data: bytes, hkey: str) -> Tuple[bytes, bool]:
    if not data.endswith(b"HMAC"):
        return data, False
    
    # Find HMAC marker
    hmac_pos = data.rfind(b"HMAC")
    if hmac_pos == -1 or len(data) - hmac_pos != 36:  # 4 + 32 bytes
        return data, False
    
    payload = data[:hmac_pos]
    received_mac = data[hmac_pos + 4:]
    
    import hmac
    key = hashlib.sha256(hkey.encode("utf-8")).digest()
    expected_mac = hmac.new(key, payload, hashlib.sha256).digest()
    
    return payload, hmac.compare_digest(received_mac, expected_mac)

def add_watermark(data: bytes, wm: str) -> bytes:
    return hashlib.sha256(wm.encode("utf-8")).digest()[:8] + data

def check_watermark(data: bytes, wm: str) -> Tuple[bytes, bool]:
    if len(data) < 8:
        return data, False
    
    expected = hashlib.sha256(wm.encode("utf-8")).digest()[:8]
    received = data[:8]
    payload = data[8:]
    
    return payload, received == expected

def frame_payload(payload: bytes, fcfg: FrameConfig) -> bytes:
    header = struct.pack(">BBI", 0xA5, fcfg.version, now_ms() & 0xFFFFFFFF)
    core = header + payload
    
    tail = b""
    if fcfg.use_crc32:
        tail += crc32_bytes(core)
    if fcfg.use_crc16:
        tail += crc16_ccitt(core)
    
    return fcfg.preamble + core + tail

def unframe_payload(framed: bytes, fcfg: FrameConfig) -> Tuple[bytes, Dict[str, Any]]:
    if len(framed) < len(fcfg.preamble) + 7:  # minimum frame size
        return b"", {"error": "Frame too short"}
    
    # Check preamble
    if not framed.startswith(fcfg.preamble):
        return b"", {"error": "Invalid preamble"}
    
    data = framed[len(fcfg.preamble):]
    
    # Parse header
    if len(data) < 7:
        return b"", {"error": "Header too short"}
    
    sync, version, timestamp = struct.unpack(">BBI", data[:7])
    if sync != 0xA5:
        return b"", {"error": "Invalid sync byte"}
    
    # Calculate payload length
    tail_len = 0
    if fcfg.use_crc32:
        tail_len += 4
    if fcfg.use_crc16:
        tail_len += 2
    
    if len(data) < 7 + tail_len:
        return b"", {"error": "Frame too short for CRC"}
    
    payload = data[7:-tail_len] if tail_len > 0 else data[7:]
    
    # Verify CRCs
    info = {"version": version, "timestamp": timestamp}
    
    if fcfg.use_crc32:
        expected_crc32 = crc32_bytes(data[:-tail_len])
        received_crc32 = data[-tail_len:-tail_len+4] if fcfg.use_crc16 else data[-4:]
        info["crc32_ok"] = expected_crc32 == received_crc32
    
    if fcfg.use_crc16:
        expected_crc16 = crc16_ccitt(data[:-2])
        received_crc16 = data[-2:]
        info["crc16_ok"] = expected_crc16 == received_crc16
    
    return payload, info

def encode_text(text: str, fcfg: FrameConfig, sec: SecurityConfig, fec_scheme: FEC) -> List[int]:
    """Complete encoding pipeline"""
    data = text.encode("utf-8")
    
    # Apply watermark
    if sec.watermark:
        data = add_watermark(data, sec.watermark)
    
    # Apply encryption
    if sec.password:
        data = aes_gcm_encrypt(data, sec.password)
    
    # Frame the data
    framed = frame_payload(data, fcfg)
    
    # Apply HMAC
    if sec.hmac_key:
        framed = apply_hmac(framed, sec.hmac_key)
    
    # Convert to bits and apply FEC
    bits = to_bits(framed)
    bits = fec_encode(bits, fec_scheme)
    
    return bits

def decode_bits(bits: List[int], fcfg: FrameConfig, sec: SecurityConfig, fec_scheme: FEC) -> Tuple[str, Dict[str, Any]]:
    """Complete decoding pipeline"""
    info = {}
    
    try:
        # Apply FEC decoding
        decoded_bits, fec_info = fec_decode(bits, fec_scheme)
        info.update(fec_info)
        
        # Convert bits to bytes
        framed = from_bits(decoded_bits)
        
        # Verify HMAC
        if sec.hmac_key:
            framed, hmac_ok = verify_hmac(framed, sec.hmac_key)
            info["hmac_ok"] = hmac_ok
            if not hmac_ok:
                return "", {**info, "error": "HMAC verification failed"}
        
        # Unframe
        data, frame_info = unframe_payload(framed, fcfg)
        info.update(frame_info)
        
        if "error" in frame_info:
            return "", info
        
        # Decrypt
        if sec.password:
            data = aes_gcm_decrypt(data, sec.password)
            info["decrypted"] = True
        
        # Check watermark
        if sec.watermark:
            data, wm_ok = check_watermark(data, sec.watermark)
            info["watermark_ok"] = wm_ok
            if not wm_ok:
                return "", {**info, "error": "Watermark verification failed"}
        
        # Decode text
        text = data.decode("utf-8", errors="replace")
        return text, info
        
    except Exception as e:
        return "", {**info, "error": str(e)}

# =========================================================
# Modulation Schemes
# =========================================================

class Modulators:
    @staticmethod
    def bfsk(bits: Sequence[int], cfg: ModConfig) -> np.ndarray:
        """Binary Frequency Shift Keying"""
        sr, rb = cfg.sample_rate, cfg.symbol_rate
        spb = int(sr / rb)  # samples per bit
        t = np.arange(spb) / sr
        
        signal_blocks = []
        for bit in bits:
            freq = cfg.f1 if bit else cfg.f0
            signal_blocks.append(cfg.amplitude * np.sin(2 * np.pi * freq * t))
        
        if not signal_blocks:
            return np.zeros(0, dtype=np.float32)
        
        signal = np.concatenate(signal_blocks)
        
        if cfg.clip:
            signal = np.clip(signal, -1, 1)
        
        return signal.astype(np.float32)
    
    @staticmethod
    def bpsk(bits: Sequence[int], cfg: ModConfig) -> Tuple[np.ndarray, np.ndarray]:
        """Binary Phase Shift Keying"""
        sr, rb, fc = cfg.sample_rate, cfg.symbol_rate, cfg.fc
        spb = int(sr / rb)
        t = np.arange(spb) / sr
        
        audio_blocks = []
        iq_blocks = []
        
        for bit in bits:
            phase = 0.0 if bit else np.pi
            
            # Audio signal (upconverted)
            audio_blocks.append(cfg.amplitude * np.sin(2 * np.pi * fc * t + phase))
            
            # IQ signal (baseband)
            iq_symbol = cfg.amplitude * (np.cos(phase) + 1j * np.sin(phase))
            iq_blocks.append(iq_symbol * np.ones(spb, dtype=np.complex64))
        
        audio = np.concatenate(audio_blocks) if audio_blocks else np.zeros(0, dtype=np.float32)
        iq = np.concatenate(iq_blocks) if iq_blocks else np.zeros(0, dtype=np.complex64)
        
        if cfg.clip:
            audio = np.clip(audio, -1, 1)
        
        return audio.astype(np.float32), iq
    
    @staticmethod
    def qpsk(bits: Sequence[int], cfg: ModConfig) -> Tuple[np.ndarray, np.ndarray]:
        """Quadrature Phase Shift Keying"""
        pairs = chunk_bits(bits, 2)
        symbols = []
        
        # Gray mapping: 00→(1+1j), 01→(-1+1j), 11→(-1-1j), 10→(1-1j)
        for pair in pairs:
            b0, b1 = (pair + [0, 0])[:2]
            if (b0, b1) == (0, 0):
                symbol = 1 + 1j
            elif (b0, b1) == (0, 1):
                symbol = -1 + 1j
            elif (b0, b1) == (1, 1):
                symbol = -1 - 1j
            else:  # (1, 0)
                symbol = 1 - 1j
            
            symbols.append(symbol / math.sqrt(2))  # normalize for unit energy
        
        return Modulators._psk_qam_to_audio_iq(np.array(symbols, dtype=np.complex64), cfg)
    
    @staticmethod
    def qam16(bits: Sequence[int], cfg: ModConfig) -> Tuple[np.ndarray, np.ndarray]:
        """16-QAM modulation"""
        quads = chunk_bits(bits, 4)
        
        def gray_map_2bit(b0, b1):
            # Gray mapping for 2 bits to {-3, -1, 1, 3}
            val = (b0 << 1) | b1
            return [-3, -1, 1, 3][val]
        
        symbols = []
        for quad in quads:
            b0, b1, b2, b3 = (quad + [0, 0, 0, 0])[:4]
            I = gray_map_2bit(b0, b1)
            Q = gray_map_2bit(b2, b3)
            symbol = (I + 1j * Q) / math.sqrt(10)  # normalize for unit average power
            symbols.append(symbol)
        
        return Modulators._psk_qam_to_audio_iq(np.array(symbols, dtype=np.complex64), cfg)
    
    @staticmethod
    def _psk_qam_to_audio_iq(symbols: np.ndarray, cfg: ModConfig) -> Tuple[np.ndarray, np.ndarray]:
        """Convert PSK/QAM symbols to audio and IQ signals"""
        sr, rb, fc = cfg.sample_rate, cfg.symbol_rate, cfg.fc
        spb = int(sr / rb)
        
        # Upsample symbols (rectangular pulse shaping)
        i_data = np.repeat(symbols.real.astype(np.float32), spb)
        q_data = np.repeat(symbols.imag.astype(np.float32), spb)
        
        # Generate time vector
        t = np.arange(len(i_data)) / sr
        
        # Generate audio signal (upconverted)
        audio = cfg.amplitude * (i_data * np.cos(2 * np.pi * fc * t) - 
                                q_data * np.sin(2 * np.pi * fc * t))
        
        # Generate IQ signal (baseband)
        iq = (cfg.amplitude * i_data) + 1j * (cfg.amplitude * q_data)
        
        if cfg.clip:
            audio = np.clip(audio, -1, 1)
        
        return audio.astype(np.float32), iq.astype(np.complex64)
    
    @staticmethod
    def afsk(bits: Sequence[int], cfg: ModConfig) -> np.ndarray:
        """Audio Frequency Shift Keying (same as BFSK)"""
        return Modulators.bfsk(bits, cfg)
    
    @staticmethod
    def dsss_bpsk(bits: Sequence[int], cfg: ModConfig) -> np.ndarray:
        """Direct Sequence Spread Spectrum BPSK"""
        # Simple PN sequence for spreading
        pn_sequence = np.array([1, -1, 1, 1, -1, 1, -1, -1], dtype=np.float32)
        
        sr = cfg.sample_rate
        chip_rate = cfg.dsss_chip_rate
        samples_per_chip = int(sr / chip_rate)
        
        baseband_signal = []
        
        for bit in bits:
            bit_value = 1.0 if bit else -1.0
            
            # Spread with PN sequence
            spread_chips = bit_value * pn_sequence
            
            # Upsample chips
            for chip in spread_chips:
                baseband_signal.extend([chip] * samples_per_chip)
        
        baseband = np.array(baseband_signal, dtype=np.float32)
        
        # Upconvert to carrier frequency
        t = np.arange(len(baseband)) / sr
        audio = cfg.amplitude * baseband * np.sin(2 * np.pi * cfg.fc * t)
        
        if cfg.clip:
            audio = np.clip(audio, -1, 1)
        
        return audio.astype(np.float32)
    
    @staticmethod
    def ofdm(bits: Sequence[int], cfg: ModConfig) -> Tuple[np.ndarray, np.ndarray]:
        """Orthogonal Frequency Division Multiplexing"""
        N = cfg.ofdm_subc
        cp_len = cfg.cp_len
        
        # Group bits for QPSK mapping on each subcarrier
        symbol_chunks = chunk_bits(bits, 2 * N)
        
        audio_blocks = []
        iq_blocks = []
        
        for chunk in symbol_chunks:
            # Map bits to QPSK symbols
            qpsk_symbols = []
            bit_pairs = chunk_bits(chunk, 2)
            
            for pair in bit_pairs:
                b0, b1 = (pair + [0, 0])[:2]
                if (b0, b1) == (0, 0):
                    symbol = 1 + 1j
                elif (b0, b1) == (0, 1):
                    symbol = -1 + 1j
                elif (b0, b1) == (1, 1):
                    symbol = -1 - 1j
                else:
                    symbol = 1 - 1j
                qpsk_symbols.append(symbol / math.sqrt(2))
            
            # Pad to N subcarriers
            while len(qpsk_symbols) < N:
                qpsk_symbols.append(0j)
            
            # IFFT to get time domain signal
            freq_domain = np.array(qpsk_symbols[:N], dtype=np.complex64)
            time_domain = np.fft.ifft(freq_domain)
            
            # Add cyclic prefix
            cyclic_prefix = time_domain[-cp_len:]
            ofdm_symbol = np.concatenate([cyclic_prefix, time_domain])
            
            # Scale to fit symbol rate timing
            symbol_duration = int(cfg.sample_rate / cfg.symbol_rate)
            repeat_factor = max(1, symbol_duration // len(ofdm_symbol))
            upsampled = np.repeat(ofdm_symbol, repeat_factor)
            
            # Generate audio (upconverted)
            t = np.arange(len(upsampled)) / cfg.sample_rate
            audio = cfg.amplitude * (upsampled.real * np.cos(2 * np.pi * cfg.fc * t) -
                                   upsampled.imag * np.sin(2 * np.pi * cfg.fc * t))
            
            audio_blocks.append(audio.astype(np.float32))
            iq_blocks.append((cfg.amplitude * upsampled).astype(np.complex64))
        
        audio = np.concatenate(audio_blocks) if audio_blocks else np.zeros(0, dtype=np.float32)
        iq = np.concatenate(iq_blocks) if iq_blocks else np.zeros(0, dtype=np.complex64)
        
        if cfg.clip:
            audio = np.clip(audio, -1, 1)
        
        return audio, iq

def bits_to_signals(bits: List[int], scheme: ModulationScheme, cfg: ModConfig) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
    """Convert bits to modulated signals"""
    if scheme == ModulationScheme.BFSK:
        return Modulators.bfsk(bits, cfg), None
    elif scheme == ModulationScheme.AFSK:
        return Modulators.afsk(bits, cfg), None
    elif scheme == ModulationScheme.BPSK:
        return Modulators.bpsk(bits, cfg)
    elif scheme == ModulationScheme.QPSK:
        return Modulators.qpsk(bits, cfg)
    elif scheme == ModulationScheme.QAM16:
        return Modulators.qam16(bits, cfg)
    elif scheme == ModulationScheme.OFDM:
        return Modulators.ofdm(bits, cfg)
    elif scheme == ModulationScheme.DSSS_BPSK:
        return Modulators.dsss_bpsk(bits, cfg), None
    else:
        raise ValueError(f"Unknown modulation scheme: {scheme}")

# =========================================================
# File I/O and Visualization
# =========================================================

def write_wav_mono(path: Path, signal: np.ndarray, sample_rate: int):
    """Write mono WAV file"""
    sig = np.clip(signal, -1.0, 1.0)
    pcm = (sig * 32767.0).astype(np.int16)
    
    with wave.open(str(path), "wb") as w:
        w.setnchannels(1)
        w.setsampwidth(2)
        w.setframerate(sample_rate)
        w.writeframes(pcm.tobytes())

def write_iq_f32(path: Path, iq: np.ndarray):
    """Write IQ data as interleaved float32"""
    if iq.ndim != 1 or not np.iscomplexobj(iq):
        raise ValueError("iq must be 1-D complex array")
    
    interleaved = np.empty(iq.size * 2, dtype=np.float32)
    interleaved[0::2] = iq.real.astype(np.float32)
    interleaved[1::2] = iq.imag.astype(np.float32)
    
    path.write_bytes(interleaved.tobytes())

def plot_wave_and_spectrum(path_png: Path, x: np.ndarray, sr: int, title: str):
    """Plot waveform and spectrum"""
    if not HAS_MATPLOTLIB:
        logger.warning("Matplotlib not available, skipping plot")
        return
    
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
    
    # Time domain plot (first 50ms)
    samples_to_plot = min(len(x), int(0.05 * sr))
    t = np.arange(samples_to_plot) / sr
    ax1.plot(t, x[:samples_to_plot])
    ax1.set_title(f"{title} - Time Domain (first 50ms)")
    ax1.set_xlabel("Time (s)")
    ax1.set_ylabel("Amplitude")
    ax1.grid(True, alpha=0.3)
    
    # Frequency domain plot
    spectrum = np.abs(rfft(x)) + 1e-12
    freqs = rfftfreq(len(x), 1.0 / sr)
    ax2.semilogy(freqs, spectrum / spectrum.max())
    ax2.set_xlim(0, min(8000, sr // 2))
    ax2.set_title(f"{title} - Frequency Domain")
    ax2.set_xlabel("Frequency (Hz)")
    ax2.set_ylabel("Normalized |X(f)|")
    ax2.grid(True, alpha=0.3)
    
    plt.tight_layout()
    fig.savefig(path_png, dpi=300, bbox_inches='tight')
    plt.close(fig)

def plot_constellation(symbols: np.ndarray, title: str = "Constellation", save_path: Optional[str] = None):
    """Plot constellation diagram"""
    if not HAS_MATPLOTLIB:
        logger.warning("Matplotlib not available, skipping constellation plot")
        return
    
    plt.figure(figsize=(8, 8))
    plt.scatter(np.real(symbols), np.imag(symbols), alpha=0.7, s=20)
    plt.title(title)
    plt.xlabel("In-phase (I)")
    plt.ylabel("Quadrature (Q)")
    plt.grid(True, alpha=0.3)
    plt.axis('equal')
    
    if save_path:
        plt.savefig(save_path, dpi=300, bbox_inches='tight')
        plt.close()
    else:
        plt.show()

def play_audio(x: np.ndarray, sr: int):
    """Play audio through soundcard"""
    if not HAS_AUDIO:
        logger.warning("sounddevice not installed; cannot play audio")
        return
    
    try:
        sd.play(x, sr)
        sd.wait()
    except Exception as e:
        logger.error(f"Audio playback failed: {e}")

# =========================================================
# Complete Processing Pipeline
# =========================================================

def full_process_and_save(
    text: str,
    outdir: Path,
    scheme: ModulationScheme,
    mcfg: ModConfig,
    fcfg: FrameConfig,
    sec: SecurityConfig,
    fec_scheme: FEC,
    want_wav: bool,
    want_iq: bool,
    title: str = "SignalProcessor"
) -> OutputPaths:
    """Complete processing pipeline from text to files"""
    
    outdir.mkdir(parents=True, exist_ok=True)
    timestamp = int(time.time())
    base_name = f"signal_{scheme.name.lower()}_{timestamp}"
    base_path = outdir / base_name
    
    # Encode text to bits
    bits = encode_text(text, fcfg, sec, fec_scheme)
    logger.info(f"Encoded {len(text)} characters to {len(bits)} bits")
    
    # Modulate bits to signals
    audio, iq = bits_to_signals(bits, scheme, mcfg)
    
    paths = OutputPaths()
    
    # Save WAV file
    if want_wav and audio is not None and len(audio) > 0:
        paths.wav = base_path.with_suffix(".wav")
        write_wav_mono(paths.wav, audio, mcfg.sample_rate)
        logger.info(f"Saved WAV: {paths.wav}")
    
    # Save IQ file
    if want_iq:
        if iq is None and audio is not None:
            # Generate IQ from audio using Hilbert transform
            try:
                analytic = sp_signal.hilbert(audio)
                iq = analytic.astype(np.complex64)
            except Exception as e:
                logger.warning(f"Failed to generate IQ from audio: {e}")
                iq = audio.astype(np.float32) + 1j * np.zeros_like(audio, dtype=np.float32)
        
        if iq is not None:
            paths.iq = base_path.with_suffix(".iqf32")
            write_iq_f32(paths.iq, iq)
            logger.info(f"Saved IQ: {paths.iq}")
    
    # Generate visualization
    if audio is not None and len(audio) > 0:
        paths.png = base_path.with_suffix(".png")
        plot_wave_and_spectrum(paths.png, audio, mcfg.sample_rate, title)
        logger.info(f"Saved plot: {paths.png}")
    
    # Save metadata
    metadata = {
        "timestamp": timestamp,
        "scheme": scheme.name,
        "sample_rate": mcfg.sample_rate,
        "symbol_rate": mcfg.symbol_rate,
        "duration_sec": len(audio) / mcfg.sample_rate if audio is not None else 0,
        "fec": fec_scheme.name,
        "encrypted": bool(sec.password),
        "watermark": bool(sec.watermark),
        "hmac": bool(sec.hmac_key),
        "text_length": len(text),
        "bits_length": len(bits)
    }
    
    paths.meta = base_path.with_suffix(".json")
    paths.meta.write_text(safe_json(metadata), encoding="utf-8")
    logger.info(f"Saved metadata: {paths.meta}")
    
    return paths

def demo_signal_processing():
    """Demonstration of signal processing capabilities"""
    
    # Test configuration
    text = "Hello, World! This is a test of the signal processing system. 🚀"
    
    schemes_to_test = [
        ModulationScheme.BFSK,
        ModulationScheme.QPSK,
        ModulationScheme.QAM16,
        ModulationScheme.OFDM
    ]
    
    mcfg = ModConfig(sample_rate=48000, symbol_rate=1200)
    fcfg = FrameConfig()
    sec = SecurityConfig(watermark="test_watermark")
    fec_scheme = FEC.HAMMING74
    
    results = []
    
    for scheme in schemes_to_test:
        logger.info(f"Testing {scheme.name}...")
        
        try:
            paths = full_process_and_save(
                text=text,
                outdir=Path("demo_output"),
                scheme=scheme,
                mcfg=mcfg,
                fcfg=fcfg,
                sec=sec,
                fec_scheme=fec_scheme,
                want_wav=True,
                want_iq=True,
                title=f"{scheme.name} Demo"
            )
            
            results.append({
                "scheme": scheme.name,
                "success": True,
                "paths": paths
            })
            
        except Exception as e:
            logger.error(f"Failed to process {scheme.name}: {e}")
            results.append({
                "scheme": scheme.name,
                "success": False,
                "error": str(e)
            })
    
    # Print summary
    logger.info("=== Signal Processing Demo Complete ===")
    for result in results:
        status = "✓" if result["success"] else "✗"
        logger.info(f"{status} {result['scheme']}")
    
    return results

if __name__ == "__main__":
    demo_signal_processing()