selene-core 0.3.0

use std::{path::Path, sync::Arc};

use barber::{ProgressBar, ProgressRenderer};
use rayon::{
    ThreadPoolBuilder,
    iter::{IntoParallelIterator, ParallelIterator},
};

use crate::{
    config::common::common_config,
    database::{DatabaseEntry, DatabaseError, writer::db_sync_transaction},
    errors::{FfmpegError, ImportError, LibraryError},
    ffmpeg::{command_mutators::FfmpegPresets, ffmpeg, loudnorm::LoudnormAnalysis, output_ffmpeg},
    library::{album::Album, artist::Artist, track::Track},
    media_container::MediaContainer,
};

#[derive(Debug, Clone)]
pub struct ExtractResult {
    pub track: Track,
    pub album: Option<Album>,
    pub artists: Vec<Artist>,
}

/// Optional flags when importing a track
#[derive(Debug, Clone, Copy)]
pub struct TrackImportOptions {
    pub dry: bool,
    pub apply_loudnorm: bool,
}

/// Scans the input `tracks` for tracks that need to be reimported
///
/// Tracks need to be reimported if:
/// - Their source file exists, but their library file does not
/// - Loudnorm config is input, but their loudnorm config does not match the input config
pub fn scan_for_reimport(loudnorm: bool) -> Result<Vec<Track>, DatabaseError> {
    let mut tracks = Track::db_get_all()?;
    let loudnorm_with = loudnorm.then_some(common_config().loudnorm_config);

    tracks.retain(|track| {
        let missing_lib = track.lib_container().is_none_or(|c| !c.path().is_file());
        let needs_loudnorm = loudnorm_with.is_some_and(|cfg| track.loudnorm() != Some(&cfg));

        missing_lib || needs_loudnorm
    });

    Ok(tracks)
}

/// Reimports the input tracks
///
/// # Errors
///
/// Errors if
pub fn reimport(
    tracks: Vec<Track>,
    progress_renderer: Arc<dyn ProgressRenderer>,
    options: TrackImportOptions,
) -> Result<(), ImportError> {
    if tracks.is_empty() {
        return Ok(());
    }

    let library_dir = common_config()
        .library_dir()
        .ok_or(LibraryError::NoLibrary)?
        .to_path_buf();

    for track in &tracks {
        track.ensure_parent_dirs(&library_dir)?;
    }

    let progress_bar = ProgressBar::new(0, tracks.len(), progress_renderer);
    progress_bar.set_label("Importing files...");

    let max_threads = (rayon::current_num_threads() as f32 * 0.33).ceil() as usize;

    let thread_pool = ThreadPoolBuilder::new()
        .num_threads(max_threads)
        .build()
        .unwrap();

    thread_pool.install(|| {
        tracks
            .into_par_iter()
            .try_for_each(|track| -> Result<(), DatabaseError> {
                let import_to = library_dir.join(&track.relative_library_path);
                let track_path = track.relative_library_path.display().to_string();

                if let Err(err) = import(track, import_to, options) {
                    progress_bar.set_label(&format!("Failed to import {track_path}: {err}",));
                } else {
                    progress_bar.set_label(&format!("Imported '{track_path}'",));
                }

                progress_bar.increment();
                Ok(())
            })
    })?;

    progress_bar.flush();
    Ok(())
}

pub fn import(
    mut track: Track,
    to: impl AsRef<Path>,
    options: TrackImportOptions,
) -> Result<(), ImportError> {
    let audio_source = track.src_container().path();

    let (container, codec) = track
        .src_container()
        .transcode_to()
        .ok_or(FfmpegError::Other(
        "Cannot transcode the input container: Unsupported or unrecognized container/codec pair"
            .to_owned(),
    ))?;

    let container = container.format_name();
    let codec = codec.codec_name();

    let mut command = ffmpeg();

    command.input_file(audio_source);

    if let Some(cover) = &track.metadata.cover_art {
        if cover.source() == audio_source {
            command.cover_art_from(0);
        } else {
            command.input_file(cover.source());
            command.cover_art_from(1);
        }
    }

    command.set_codec(codec);

    if options.apply_loudnorm {
        let measured = if let Some(loudnorm_analysis) = track.loudnorm_analysis {
            loudnorm_analysis
        } else {
            LoudnormAnalysis::from_file(audio_source)?
        };

        track.loudnorm_analysis = Some(measured);

        command.apply_loudnorm_filter(measured);
    }

    command.map_audio_from(0);
    command.drop_subtitles();
    command.set_container(container);

    command.drop_metadata();

    let metadata = track.metadata_key_values()?;
    command.add_metadata_group(metadata.iter());

    let output_file = to.as_ref();

    command.output_file(output_file);

    output_ffmpeg(command)?;

    let lib_container = MediaContainer::from_file(output_file.to_path_buf())?;
    track.lib_container = Some(lib_container);

    if options.apply_loudnorm {
        let loudnorm_config = common_config().loudnorm_config;
        track.set_loudnorm(loudnorm_config);
    }

    db_sync_transaction(move |cas_tx| cas_tx.tx_patch(track.clone()), false)?;

    Ok(())
}

/// Returns an error with the corrected value if one is detected, else returns ()
pub fn valdiate_tag_value(title: &str) -> Result<(), String> {
    if title.chars().any(char::is_control) {
        let fixed: String = title.chars().filter(|c| !c.is_control()).collect();
        Err(fixed)
    } else {
        Ok(())
    }
}