# podcast
 ---
 `podcast` is a command line podcast player.
 
 It currently supports:
- [x] Subscribing to RSS feeds
- [x] Streaming podcasts
- [x] Playing podcasts
- [ ] Shell Completions
    - [x] zsh
    - [ ] bash
    - [ ] sh
- [ ] Searching for podcasts...(WIP)
By default, podcasts are downloaded to $HOME/Podcasts, but this folder can be set with the $PODCASTS environmental variable.
Individually: `podcast download $podcast_name 4`
Multiple: `podcast download $podcast_name 1,5,9-12,14`
All: `podcast download $podcast_name`
How many latest episodes to download when subscibing to new podcasts can be set in the $PODCASTS/.config YAML file
Downloads can be done a variety of ways:
- [x] Auto-download new episodes
- [x] Automatically check for updates
- [ ] Auto-delete old episodes
- [x] Parallel downloading of multiple podcasts 
- [x] Unsubscribing from RSS feeds
 
 NOTE: Playback requires either mpv or vlc to be installed

pub fn download_rss(url: &str, config: &Config) {

pub fn subscribe_rss(url: &str) {

    let mut path = get_podcast_dir();
    path.push(".rss");
    DirBuilder::new().recursive(true).create(&path).unwrap();
    let mut resp = reqwest::get(url).unwrap();
    let mut content: Vec<u8> = Vec::new();
    resp.read_to_end(&mut content).unwrap();
    let channel = Channel::read_from(BufReader::new(&content[..])).unwrap();
    let mut filename = String::from(channel.title());
    filename.push_str(".xml");
    path.push(filename);
    let mut file = File::create(&path).unwrap();
    file.write_all(&content).unwrap();

    if let Err(err) = download_rss_feed(url) {
        eprintln!("Error: {}", err);
    }
}

    let download_limit = config.auto_download_limit as usize;
    if download_limit > 0 {
        let podcast = Podcast::from(channel);
        let episodes = podcast.episodes();
        &episodes[..download_limit].par_iter().for_each(|ref ep| {
            if let Err(err) = ep.download(podcast.title()) {
                eprintln!("Error downloading {}: {}", podcast.title(), err);

pub fn download_rss(config: &Config, url: &str) {
    println!("Downloading episode(s)...");
    match download_rss_feed(url) {
        Ok(channel) => {
            let download_limit = config.auto_download_limit as usize;
            if download_limit > 0 {
                let podcast = Podcast::from(channel);
                let episodes = podcast.episodes();
                &episodes[..download_limit].par_iter().for_each(|ref ep| {
                    if let Err(err) = ep.download(podcast.title()) {
                        eprintln!("Error downloading {}: {}", podcast.title(), err);
                    }
                });

        });

        }
        Err(err) => eprintln!("Error: {}", err),

                )
                .arg(
                    Arg::with_name("download")
                        .short("d")
                        .long("download")
                        .help("auto download based on config"),

        Some("subscribe") => state.subscribe(
            matches
                .subcommand_matches("subscribe")
                .unwrap()
                .value_of("URL")
                .unwrap(),
            &config,
        ),

        Some("subscribe") => {
            let subscribe_matches = matches.subcommand_matches("subscribe").unwrap();
            let url = subscribe_matches.value_of("URL").unwrap();
            state.subscribe(url);
            if subscribe_matches.occurrences_of("download") > 0 {
                download_rss(&config, url);
            } else {
                subscribe_rss(url);
            }
        }

    pub fn subscribe(&mut self, url: &str, config: &Config) {

    pub fn subscribe(&mut self, url: &str) {

        download_rss(url, config);

use std::fs::{self, DirBuilder};
use std::io;

use std::fs::{self, DirBuilder, File};
use std::io::{self, BufReader, Read, Write};

use reqwest;
use rss::Channel;

pub fn download_rss_feed(url: &str) -> Result<Channel, String> {
    let mut path = get_podcast_dir();
    path.push(".rss");
    DirBuilder::new().recursive(true).create(&path).unwrap();
    let mut resp = reqwest::get(url).unwrap();
    let mut content: Vec<u8> = Vec::new();
    resp.read_to_end(&mut content).unwrap();
    let channel = Channel::read_from(BufReader::new(&content[..])).unwrap();
    let mut filename = String::from(channel.title());
    filename.push_str(".xml");
    path.push(filename);
    let mut file = File::create(&path).unwrap();
    file.write_all(&content).unwrap();
    Ok(channel)
}