use std::path::PathBuf;

use crate::utils::formats::AudioContainer;

#[derive(Debug, Clone)]
pub struct Tags {
    pub title: String,
    pub artist: String,
}

impl Default for Tags {
    fn default() -> Self {
        Tags {
            title: "".to_string(),
            artist: "".to_string(),
        }
    }
}

#[derive(Debug, Clone)]

pub struct ReplayGainData {
    pub track_gain: String,
    pub track_peak: String,
}

impl ReplayGainData {
    pub fn to_raw(&self) -> ReplayGainRawData {
        let track_gain = self.track_gain.split(' ').next().unwrap_or("0.0");
        let track_gain = track_gain.parse::<f64>().unwrap();

        let track_peak = self.track_peak.parse::<f64>().unwrap();

        ReplayGainRawData {
            track_gain,
            track_peak,
        }
    }
}

#[derive(Debug, Clone)]
pub struct ReplayGainRawData {
    pub track_gain: f64,
    pub track_peak: f64,
}

impl ReplayGainRawData {
    pub fn to_normal(&self) -> ReplayGainData {
        ReplayGainData {
            track_gain: format!("{:.2} dB", self.track_gain),
            track_peak: format!("{:.6}", self.track_peak),
        }
    }
}

#[derive(Debug, Clone)]
pub struct AudioFileInfo {
    pub tags: Tags,
    pub replaygain: Option<ReplayGainData>,
    pub supports_replaygain: bool,
    pub container: AudioContainer,
}

impl Default for AudioFileInfo {
    fn default() -> Self {
        AudioFileInfo {
            tags: Tags::default(),
            replaygain: None,
            supports_replaygain: false,
            container: AudioContainer::Unknown,
        }
    }
}

#[derive(Debug, Clone)]
pub struct File {
    pub filename: String,
    pub extension: String,

    // relative path to file's folder
    pub path_to: PathBuf,
    // path to folder from source
    pub path_from_source: PathBuf,

    pub extra_files: Vec<File>,

    pub info: AudioFileInfo,
}

impl File {
    pub fn from_path(source_dir: String, full_path: PathBuf) -> File {
        let full_file_path = PathBuf::from(&source_dir).join(full_path);
        let filename = full_file_path
            .file_stem()
            .unwrap()
            .to_str()
            .unwrap()
            .to_string();

        let extension = full_file_path.extension();

        let extension = if let Some(extension) = extension {
            extension.to_str().unwrap().to_string()
        } else {
            "".to_string()
        };

        let path_from_src = full_file_path.strip_prefix(&source_dir).unwrap();

        let mut folder_path_from_src = path_from_src.to_path_buf();
        folder_path_from_src.pop();

        let path_to = PathBuf::from(&source_dir).join(&folder_path_from_src);

        File {
            filename,
            extension,
            path_from_source: folder_path_from_src,
            path_to,
            extra_files: Vec::new(),
            info: AudioFileInfo::default(),
        }
    }

    pub fn join_filename(&self) -> String {
        format!("{}.{}", self.filename, self.extension)
    }
    pub fn join_path_to(&self) -> PathBuf {
        PathBuf::from(&self.path_to).join(self.join_filename())
    }
    pub fn join_path_from_source(&self) -> PathBuf {
        PathBuf::from(&self.path_from_source).join(self.join_filename())
    }
}