//! End-to-end integration test: import real audio -> analyze -> search -> tag -> export.
//!
//! Generates a valid 16-bit PCM WAV sine wave programmatically (no external files),
//! then exercises the full pipeline: content-addressed import, audio analysis,
//! VFS organisation, search by text/properties/tags, and export to filesystem.

use std::f32::consts::PI;
use std::fs;
use std::path::{Path, PathBuf};

use audiofiles_core::analysis::{self, config::AnalysisConfig};
use audiofiles_core::db::Database;
use audiofiles_core::export::{
    collect_export_items, enrich_with_tags, run_export, ExportChannels, ExportConfig,
    ExportFormat,
};
use audiofiles_core::search::{SearchFilter, SearchScope};
use audiofiles_core::store::SampleStore;
use audiofiles_core::{search, tags, vfs};

/// Generate a 16-bit PCM WAV file containing a sine wave.
///
/// Parameters:
/// - `path`: output file path
/// - `sample_rate`: e.g. 44100
/// - `frequency`: sine wave frequency in Hz (e.g. 440.0)
/// - `duration_secs`: length of the generated audio
fn generate_sine_wav(path: &Path, sample_rate: u32, frequency: f32, duration_secs: f32) {
    let spec = hound::WavSpec {
        channels: 1,
        sample_rate,
        bits_per_sample: 16,
        sample_format: hound::SampleFormat::Int,
    };
    let mut writer = hound::WavWriter::create(path, spec).unwrap();
    let num_samples = (sample_rate as f32 * duration_secs) as usize;
    let amplitude = 0.8_f32; // -1.94 dBFS peak

    for i in 0..num_samples {
        let t = i as f32 / sample_rate as f32;
        let sample = amplitude * (2.0 * PI * frequency * t).sin();
        // Scale to 16-bit range
        let scaled = (sample * i16::MAX as f32) as i16;
        writer.write_sample(scaled).unwrap();
    }
    writer.finalize().unwrap();
}

/// Helper: set up a temp directory, database, sample store, and a generated WAV file.
struct TestEnv {
    dir: tempfile::TempDir,
    db: Database,
    store: SampleStore,
    wav_path: PathBuf,
}

impl TestEnv {
    fn new() -> Self {
        let dir = tempfile::tempdir().unwrap();
        let db = Database::open_in_memory().unwrap();
        let store_dir = dir.path().join("store");
        let store = SampleStore::new(&store_dir).unwrap();

        // Generate a ~0.5-second 440 Hz sine wave at 44100 Hz, 16-bit mono
        let wav_path = dir.path().join("test_sine_440.wav");
        generate_sine_wav(&wav_path, 44100, 440.0, 0.5);

        Self {
            dir,
            db,
            store,
            wav_path,
        }
    }
}

#[test]
fn e2e_import_analyze_search_tag_export() {
    let env = TestEnv::new();

    // ── Step 1: Import ──────────────────────────────────────────
    // Import the generated WAV into the content-addressed store.
    let hash = env.store.import(&env.wav_path, &env.db).unwrap();

    // Verify the hash is a valid 64-char lowercase hex SHA-256.
    assert_eq!(hash.len(), 64);
    assert!(hash.chars().all(|c| c.is_ascii_hexdigit() && !c.is_ascii_uppercase()));

    // Verify the file exists in the store.
    assert!(env.store.exists(&hash, "wav").unwrap());

    // Verify the sample row exists in the database.
    let row_count: i64 = env
        .db
        .conn()
        .query_row(
            "SELECT COUNT(*) FROM samples WHERE hash = ?1",
            [&hash],
            |row| row.get(0),
        )
        .unwrap();
    assert_eq!(row_count, 1);

    // Verify deduplication: importing again yields the same hash.
    let hash2 = env.store.import(&env.wav_path, &env.db).unwrap();
    assert_eq!(hash, hash2);

    // ── Step 2: Create VFS and link sample ──────────────────────
    let vfs_id = vfs::create_vfs(&env.db, "TestLibrary").unwrap();
    let drums_dir = vfs::create_directory(&env.db, vfs_id, None, "Drums").unwrap();
    let node_id = vfs::create_sample_link(
        &env.db,
        vfs_id,
        Some(drums_dir),
        "test_sine_440.wav",
        &hash,
    )
    .unwrap();

    // Verify the VFS node was created correctly.
    let node = vfs::get_node(&env.db, node_id).unwrap();
    assert_eq!(node.name, "test_sine_440.wav");
    assert_eq!(node.sample_hash.as_deref(), Some(hash.as_str()));

    // Verify listing children works.
    let children = vfs::list_children(&env.db, vfs_id, Some(drums_dir)).unwrap();
    assert_eq!(children.len(), 1);
    assert_eq!(children[0].name, "test_sine_440.wav");

    // ── Step 3: Run audio analysis ──────────────────────────────
    let store_path = env.store.sample_path(&hash, "wav").unwrap();
    let config = AnalysisConfig::default();
    let result = analysis::analyze_sample(&hash, &store_path, &config).unwrap();

    // Verify basic properties from the generated file.
    assert_eq!(result.hash, hash);
    assert_eq!(result.sample_rate, 44100);
    assert_eq!(result.channels, 1);

    // Duration should be approximately 0.5 seconds.
    assert!(
        (result.duration - 0.5).abs() < 0.02,
        "expected duration ~0.5s, got {}",
        result.duration
    );

    // Peak should be close to -1.94 dBFS (0.8 amplitude).
    assert!(result.peak_db.is_some());
    let peak = result.peak_db.unwrap();
    assert!(
        (peak - (-1.94)).abs() < 0.5,
        "expected peak ~-1.94 dBFS, got {peak}"
    );

    // RMS should be about -4.95 dBFS (sine at 0.8 amplitude).
    assert!(result.rms_db.is_some());

    // BPM may or may not be detected on a short sine wave, but the field should exist.
    // Musical key should be detected for a pure 440 Hz tone (A).
    // These are best-effort checks; the exact values depend on the algorithms.

    // Save analysis to DB.
    analysis::save_analysis(&env.db, &result).unwrap();

    // Verify analysis is retrievable.
    let loaded = analysis::load_analysis(&env.db, &hash);
    assert!(loaded.is_some());
    let loaded = loaded.unwrap();
    assert_eq!(loaded.hash, hash);
    assert_eq!(loaded.sample_rate, 44100);
    assert!(
        (loaded.duration - result.duration).abs() < 0.001,
        "loaded duration should match saved"
    );
    assert_eq!(loaded.peak_db, result.peak_db);

    // ── Step 4: Search by text (filename) ───────────────────────
    let filter = SearchFilter {
        text_query: "sine".to_string(),
        ..Default::default()
    };
    let results = search::search_in_folder(&env.db, &filter, vfs_id, Some(drums_dir)).unwrap();
    assert_eq!(results.len(), 1);
    assert_eq!(results[0].node.name, "test_sine_440.wav");

    // Text search that doesn't match should return empty.
    let filter_miss = SearchFilter {
        text_query: "nonexistent_sample".to_string(),
        ..Default::default()
    };
    let results_miss =
        search::search_in_folder(&env.db, &filter_miss, vfs_id, Some(drums_dir)).unwrap();
    assert!(results_miss.is_empty());

    // ── Step 5: Search by analysis properties ───────────────────
    // Duration filter: our sample is ~0.5s, so filtering 0.3-0.7 should match.
    let filter_duration = SearchFilter {
        duration_min: Some(0.3),
        duration_max: Some(0.7),
        ..Default::default()
    };
    let results_dur =
        search::search_in_folder(&env.db, &filter_duration, vfs_id, Some(drums_dir)).unwrap();
    assert_eq!(results_dur.len(), 1);

    // Duration filter that excludes: minimum 2.0s should find nothing.
    let filter_long = SearchFilter {
        duration_min: Some(2.0),
        ..Default::default()
    };
    let results_long =
        search::search_in_folder(&env.db, &filter_long, vfs_id, Some(drums_dir)).unwrap();
    assert!(results_long.is_empty());

    // Classification filter: if the analysis classified the sample, search for it.
    if let Some(ref class) = result.classification {
        let filter_class = SearchFilter {
            classifications: vec![class.as_str().to_string()],
            ..Default::default()
        };
        let results_class =
            search::search_in_folder(&env.db, &filter_class, vfs_id, Some(drums_dir)).unwrap();
        assert_eq!(results_class.len(), 1);
    }

    // ── Step 6: Global search ───────────────────────────────────
    let global_filter = SearchFilter {
        text_query: "sine".to_string(),
        scope: SearchScope::Global,
        ..Default::default()
    };
    let global_results = search::search_global(&env.db, &global_filter).unwrap();
    assert_eq!(global_results.len(), 1);
    assert_eq!(global_results[0].node.name, "test_sine_440.wav");

    // ── Step 7: Tag the sample and search by tags ───────────────
    tags::add_tag(&env.db, &hash, "instrument.synth").unwrap();
    tags::add_tag(&env.db, &hash, "frequency.440hz").unwrap();
    tags::add_tag(&env.db, &hash, "test").unwrap();

    // Verify tags are stored.
    let sample_tags = tags::get_sample_tags(&env.db, &hash).unwrap();
    assert_eq!(sample_tags.len(), 3);
    assert!(sample_tags.contains(&"instrument.synth".to_string()));
    assert!(sample_tags.contains(&"frequency.440hz".to_string()));
    assert!(sample_tags.contains(&"test".to_string()));

    // Search by tag prefix.
    let filter_tag = SearchFilter {
        required_tags: vec!["instrument".to_string()],
        ..Default::default()
    };
    let results_tag =
        search::search_in_folder(&env.db, &filter_tag, vfs_id, Some(drums_dir)).unwrap();
    assert_eq!(results_tag.len(), 1);
    assert_eq!(results_tag[0].node.name, "test_sine_440.wav");

    // Search by a tag that doesn't match.
    let filter_tag_miss = SearchFilter {
        required_tags: vec!["percussion".to_string()],
        ..Default::default()
    };
    let results_tag_miss =
        search::search_in_folder(&env.db, &filter_tag_miss, vfs_id, Some(drums_dir)).unwrap();
    assert!(results_tag_miss.is_empty());

    // Combined: text + tag + duration.
    let filter_combined = SearchFilter {
        text_query: "sine".to_string(),
        required_tags: vec!["test".to_string()],
        duration_min: Some(0.3),
        duration_max: Some(0.7),
        ..Default::default()
    };
    let results_combined =
        search::search_in_folder(&env.db, &filter_combined, vfs_id, Some(drums_dir)).unwrap();
    assert_eq!(results_combined.len(), 1);

    // ── Step 8: Export ──────────────────────────────────────────
    let export_dest = env.dir.path().join("export_output");

    // Collect export items from VFS.
    let mut items = collect_export_items(&env.db, vfs_id, None).unwrap();
    assert_eq!(items.len(), 1);
    assert_eq!(items[0].name, "test_sine_440.wav");
    assert_eq!(items[0].relative_path, PathBuf::from("Drums/test_sine_440.wav"));

    // Enrich with tags.
    enrich_with_tags(&env.db, &mut items);
    assert_eq!(items[0].tags.len(), 3);

    // Export as original format, preserving directory structure.
    let export_config = ExportConfig {
        format: ExportFormat::Original,
        sample_rate: None,
        bit_depth: None,
        channels: ExportChannels::Original,
        naming_pattern: None,
        flatten: false,
        metadata_sidecar: true,
        destination: export_dest.clone(),
        device_profile: None,
        naming_rules: None,
        max_file_size_bytes: None,
        name_overrides: None,
    };

    let summary = run_export(&items, &export_config, &env.store, |_, _, _| true).unwrap();
    assert_eq!(summary.total, 1);
    assert!(summary.errors.is_empty(), "export errors: {:?}", summary.errors);

    // Verify the exported file exists with correct directory structure.
    let exported_file = export_dest.join("Drums").join("test_sine_440.wav");
    assert!(exported_file.exists(), "exported file should exist at Drums/test_sine_440.wav");

    // Verify the exported file content matches the store copy.
    let store_bytes = fs::read(env.store.sample_path(&hash, "wav").unwrap()).unwrap();
    let export_bytes = fs::read(&exported_file).unwrap();
    assert_eq!(store_bytes, export_bytes, "exported file should match store content");

    // Verify the metadata sidecar was written.
    let sidecar_path = export_dest.join("Drums").join("test_sine_440.wav.audiofiles.json");
    assert!(sidecar_path.exists(), "metadata sidecar should exist");

    let sidecar_content: serde_json::Value =
        serde_json::from_str(&fs::read_to_string(&sidecar_path).unwrap()).unwrap();
    assert_eq!(sidecar_content["name"], "test_sine_440.wav");
    assert!(sidecar_content["hash"].is_string());
    // Tags should be present in the sidecar.
    let sidecar_tags = sidecar_content["tags"].as_array().unwrap();
    assert_eq!(sidecar_tags.len(), 3);

    // ── Step 9: Export with format conversion (WAV 16-bit) ──────
    let export_dest_wav = env.dir.path().join("export_wav16");
    let export_config_wav = ExportConfig {
        format: ExportFormat::Wav,
        sample_rate: Some(44100),
        bit_depth: Some(16),
        channels: ExportChannels::Mono,
        naming_pattern: None,
        flatten: true,
        metadata_sidecar: false,
        destination: export_dest_wav.clone(),
        device_profile: None,
        naming_rules: None,
        max_file_size_bytes: None,
        name_overrides: None,
    };

    let summary_wav =
        run_export(&items, &export_config_wav, &env.store, |_, _, _| true).unwrap();
    assert!(summary_wav.errors.is_empty(), "WAV export errors: {:?}", summary_wav.errors);

    let exported_wav = export_dest_wav.join("test_sine_440.wav");
    assert!(exported_wav.exists(), "re-encoded WAV should exist");

    // Verify it's a valid 16-bit WAV using hound.
    let reader = hound::WavReader::open(&exported_wav).unwrap();
    assert_eq!(reader.spec().bits_per_sample, 16);
    assert_eq!(reader.spec().sample_rate, 44100);
    assert_eq!(reader.spec().channels, 1);
}

/// Separate test to verify the analysis pipeline produces sensible spectral results
/// on a known signal, validating the full decode -> analyze -> persist -> retrieve loop.
#[test]
fn e2e_analysis_roundtrip_verify_values() {
    let env = TestEnv::new();

    let hash = env.store.import(&env.wav_path, &env.db).unwrap();
    let store_path = env.store.sample_path(&hash, "wav").unwrap();

    let config = AnalysisConfig::default();
    let result = analysis::analyze_sample(&hash, &store_path, &config).unwrap();
    analysis::save_analysis(&env.db, &result).unwrap();

    // Load back and verify all fields survive the DB roundtrip.
    let loaded = analysis::load_analysis(&env.db, &hash).unwrap();

    assert_eq!(loaded.sample_rate, result.sample_rate);
    assert_eq!(loaded.channels, result.channels);
    assert!((loaded.duration - result.duration).abs() < 0.001);
    assert_eq!(loaded.peak_db, result.peak_db);
    assert_eq!(loaded.rms_db, result.rms_db);
    assert_eq!(loaded.bpm, result.bpm);
    assert_eq!(loaded.musical_key, result.musical_key);
    assert_eq!(loaded.is_loop, result.is_loop);
    assert_eq!(loaded.spectral_centroid, result.spectral_centroid);
    assert_eq!(loaded.spectral_flatness, result.spectral_flatness);
    assert_eq!(loaded.spectral_rolloff, result.spectral_rolloff);
    assert_eq!(loaded.zero_crossing_rate, result.zero_crossing_rate);
    assert_eq!(loaded.onset_strength, result.onset_strength);
    assert_eq!(loaded.classification, result.classification);

    // For a pure 440 Hz sine, spectral centroid should be close to 440 Hz.
    if let Some(centroid) = result.spectral_centroid {
        assert!(
            (centroid - 440.0).abs() < 100.0,
            "spectral centroid of 440Hz sine should be near 440Hz, got {centroid}"
        );
    }
}

/// Test that importing multiple different files, tagging them differently,
/// and searching with various filter combinations works correctly.
#[test]
fn e2e_multi_sample_search() {
    let env = TestEnv::new();

    // Generate a second WAV at a different frequency and longer duration.
    let wav2_path = env.dir.path().join("bass_note_80hz.wav");
    generate_sine_wav(&wav2_path, 44100, 80.0, 2.0);

    // Import both.
    let hash1 = env.store.import(&env.wav_path, &env.db).unwrap();
    let hash2 = env.store.import(&wav2_path, &env.db).unwrap();
    assert_ne!(hash1, hash2, "different audio should produce different hashes");

    // Analyze both.
    let config = AnalysisConfig::default();
    let store_path1 = env.store.sample_path(&hash1, "wav").unwrap();
    let result1 = analysis::analyze_sample(&hash1, &store_path1, &config).unwrap();
    analysis::save_analysis(&env.db, &result1).unwrap();

    let store_path2 = env.store.sample_path(&hash2, "wav").unwrap();
    let result2 = analysis::analyze_sample(&hash2, &store_path2, &config).unwrap();
    analysis::save_analysis(&env.db, &result2).unwrap();

    // Create VFS with both samples.
    let vfs_id = vfs::create_vfs(&env.db, "MultiTest").unwrap();
    vfs::create_sample_link(&env.db, vfs_id, None, "test_sine_440.wav", &hash1).unwrap();
    vfs::create_sample_link(&env.db, vfs_id, None, "bass_note_80hz.wav", &hash2).unwrap();

    // Tag differently.
    tags::add_tag(&env.db, &hash1, "instrument.synth").unwrap();
    tags::add_tag(&env.db, &hash1, "frequency.high").unwrap();
    tags::add_tag(&env.db, &hash2, "instrument.bass").unwrap();
    tags::add_tag(&env.db, &hash2, "frequency.low").unwrap();

    // Search: all samples (no filter).
    let filter_all = SearchFilter::default();
    let all = search::search_in_folder(&env.db, &filter_all, vfs_id, None).unwrap();
    assert_eq!(all.len(), 2);

    // Search by text: "bass" should match only one.
    let filter_bass = SearchFilter {
        text_query: "bass".to_string(),
        ..Default::default()
    };
    let bass_results = search::search_in_folder(&env.db, &filter_bass, vfs_id, None).unwrap();
    assert_eq!(bass_results.len(), 1);
    assert_eq!(bass_results[0].node.name, "bass_note_80hz.wav");

    // Search by duration: > 1.0s should match only the 2-second sample.
    let filter_long = SearchFilter {
        duration_min: Some(1.0),
        ..Default::default()
    };
    let long_results = search::search_in_folder(&env.db, &filter_long, vfs_id, None).unwrap();
    assert_eq!(long_results.len(), 1);
    assert_eq!(long_results[0].node.name, "bass_note_80hz.wav");

    // Search by duration: < 1.0s should match only the 0.5-second sample.
    let filter_short = SearchFilter {
        duration_max: Some(1.0),
        ..Default::default()
    };
    let short_results = search::search_in_folder(&env.db, &filter_short, vfs_id, None).unwrap();
    assert_eq!(short_results.len(), 1);
    assert_eq!(short_results[0].node.name, "test_sine_440.wav");

    // Search by tag: "instrument.synth" should match only the first.
    let filter_synth = SearchFilter {
        required_tags: vec!["instrument.synth".to_string()],
        ..Default::default()
    };
    let synth_results = search::search_in_folder(&env.db, &filter_synth, vfs_id, None).unwrap();
    assert_eq!(synth_results.len(), 1);
    assert_eq!(synth_results[0].node.name, "test_sine_440.wav");

    // Search by tag prefix "instrument" should match both.
    let filter_instrument = SearchFilter {
        required_tags: vec!["instrument".to_string()],
        ..Default::default()
    };
    let instrument_results =
        search::search_in_folder(&env.db, &filter_instrument, vfs_id, None).unwrap();
    assert_eq!(instrument_results.len(), 2);

    // Combined: text "bass" + tag "frequency.low" should match one.
    let filter_combo = SearchFilter {
        text_query: "bass".to_string(),
        required_tags: vec!["frequency.low".to_string()],
        ..Default::default()
    };
    let combo_results = search::search_in_folder(&env.db, &filter_combo, vfs_id, None).unwrap();
    assert_eq!(combo_results.len(), 1);
    assert_eq!(combo_results[0].node.name, "bass_note_80hz.wav");

    // Combined: text "bass" + tag "frequency.high" should match zero (contradictory).
    let filter_contradictory = SearchFilter {
        text_query: "bass".to_string(),
        required_tags: vec!["frequency.high".to_string()],
        ..Default::default()
    };
    let contradictory_results =
        search::search_in_folder(&env.db, &filter_contradictory, vfs_id, None).unwrap();
    assert!(contradictory_results.is_empty());
}