Audio Engine

flowchart TB
    subgraph Input [Input]
        Lexicon[Lexicon Signals]
        Gesture[Gesture Events]
        Link[Ableton Link]
    end

    subgraph Conductor [cc-conductor]
        Tempo[Tempo Tracker]
        Quantizer[Beat Quantizer]
        Actions[Action Queue]
    end

    subgraph Scheduler [scheduler]
        Timeline[Beat Timeline]
        Pending[Pending Actions]
        Fire[Fire Actions]
    end

    subgraph Engine [audio-engine]
        DSP[DSP Chain]
        Mixer[Mixer]
        Output[Audio Output]
    end

    subgraph DJ [DJ Integration]
        RB[Rekordbox]
        Serato[Serato]
        MIDI[MIDI/OSC]
    end

    Lexicon --> Tempo
    Gesture --> Actions
    Link --> Tempo
    Tempo --> Quantizer --> Actions --> Pending
    Pending --> Fire --> DSP --> Mixer --> Output
    Fire --> MIDI --> RB
    Fire --> MIDI --> Serato

pub struct Conductor {
    config: ConductorConfig,
    tempo: TempoTracker,
    section: SectionState,
    pattern_engine: PatternEngine,
    action_queue: VecDeque<ScheduledAction>,
}

impl Conductor {
    pub fn process(
        &mut self,
        lexicon: &Lexicon,
        gesture: Option<&GestureEvent>,
        dt: f32,
    ) -> Vec<Action> {
        // Update tempo from lexicon
        self.tempo.update(lexicon.energy, dt);

        // Update section state
        self.section = self.compute_section(lexicon);

        // Generate pattern modifications
        let pattern_changes = self.pattern_engine.process(lexicon, self.section);

        // Process gestures into actions
        let gesture_actions = gesture.map(|g| self.gesture_to_action(g));

        // Collect and quantize actions
        self.collect_actions(pattern_changes, gesture_actions)
    }
}

pub struct TempoTracker {
    base_bpm: f32,          // 120.0
    current_bpm: f32,
    target_bpm: f32,
    smoothing: f32,         // 0.95 (high smoothing)
    min_bpm: f32,           // 80.0
    max_bpm: f32,           // 160.0
}

impl TempoTracker {
    pub fn update(&mut self, energy: f32, dt: f32) {
        // Map energy [0,1] to tempo range
        self.target_bpm = self.min_bpm + energy * (self.max_bpm - self.min_bpm);

        // Smooth transition
        self.current_bpm = self.smoothing * self.current_bpm
                         + (1.0 - self.smoothing) * self.target_bpm;
    }

    pub fn beat_duration(&self) -> f32 {
        60.0 / self.current_bpm
    }
}

pub struct BeatScheduler {
    timeline: BeatTimeline,
    pending: Vec<ScheduledAction>,
    quantize_mode: QuantizeMode,
}

pub enum QuantizeMode {
    Off,           // Fire immediately
    Beat,          // Quantize to beat
    Bar,           // Quantize to bar
    Phrase,        // Quantize to 4/8 bar phrase
}

pub struct ScheduledAction {
    pub action: Action,
    pub fire_at: BeatPosition,
    pub priority: Priority,
}

impl BeatScheduler {
    pub fn schedule(&mut self, action: Action, quantize: QuantizeMode) {
        let fire_at = match quantize {
            QuantizeMode::Off => self.timeline.now(),
            QuantizeMode::Beat => self.timeline.next_beat(),
            QuantizeMode::Bar => self.timeline.next_bar(),
            QuantizeMode::Phrase => self.timeline.next_phrase(),
        };

        self.pending.push(ScheduledAction {
            action,
            fire_at,
            priority: Priority::Normal,
        });
    }

    pub fn tick(&mut self, now: BeatPosition) -> Vec<Action> {
        let (ready, pending): (Vec<_>, Vec<_>) = self.pending
            .drain(..)
            .partition(|a| a.fire_at <= now);

        self.pending = pending;
        ready.into_iter().map(|a| a.action).collect()
    }
}

pub struct BeatTimeline {
    link: Option<AbletonLink>,
    local_tempo: f32,
    beat_phase: f32,
    bar_phase: f32,
}

impl BeatTimeline {
    pub fn update(&mut self, dt: f32) {
        if let Some(ref link) = self.link {
            // Sync from Link
            let state = link.capture_audio_session_state();
            self.beat_phase = state.beat_at_time(link.clock_micros()) % 1.0;
            self.bar_phase = state.beat_at_time(link.clock_micros()) % 4.0 / 4.0;
        } else {
            // Local timing
            self.beat_phase = (self.beat_phase + dt / self.beat_duration()) % 1.0;
            self.bar_phase = (self.bar_phase + dt / (self.beat_duration() * 4.0)) % 1.0;
        }
    }

    pub fn next_beat(&self) -> BeatPosition {
        BeatPosition::from_phase(1.0 - self.beat_phase)
    }
}

pub struct AudioEngine {
    sample_rate: u32,       // 48000
    buffer_size: usize,     // 256
    channels: Vec<Channel>,
    master: MasterChannel,
}

impl AudioEngine {
    /// Audio callback - MUST be lock-free, allocation-free
    pub fn process(&mut self, output: &mut [f32]) {
        // Clear output
        for sample in output.iter_mut() {
            *sample = 0.0;
        }

        // Mix channels
        for channel in &mut self.channels {
            if channel.is_active() {
                channel.render_into(output);
            }
        }

        // Master processing
        self.master.process(output);
    }
}

pub enum Action {
    // Transport
    Play,
    Pause,
    CueSet,
    CueGoto,

    // Mixing
    CrossfaderLeft(f32),
    CrossfaderRight(f32),
    EqLow(u8, f32),     // (deck, value)
    EqMid(u8, f32),
    EqHigh(u8, f32),

    // Effects
    EffectOn(u8),       // effect slot
    EffectOff(u8),
    EffectDry(u8, f32),

    // Loops
    LoopIn,
    LoopOut,
    LoopDouble,
    LoopHalf,

    // Navigation
    JumpForward(f32),   // beats
    JumpBack(f32),
}

pub struct RekordboxBridge {
    midi_out: MidiOutput,
    key_mappings: HashMap<Action, MidiMessage>,
}

impl RekordboxBridge {
    pub fn send(&mut self, action: Action) -> Result<()> {
        if let Some(msg) = self.key_mappings.get(&action) {
            self.midi_out.send(msg)?;
        }
        Ok(())
    }
}

pub struct SeratoBridge {
    osc_client: OscClient,
    address_mappings: HashMap<Action, String>,
}

impl SeratoBridge {
    pub fn send(&mut self, action: Action) -> Result<()> {
        if let Some(addr) = self.address_mappings.get(&action) {
            self.osc_client.send(addr, action.value())?;
        }
        Ok(())
    }
}

pub struct ConductorConfig {
    pub base_tempo: f32,        // 120.0
    pub tempo_range: (f32, f32), // (80.0, 160.0)
    pub tempo_smoothing: f32,   // 0.95
    pub quantize_mode: QuantizeMode, // Bar
    pub link_enabled: bool,     // true
}

pub struct AudioConfig {
    pub sample_rate: u32,       // 48000
    pub buffer_size: usize,     // 256
    pub channels: usize,        // 2
    pub output_device: String,
}