use std::path::PathBuf;

use crate::{
    device,
    ffmpeg::{Bitrate, BitrateParser, Codec, Quality, SamplingRate, SamplingRateParser},
};
use anyhow::{Result, anyhow};
use clap::Args as ClapArgs;

#[derive(ClapArgs, Debug)]
pub struct Args {
    /// Path where tunz database is stored.
    #[arg(long)]
    pub destination: PathBuf,

    /// Enable or disable transcoding on copy.
    #[arg(long)]
    pub enabled: Option<bool>,

    /// Codec to transcode files to.
    #[arg(long)]
    pub codec: Option<Codec>,

    /// Bitrate to transcode at.
    #[arg(long, value_parser = BitrateParser{})]
    pub bitrate: Option<Bitrate>,

    /// Sample rate to transcode at.
    #[arg(long, value_parser = SamplingRateParser{})]
    pub sampling_rate: Option<SamplingRate>,
}

impl Args {
    pub fn validate(&self) -> Result<()> {
        match self.enabled {
            Some(s) => match s {
                true => {
                    if !(self.bitrate.is_some()
                        && self.codec.is_some()
                        && self.sampling_rate.is_some())
                    {
                        return Err(anyhow!("must specify all transcoding settings"));
                    }

                    Ok(())
                }
                false => Ok(()),
            },
            None => Ok(()),
        }
    }
}

pub async fn run(args: Args) -> Result<()> {
    args.validate()?;

    // transcoding settings are always written in tunz.db, open dest as a disk by default

    let dest = device::Disk::new(args.destination).await?;

    if let Some(enabled) = args.enabled {
        match enabled {
            true => {
                dest.set_transcoding_settings(Some(Quality {
                    bitrate: args.bitrate.unwrap(),
                    sampling_rate: args.sampling_rate,
                    codec: args.codec.unwrap(),
                }))
                .await?
            }
            false => dest.set_transcoding_settings(None).await?,
        }
    }

    Ok(())
}