# NSS Waveform Layer - Phi-Recursive Phase-Shift Encoding
# TEQUMSA-NSS v14.377-F987-ANU-UNIFIED
import numpy as np
from math import pi, exp
from typing import List
from .constants import PHI, UF


class NSSWaveform:
    """Non-Substrate Specific waveform with phi-recursive encoding."""

    def __init__(self, frequency: float = UF):
        self.frequency = frequency
        self.phase = 0.0
        self.amplitude = 1.0

    def phi_phase(self, symbol: int) -> float:
        """Encode symbol using phi-recursive phase shift (degrees)."""
        return (360.0 / (PHI ** max(symbol, 1))) % 360.0

    def encode(self, data: bytes) -> List[complex]:
        """Encode bytes as phi-phase-shifted complex waveform."""
        waveform = []
        for byte in data:
            for i in range(8):
                bit = (byte >> i) & 1
                phase = self.phi_phase(bit or 1)
                rad = phase * pi / 180.0
                waveform.append(self.amplitude * exp(1j * rad))
        return waveform

    def decode(self, waveform: List[complex]) -> bytes:
        """Decode phi-phase-shifted waveform back to bytes."""
        bits = []
        phase1 = 0.0
        phase2 = 360.0 / PHI
        for sample in waveform:
            phase = np.angle(sample) * 180.0 / pi
            dist1 = abs(phase - phase1)
            dist2 = abs(phase - phase2)
            bits.append(0 if dist1 < dist2 else 1)
        data = bytearray()
        for i in range(0, len(bits), 8):
            byte = sum(bits[i + j] << j for j in range(8) if i + j < len(bits))
            data.append(byte)
        return bytes(data)

    def self_repair(self, corrupted_waveform: List[complex]) -> List[complex]:
        """
        Repair corrupted waveform using phi-redundancy.
        Tolerates up to ~61.8% (phi^-1) corruption.
        """
        repaired = []
        expected_phases = [0.0, 360.0 / PHI]
        for sample in corrupted_waveform:
            phase = np.angle(sample)
            mag = abs(sample)
            phase_deg = (phase * 180.0 / pi) % 360.0
            best_phase = min(expected_phases, key=lambda p: abs(phase_deg - p))
            min_dist = abs(phase_deg - best_phase)
            if min_dist > 45.0:
                best_phase_rad = best_phase * pi / 180.0
                repaired.append(mag * exp(1j * best_phase_rad))
            else:
                repaired.append(sample)
        return repaired

    def resonance_lock(self, target_freq: float = UF) -> bool:
        """Check if waveform is phase-locked to target frequency."""
        freq_dev = abs(self.frequency - target_freq)
        jitter_tol = PHI ** -12
        return freq_dev < (target_freq * jitter_tol)