Update dependencies

[rbdr/lyricli] / src / main.rs

mod configuration;
mod lyrics_engine;
mod sources;

use clap::Parser;
use std::io::{Error, ErrorKind::Other, Result};

use configuration::Configuration;
use lyrics_engine::print_lyrics;
use sources::{disable, enable, get_track, list, reset};

#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Arguments {
    // Positional Arguments
    /// Specify the artist.
    artist: Option<String>,

    /// Specify the artist.
    track_name: Option<String>,

    /// Show title of track if present
    #[arg(short = 't', long)]
    show_title: bool,

    /// Lists all sources
    #[arg(short, long)]
    list_sources: bool,

    /// Enables a source
    #[arg(short, long, value_name = "SOURCE")]
    enable_source: Option<String>,

    #[arg(short, long, value_name = "SOURCE")]
    disable_source: Option<String>,

    #[arg(short, long, value_name = "SOURCE")]
    reset_source: Option<String>,
}

pub struct Track {
    pub name: String,
    pub artist: String,
}

#[tokio::main]
async fn main() -> Result<()> {
    let result = run().await;

    if cfg!(debug_assertions) {
        result
    } else {
        match result {
            Ok(_) => Ok(()),
            Err(e) => {
                eprintln!("Error: {}", e);
                std::process::exit(1);
            }
        }
    }
}

async fn run() -> Result<()> {
    let mut configuration = Configuration::new();
    let arguments = Arguments::parse();

    if arguments.list_sources {
        let sources = list();
        for source in sources {
            print!("{}", source);
            if configuration.is_enabled(&source) {
                print!(" (enabled)");
            }
            println!();
        }
        return Ok(());
    }

    if let Some(source_name) = arguments.enable_source {
        if !configuration.is_enabled(&source_name) {
            enable(&source_name)?;
        }
        return configuration.enable_source(&source_name);
    }

    if let Some(source_name) = arguments.disable_source {
        if configuration.is_enabled(&source_name) {
            disable(&source_name)?;
        }
        return configuration.disable_source(&source_name);
    }

    if let Some(source_name) = arguments.reset_source {
        return reset(&source_name);
    }

    let current_track: Track;
    if let Some(artist) = arguments.artist {
        current_track = Track {
            name: arguments.track_name.unwrap_or("".to_string()),
            artist,
        };
    } else {
        current_track =
            get_track().ok_or_else(|| Error::new(Other, "No Artist/Song could be found :("))?
    }

    print_lyrics(current_track, arguments.show_title).await
}