codename-206/src/lib.rs

use nih_plug::prelude::*;
use nih_plug_egui::{
    create_egui_editor,
    egui::{self, Vec2},
    resizable_window::ResizableWindow,
    widgets, EguiState,
};
use std::sync::Arc;

mod dsp;
use dsp::compressor::{Compressor, CompressorSettings, MAX_LOOKAHEAD_MS};
use dsp::crossover::Crossover;
use dsp::limiter::Limiter;

/// Band indices into the compressor array: low, mid, high, then the 'All' aggregate channel.
const LOW: usize = 0;
const MID: usize = 1;
const HIGH: usize = 2;
const ALL: usize = 3;

/// Level-detection mode for a compressor's detector.
#[derive(Enum, PartialEq, Clone, Copy)]
enum DetectionMode {
    #[id = "peak"]
    #[name = "Peak"]
    Peak,
    #[id = "rms"]
    #[name = "RMS"]
    Rms,
}

/// Codename 206 — Stage 3: 3-band crossover + per-band compressors summed into an 'All' channel.
///
/// Signal: input → LR4 crossover → {low, mid, high} each through their own compressor → sum →
/// 'All' compressor → output. Bypassing low+mid+high collapses it to a plain full-band comp
/// driven by the 'All' channel (the crossover sums flat).
struct Codename206 {
    params: Arc<Codename206Params>,
    sample_rate: f32,
    crossover: Crossover,
    /// Compressors indexed by [`LOW`], [`MID`], [`HIGH`], [`ALL`].
    comps: [Compressor; 4],
    /// Output brickwall limiter (final stage).
    limiter: Limiter,
}

#[derive(Params)]
struct Codename206Params {
    #[persist = "editor-state"]
    editor_state: Arc<EguiState>,

    /// Low/Mid crossover frequency.
    #[id = "xover_lo"]
    pub crossover_low_hz: FloatParam,
    /// Mid/High crossover frequency.
    #[id = "xover_hi"]
    pub crossover_high_hz: FloatParam,
    /// Global look-ahead time (constant reported latency — safe to adjust during playback).
    #[id = "lookahead"]
    pub look_ahead_ms: FloatParam,

    /// Output brickwall ceiling (the limiter never lets output exceed this).
    #[id = "ceiling"]
    pub output_ceiling_db: FloatParam,
    /// Output limiter release time.
    #[id = "lim_rel"]
    pub limiter_release_ms: FloatParam,

    #[nested(id_prefix = "low", group = "Low")]
    pub low: CompressorParams,
    #[nested(id_prefix = "mid", group = "Mid")]
    pub mid: CompressorParams,
    #[nested(id_prefix = "high", group = "High")]
    pub high: CompressorParams,
    #[nested(id_prefix = "all", group = "All")]
    pub all: CompressorParams,
}

#[derive(Params)]
struct CompressorParams {
    #[id = "detect"]
    pub detection: EnumParam<DetectionMode>,
    #[id = "thresh"]
    pub threshold_db: FloatParam,
    #[id = "ratio"]
    pub ratio: FloatParam,
    #[id = "knee"]
    pub knee_db: FloatParam,
    #[id = "attack"]
    pub attack_ms: FloatParam,
    #[id = "release"]
    pub release_ms: FloatParam,
    #[id = "makeup"]
    pub makeup_db: FloatParam,
    #[id = "bypass"]
    pub bypass: BoolParam,
}

impl Default for Codename206 {
    fn default() -> Self {
        Self {
            params: Arc::new(Codename206Params::default()),
            sample_rate: 48_000.0,
            crossover: Crossover::new(),
            comps: [Compressor::new(), Compressor::new(), Compressor::new(), Compressor::new()],
            limiter: Limiter::new(),
        }
    }
}

impl Default for Codename206Params {
    fn default() -> Self {
        Self {
            editor_state: EguiState::from_size(760, 520),

            crossover_low_hz: FloatParam::new(
                "Crossover Lo/Mid",
                200.0,
                FloatRange::Skewed { min: 30.0, max: 1_000.0, factor: FloatRange::skew_factor(-1.0) },
            )
            .with_value_to_string(formatters::v2s_f32_hz_then_khz(0))
            .with_string_to_value(formatters::s2v_f32_hz_then_khz()),

            crossover_high_hz: FloatParam::new(
                "Crossover Mid/Hi",
                2_500.0,
                FloatRange::Skewed { min: 500.0, max: 18_000.0, factor: FloatRange::skew_factor(-1.0) },
            )
            .with_value_to_string(formatters::v2s_f32_hz_then_khz(0))
            .with_string_to_value(formatters::s2v_f32_hz_then_khz()),

            look_ahead_ms: FloatParam::new(
                "Look-ahead",
                2.0,
                FloatRange::Linear { min: 0.0, max: MAX_LOOKAHEAD_MS },
            )
            .with_unit(" ms")
            .with_value_to_string(formatters::v2s_f32_rounded(2)),

            output_ceiling_db: FloatParam::new(
                "Ceiling",
                0.0,
                FloatRange::Linear { min: -24.0, max: 0.0 },
            )
            .with_unit(" dB")
            .with_value_to_string(formatters::v2s_f32_rounded(1)),

            limiter_release_ms: FloatParam::new(
                "Limiter Release",
                100.0,
                FloatRange::Skewed { min: 1.0, max: 1_000.0, factor: FloatRange::skew_factor(-2.0) },
            )
            .with_unit(" ms")
            .with_value_to_string(formatters::v2s_f32_rounded(1)),

            low: CompressorParams::default(),
            mid: CompressorParams::default(),
            high: CompressorParams::default(),
            all: CompressorParams::default(),
        }
    }
}

impl Default for CompressorParams {
    fn default() -> Self {
        Self {
            detection: EnumParam::new("Detection", DetectionMode::Peak),

            threshold_db: FloatParam::new(
                "Threshold",
                -18.0,
                FloatRange::Linear { min: -60.0, max: 0.0 },
            )
            .with_unit(" dB")
            .with_value_to_string(formatters::v2s_f32_rounded(1)),

            ratio: FloatParam::new(
                "Ratio",
                2.0,
                FloatRange::Skewed { min: 1.0, max: 20.0, factor: FloatRange::skew_factor(-1.0) },
            )
            .with_value_to_string(Arc::new(|v| format!("{v:.2} : 1")))
            .with_string_to_value(Arc::new(|s| {
                s.split(':').next().and_then(|x| x.trim().parse::<f32>().ok())
            })),

            knee_db: FloatParam::new("Knee", 6.0, FloatRange::Linear { min: 0.0, max: 24.0 })
                .with_unit(" dB")
                .with_value_to_string(formatters::v2s_f32_rounded(1)),

            attack_ms: FloatParam::new(
                "Attack",
                10.0,
                FloatRange::Skewed { min: 0.0, max: 100.0, factor: FloatRange::skew_factor(-2.0) },
            )
            .with_unit(" ms")
            .with_value_to_string(formatters::v2s_f32_rounded(2)),

            release_ms: FloatParam::new(
                "Release",
                100.0,
                FloatRange::Skewed { min: 1.0, max: 1_000.0, factor: FloatRange::skew_factor(-2.0) },
            )
            .with_unit(" ms")
            .with_value_to_string(formatters::v2s_f32_rounded(1)),

            makeup_db: FloatParam::new("Makeup", 0.0, FloatRange::Linear { min: -12.0, max: 24.0 })
                .with_smoother(SmoothingStyle::Linear(20.0))
                .with_unit(" dB")
                .with_value_to_string(formatters::v2s_f32_rounded(1)),

            bypass: BoolParam::new("Bypass", false),
        }
    }
}

/// Build the per-block compressor settings for one channel's params (makeup filled per sample).
fn build_settings(p: &CompressorParams, lookahead: usize, sample_rate: f32) -> CompressorSettings {
    CompressorSettings {
        threshold_db: p.threshold_db.value(),
        ratio: p.ratio.value(),
        knee_db: p.knee_db.value(),
        attack_coef: Compressor::time_to_coef(p.attack_ms.value(), sample_rate),
        release_coef: Compressor::time_to_coef(p.release_ms.value(), sample_rate),
        makeup_db: 0.0,
        lookahead_samples: lookahead,
        use_rms: p.detection.value() == DetectionMode::Rms,
        bypass: p.bypass.value(),
    }
}

impl Codename206 {
    fn lookahead_samples(&self) -> usize {
        (self.params.look_ahead_ms.value() * 0.001 * self.sample_rate).round() as usize
    }
}

impl Plugin for Codename206 {
    const NAME: &'static str = "206 prototype";
    const VENDOR: &'static str = "Novoyuuparosk";
    const URL: &'static str = env!("CARGO_PKG_HOMEPAGE");
    const EMAIL: &'static str = "mikkeli@novoyuuparosk.org";

    const VERSION: &'static str = env!("CARGO_PKG_VERSION");

    const AUDIO_IO_LAYOUTS: &'static [AudioIOLayout] = &[
        AudioIOLayout {
            main_input_channels: NonZeroU32::new(2),
            main_output_channels: NonZeroU32::new(2),
            ..AudioIOLayout::const_default()
        },
        AudioIOLayout {
            main_input_channels: NonZeroU32::new(1),
            main_output_channels: NonZeroU32::new(1),
            ..AudioIOLayout::const_default()
        },
    ];

    const MIDI_INPUT: MidiConfig = MidiConfig::None;
    const MIDI_OUTPUT: MidiConfig = MidiConfig::None;

    const SAMPLE_ACCURATE_AUTOMATION: bool = true;

    type SysExMessage = ();
    type BackgroundTask = ();

    fn params(&self) -> Arc<dyn Params> {
        self.params.clone()
    }

    fn editor(&mut self, _async_executor: AsyncExecutor<Self>) -> Option<Box<dyn Editor>> {
        let params = self.params.clone();
        let egui_state = self.params.editor_state.clone();
        create_egui_editor(
            self.params.editor_state.clone(),
            (),
            |_, _| {},
            move |egui_ctx, setter, _state| {
                // One column of controls for a single compressor channel.
                let band_col = |ui: &mut egui::Ui, title: &str, p: &CompressorParams| {
                    ui.strong(title);
                    ui.add(widgets::ParamSlider::for_param(&p.detection, setter));
                    ui.label("Threshold");
                    ui.add(widgets::ParamSlider::for_param(&p.threshold_db, setter));
                    ui.label("Ratio");
                    ui.add(widgets::ParamSlider::for_param(&p.ratio, setter));
                    ui.label("Knee");
                    ui.add(widgets::ParamSlider::for_param(&p.knee_db, setter));
                    ui.label("Attack");
                    ui.add(widgets::ParamSlider::for_param(&p.attack_ms, setter));
                    ui.label("Release");
                    ui.add(widgets::ParamSlider::for_param(&p.release_ms, setter));
                    ui.label("Makeup");
                    ui.add(widgets::ParamSlider::for_param(&p.makeup_db, setter));
                    ui.add(widgets::ParamSlider::for_param(&p.bypass, setter));
                };

                // Resizable window; vertical scroll so every control stays reachable even when the
                // window is small. (Placeholder layout — Stage 6 will replace it.)
                ResizableWindow::new("editor")
                    .min_size(Vec2::new(480.0, 320.0))
                    .show(egui_ctx, egui_state.as_ref(), |ui| {
                        egui::ScrollArea::vertical().show(ui, |ui| {
                            ui.heading(Self::NAME);
                            // Global controls stacked vertically so they never overflow sideways.
                            egui::Grid::new("globals").num_columns(2).show(ui, |ui| {
                                ui.label("Xover Lo/Mid");
                                ui.add(widgets::ParamSlider::for_param(&params.crossover_low_hz, setter));
                                ui.end_row();
                                ui.label("Xover Mid/Hi");
                                ui.add(widgets::ParamSlider::for_param(&params.crossover_high_hz, setter));
                                ui.end_row();
                                ui.label("Look-ahead");
                                ui.add(widgets::ParamSlider::for_param(&params.look_ahead_ms, setter));
                                ui.end_row();
                                ui.label("Ceiling");
                                ui.add(widgets::ParamSlider::for_param(&params.output_ceiling_db, setter));
                                ui.end_row();
                                ui.label("Lim Release");
                                ui.add(widgets::ParamSlider::for_param(&params.limiter_release_ms, setter));
                                ui.end_row();
                            });
                            ui.separator();
                            ui.columns(4, |cols| {
                                band_col(&mut cols[0], "LOW", &params.low);
                                band_col(&mut cols[1], "MID", &params.mid);
                                band_col(&mut cols[2], "HIGH", &params.high);
                                band_col(&mut cols[3], "ALL", &params.all);
                            });
                        });
                    });
            },
        )
    }

    fn initialize(
        &mut self,
        audio_io_layout: &AudioIOLayout,
        buffer_config: &BufferConfig,
        context: &mut impl InitContext<Self>,
    ) -> bool {
        self.sample_rate = buffer_config.sample_rate;
        let channels = audio_io_layout
            .main_output_channels
            .map(NonZeroU32::get)
            .unwrap_or(2) as usize;

        for comp in &mut self.comps {
            comp.prepare(self.sample_rate, channels, MAX_LOOKAHEAD_MS);
        }
        self.crossover.prepare(channels);
        self.crossover.update(
            self.sample_rate,
            self.params.crossover_low_hz.value(),
            self.params.crossover_high_hz.value(),
        );
        self.limiter.prepare(self.sample_rate, channels);

        // Three series stages each with a fixed look-ahead delay: the bands, the 'All' channel,
        // and the output limiter. Reported once as a constant; see the compressor look-ahead note.
        let total_latency =
            self.comps[LOW].latency() + self.comps[ALL].latency() + self.limiter.latency();
        context.set_latency_samples(total_latency);
        true
    }

    fn reset(&mut self) {
        self.crossover.reset();
        for comp in &mut self.comps {
            comp.reset();
        }
        self.limiter.reset();
    }

    fn process(
        &mut self,
        buffer: &mut Buffer,
        _aux: &mut AuxiliaryBuffers,
        _context: &mut impl ProcessContext<Self>,
    ) -> ProcessStatus {
        let lookahead = self.lookahead_samples();

        // Crossover coefficients track the frequency params (recomputed per block — cheap).
        self.crossover.update(
            self.sample_rate,
            self.params.crossover_low_hz.value(),
            self.params.crossover_high_hz.value(),
        );

        // Block-rate settings for the three bands + the 'All' channel.
        let band_params = [&self.params.low, &self.params.mid, &self.params.high];
        let mut band_set = [
            build_settings(&self.params.low, lookahead, self.sample_rate),
            build_settings(&self.params.mid, lookahead, self.sample_rate),
            build_settings(&self.params.high, lookahead, self.sample_rate),
        ];
        let mut all_set = build_settings(&self.params.all, lookahead, self.sample_rate);

        // Output limiter settings (block-rate).
        let ceiling = util::db_to_gain(self.params.output_ceiling_db.value());
        let limiter_release =
            Compressor::time_to_coef(self.params.limiter_release_ms.value(), self.sample_rate);

        let mut in_frame = [0.0f32; 2];
        let mut band_in = [[0.0f32; 2]; 3];
        let mut band_out = [[0.0f32; 2]; 3];
        let mut summed = [0.0f32; 2];
        let mut out_frame = [0.0f32; 2];
        let mut lim_frame = [0.0f32; 2];

        for mut frame in buffer.iter_samples() {
            let n = frame.len().min(2);
            for ch in 0..n {
                in_frame[ch] = *frame.get_mut(ch).unwrap();
            }

            // Split each channel into low/mid/high.
            for ch in 0..n {
                let [lo, mid, hi] = self.crossover.split(ch, in_frame[ch]);
                band_in[LOW][ch] = lo;
                band_in[MID][ch] = mid;
                band_in[HIGH][ch] = hi;
            }

            // Compress each band (per-sample smoothed makeup), then sum.
            summed[..n].fill(0.0);
            for b in 0..3 {
                band_set[b].makeup_db = band_params[b].makeup_db.smoothed.next();
                self.comps[b].process(&band_in[b][..n], &mut band_out[b][..n], &band_set[b]);
                for ch in 0..n {
                    summed[ch] += band_out[b][ch];
                }
            }

            // 'All' aggregate channel over the summed bands.
            all_set.makeup_db = self.params.all.makeup_db.smoothed.next();
            self.comps[ALL].process(&summed[..n], &mut out_frame[..n], &all_set);

            // Output brickwall limiter.
            self.limiter.process(&out_frame[..n], &mut lim_frame[..n], ceiling, limiter_release);

            for ch in 0..n {
                *frame.get_mut(ch).unwrap() = lim_frame[ch];
            }
        }

        ProcessStatus::Normal
    }
}

impl ClapPlugin for Codename206 {
    const CLAP_ID: &'static str = "com.mikkeli.codename-206";
    const CLAP_DESCRIPTION: Option<&'static str> =
        Some("Multiband compressor/limiter (stage 3: 3-band + 'All' channel)");
    const CLAP_MANUAL_URL: Option<&'static str> = Some(Self::URL);
    const CLAP_SUPPORT_URL: Option<&'static str> = None;
    const CLAP_FEATURES: &'static [ClapFeature] = &[
        ClapFeature::AudioEffect,
        ClapFeature::Stereo,
        ClapFeature::Mono,
        ClapFeature::Compressor,
        ClapFeature::Limiter,
    ];
}

impl Vst3Plugin for Codename206 {
    const VST3_CLASS_ID: [u8; 16] = *b"Codename206Maxi!";
    const VST3_SUBCATEGORIES: &'static [Vst3SubCategory] =
        &[Vst3SubCategory::Fx, Vst3SubCategory::Dynamics];
}

nih_export_clap!(Codename206);
nih_export_vst3!(Codename206);