debug_batch_matching.rs

#![allow(dead_code)]
use crate::analysis::matching::{ChordMatcher, MatchOutcome, Voicing};
use crate::utils::run_samples::{run_root_batch, RunOptions};
use crate::processing::peak_detection_bands::PeakData;
use crate::utils::logging::{write_summary_md, MatchRecord, FileLogger};
use crate::utils::chord_diagrams::{render_diagram, PathMode};
use crate::utils::weights::MatcherCfg;

use std::collections::HashMap;

pub fn run_chord_matching_batch(root: &str) -> Vec<MatchRecord> {
    let opts = RunOptions {
        top_n: 15,  // allow room for filtering
        threshold_percentile: 90.0,
        enable_bands: true,
        verbose: false,
        plot: false,
    };

    let results: HashMap<String, Vec<PeakData>> = match run_root_batch(root, &opts) {
        Ok(data) => data,
        Err(e) => {
            eprintln!("❌ Batch failed: {}", e);
            return vec![];
        }
    };
    
    // build matcher 
    let mut matcher = ChordMatcher::from_cfg(MatcherCfg::load());
    
    matcher.top_n = 7;                       // truncation post-filtering
    matcher.matched_top_n = 5;               // take n highest scores
    matcher.logger = FileLogger::boxed();    // <-- enables full logging
    
    // use crate::utils::logging::Logger;
    // matcher.logger = Logger::disabled();  // <-- turn logs off

    let mut total = 0;
    let mut correct = 0;
    let mut records: Vec<MatchRecord> = Vec::new();
    let mut summary_rows: Vec<String> = Vec::new();

    println!("\n🎸 Chord Matching Batch for Root: {}", root);
    
    for (label, peaks) in results.iter() {
        let expected = label.trim().to_ascii_lowercase();
        
        // ─────────────────── run matcher ────────────────────────
        let prediction = matcher.identify_chord(
            label, &expected, peaks, Voicing::Barre, true
        );

        // ───────────────── render chord diagram (Certain only) ──────────────
        if let MatchOutcome::Certain { name, .. } = &prediction.outcome {
            // ignore errors, just log
            if let Err(e) = render_diagram(label, name, true, PathMode::Group) {
                eprintln!("⚠️  diagram render failed for {label}: {e}");
            }
        }
        
        // ─────────────────── unpack outcome ─────────────────────
        let (predicted, details_opt) = match prediction.outcome {
            MatchOutcome::Certain { name, details, .. } => (name, Some(details)),
            MatchOutcome::Ambiguous { name, second, .. } =>
                (format!("{name}/{second}"), None),
            MatchOutcome::NoMatch =>
                ("none".to_string(), None),
        };
        
        let predicted_lc = predicted.to_ascii_lowercase();
        let is_match = expected == predicted_lc;

        total += 1;
        if is_match { correct += 1; }
        
        // ─────────────────── collect CSV record ─────────────────
        if let Some(details) = details_opt.as_ref() {
            records.push(MatchRecord {
                label: label.to_string(),
                predicted: predicted_lc.clone(),
                is_match,
                base_score: details.base_score,
                amplitude_bonus: details.amplitude_bonus,
                penalty_extra: details.penalty_extra,
                repetition_bonus: details.repetition_bonus,
                size_bonus: details.size_bonus,
                missing_notes_penalty: details.missing_notes_penalty,
                total_score: details.total_score,
                seventh_score: details.seventh_score,
                matched_count: details.matched.len(),
                extraneous_count: details.extraneous.len(),
                bass_note: details.bass_note.clone(),
                chord_template: format!("{:?}", details.chord_template),
                matched: format!("{:?}", details.matched),
                extraneous: format!("{:?}", details.extraneous),
                detected: format!("{:?}", details.detected),
            });

            // full log only for “Certain”
            matcher.logger.as_ref().log_match_summary(
                root, 
                label, 
                &predicted, 
                details, 
                is_match
            ).ok();
        } else {
            // placeholder row (zeros) for Ambiguous / NoMatch
            records.push(MatchRecord {
                label: label.to_string(),
                predicted: predicted_lc.clone(),
                is_match,
                base_score: 0.0,  amplitude_bonus: 0.0,  penalty_extra: 0.0,
                repetition_bonus: 0.0, size_bonus: 0.0, seventh_score: 0.0,
                missing_notes_penalty: 0.0, total_score: 0.0,
                matched_count: 0, extraneous_count: 0,
                bass_note: "-".into(),
                chord_template: "[]".into(), matched: "[]".into(),
                extraneous: "[]".into(), detected: "[]".into(),
            });
        }

        // ─────────────────── CLI summary row ────────────────────
        let status = if is_match { "✅" } else { "❌" };
        summary_rows.push(format!(
            "| {:<12} | {:<12} | {} |",
            expected, predicted, status
        ));
    }

    // Write a Markdown summary and finish
    if let Err(e) = write_summary_md(root, &summary_rows, total, correct) {
        eprintln!("❌ Failed to write markdown summary for {}: {e}", root);
    };
    
    println!("Summary: {}/{} correct ({:.1}%)", correct, total, 100.0 * correct as f32 / total as f32);
    records.sort_by(|a, b| a.label.to_lowercase().cmp(&b.label.to_lowercase()));
    records
    
}