use rayon::prelude::*;

use std::fs::{DirBuilder, File};

use std::collections::HashSet;
use std::fs::{self, DirBuilder, File};

use rayon::prelude::*;

pub fn download_rss(url: &str) {

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

    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 update_rss(state: &State) {
    println!("Updating RSS feeds...");
    state.subscriptions().par_iter().for_each(|ref sub| {

pub fn update_rss(state: &mut State) {
    println!("Checking for new episodes...");
    state.subs.par_iter_mut().for_each(|mut sub| {

        path.push(".rss");

        path.push(sub.title());

        let mut titles = HashSet::new();
        for entry in fs::read_dir(&path).unwrap() {
            let entry = entry.unwrap();
            titles.insert(trim_extension(&entry.file_name().into_string().unwrap()));
        }

        let channel = Channel::read_from(BufReader::new(&content[..])).unwrap();
        let mut filename = String::from(channel.title());

        let podcast = Podcast::from(Channel::read_from(BufReader::new(&content[..])).unwrap());
        path = get_podcast_dir();
        path.push(".rss");
        let mut filename = String::from(podcast.title());

        path.push(filename);

        path.push(&filename);

        if podcast.episodes().len() > sub.num_episodes {
            &podcast.episodes()[..podcast.episodes().len() - sub.num_episodes]
                .par_iter()
                .for_each(|ref ep| if let Err(err) = ep.download(podcast.title()) {
                    eprintln!("Error downloading {}: {}", podcast.title(), err);
                });
        }
        sub.num_episodes = podcast.episodes().len();

extern crate yaml_rust;

    let config = Config::new();

                &config,

        Some("update") => update_rss(&state),

        Some("update") => update_rss(&mut state),

use yaml_rust::YamlLoader;
pub struct Config {
    pub auto_download_limit: i64,
    pub auto_delete_limit: i64,
}

impl Config {
    pub fn new() -> Config {
        let mut path = get_podcast_dir();
        let mut download_limit = 1;
        let mut delete_limit = 0;
        path.push(".config");
        if path.exists() {
            let mut s = String::new();
            File::open(&path).unwrap().read_to_string(&mut s).unwrap();
            let config = YamlLoader::load_from_str(&s).unwrap();
            if config.len() > 0 {
                let doc = &config[0];
                if let Some(val) = doc["auto_download_limit"].as_i64() {
                    download_limit = val;
                }
                if let Some(val) = doc["auto_delete_limit"].as_i64() {
                    delete_limit = val;
                }
            }
        }
        Config {
            auto_download_limit: download_limit,
            auto_delete_limit: delete_limit,
        }
    }
}

    title: String,
    url: String,

    pub title: String,
    pub url: String,
    pub num_episodes: usize,

    last_run_time: DateTime<Utc>,
    subs: Vec<Subscription>,

    pub last_run_time: DateTime<Utc>,
    pub subs: Vec<Subscription>,

                update_rss(&state.clone());

                update_rss(&mut state);

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

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

        let channel = Channel::from_url(url).unwrap();
        if !set.contains(channel.title()) {

        let podcast = Podcast::from(Channel::from_url(url).unwrap());
        if !set.contains(podcast.title()) {

                title: String::from(channel.title()),

                title: String::from(podcast.title()),

                num_episodes: podcast.episodes().len(),

        download_rss(url);

        download_rss(url, config);

                    _ => None,

                    _ => find_extension(self.url().unwrap()),

                println!("Downloading: {}", title);

                println!("Downloading: {}", path.to_str().unwrap());

use std::collections::BTreeSet;

use std::collections::HashSet;

use std::path::PathBuf;

use std::path::PathBuf;

pub fn already_downloaded(dir: &str) -> BTreeSet<String> {
    let mut result = BTreeSet::new();

pub fn trim_extension(filename: &str) -> String {
    let name = String::from(filename);
    let index = name.rfind('.').unwrap();
    String::from(&name[0..index])
}
pub fn find_extension(input: &str) -> Option<&str> {
    let tmp = String::from(input);
    if tmp.contains(".mp3") {
        Some(".mp3")
    } else if tmp.contains(".m4a") {
        Some(".m4a")
    } else if tmp.contains(".wav") {
        Some(".wav")
    } else if tmp.contains(".ogg") {
        Some(".ogg")
    } else {
        None
    }
}

pub fn already_downloaded(dir: &str) -> HashSet<String> {
    let mut result = HashSet::new();