version = "0.3.1"

version = "0.4.0"

#compdef podcast
#autoload
# Copyright (C) 2017:
#    Nathan Jaremko <njaremko@gmail.com>
# All Rights Reserved.
# This file is licensed under the GPLv2+. Please see COPYING for more information.
_podcast() {
    local ret=1
    _arguments -C \
        '1: :_podcast_cmds' \
        && ret=0
}
_podcast_cmds () {
    local subcommands;
    subcommands=(
    "download:Download episodes of podcast"
    "help:Prints this message or the help of the given subcommand(s)"
    "ls:List podcasts or episodes of a podcast"
    "play:Play episodes of a podcast"
    "refresh:Refreshes subscribed podcasts"
    "rm:Delete podcast"
    "search:Searches for podcasts"
    "subscribe:Subscribe to a podcast RSS feed"
    "update:check for updates"
    )
    _describe -t commands 'podcast' subcommands
    _arguments : \
        "--version[Output version information]" \
        "--help[Output help message]"
}
_podcast

    let re = Regex::new(search).unwrap();

    let re = Regex::new(&format!("(?i){}", &search)).expect("Failed to parse regex");

    &state.subs.par_iter_mut().for_each(|mut sub| {

    &state.subs.par_iter_mut().for_each(|sub| {

                .for_each(|ref ep| if let Err(err) = ep.download(podcast.title()) {
                    eprintln!("Error downloading {}: {}", podcast.title(), err);

                .for_each(|ref ep| {
                    if let Err(err) = ep.download(podcast.title()) {
                        eprintln!("Error downloading {}: {}", podcast.title(), err);
                    }

    let re_pod = Regex::new(p_search).unwrap();

    let re_pod = Regex::new(&format!("(?i){}", &p_search)).expect("Failed to parse regex");;

                Ok(podcast) => {
                    match parse_download_episodes(e_search) {
                        Ok(episodes_to_download) => {
                            if let Err(err) = podcast.download_specific(episodes_to_download) {
                                eprintln!("Error: {}", err);
                            }

                Ok(podcast) => match parse_download_episodes(e_search) {
                    Ok(episodes_to_download) => {
                        if let Err(err) = podcast.download_specific(episodes_to_download) {
                            eprintln!("Error: {}", err);

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

                }

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

    let re_pod = Regex::new(p_search).unwrap();

    let re_pod = Regex::new(&format!("(?i){}", &p_search)).expect("Failed to parse regex");

                Ok(podcast) => {
                    if let Err(err) = podcast.download() {
                        eprintln!("{}", err);
                    }
                }

                Ok(podcast) => if let Err(err) = podcast.download() {
                    eprintln!("{}", err);
                },

    let re_pod = Regex::new(p_search).unwrap();

    let re_pod = Regex::new(&format!("(?i){}", &p_search)).expect("Failed to parse regex");

pub fn check_for_update(state: &mut State) {
    println!("Checking for updates...");
}

extern crate serde;

use clap::{Arg, App, SubCommand};

use clap::{App, Arg, SubCommand};

        .version("1.0")

        .version("0.4")

        .about("Does awesome things")

        .about("A command line podcast manager")

            SubCommand::with_name("list")

            SubCommand::with_name("ls")

                .arg(Arg::with_name("debug").short("d").help(
                    "print debug information verbosely",
                )),

                .arg(
                    Arg::with_name("debug")
                        .short("d")
                        .help("print debug information verbosely"),
                ),

        .subcommand(SubCommand::with_name("update").about(
            "update subscribed podcasts",
        ))

        .subcommand(SubCommand::with_name("refresh").about("refresh subscribed podcasts"))
        .subcommand(SubCommand::with_name("update").about("check for updates"))
        .subcommand(SubCommand::with_name("rm").about("delete podcast"))
        .subcommand(SubCommand::with_name("completions").about("install shell completions"))

                Some(ep) => {
                    if String::from(ep).contains(|c| c == '-' || c == ',') {
                        download_range(&state, podcast, ep)
                    } else {
                        download_episode(&state, podcast, ep)
                    }
                }

                Some(ep) => if String::from(ep).contains(|c| c == '-' || c == ',') {
                    download_range(&state, podcast, ep)
                } else {
                    download_episode(&state, podcast, ep)
                },

        Some("list") => {
            let list_matches = matches.subcommand_matches("list").unwrap();

        Some("ls") => {
            let list_matches = matches.subcommand_matches("ls").unwrap();

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

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

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

        Some("rm") => (),
        Some("completions") => (),
        Some("refresh") => update_rss(&mut state),
        Some("update") => check_for_update(&mut state),

            Ok(file) => {
                match Channel::read_from(BufReader::new(file)) {
                    Ok(podcast) => return Ok(Podcast::from(podcast)),
                    Err(err) => return Err(format!("Error: {}", err)),
                }
            }

            Ok(file) => match Channel::read_from(BufReader::new(file)) {
                Ok(podcast) => return Ok(Podcast::from(podcast)),
                Err(err) => return Err(format!("Error: {}", err)),
            },

        self.episodes().par_iter().for_each(
            |ref i| if let Some(ep_title) =
                i.title()
            {

        self.episodes().par_iter().for_each(|ref i| {
            if let Some(ep_title) = i.title() {

            },
        );

            }
        });

        episode_numbers.par_iter().for_each(
            |ep_num| if let Some(ep_title) =
                episodes[episodes.len() - ep_num].title()
            {

        episode_numbers.par_iter().for_each(|ep_num| {
            if let Some(ep_title) = episodes[episodes.len() - ep_num].title() {

            },
        );

            }
        });

            Some(enclosure) => {
                match enclosure.mime_type() {
                    "audio/mpeg" => Some(".mp3"),
                    "audio/mp4" => Some(".m4a"),
                    "audio/ogg" => Some(".ogg"),
                    _ => find_extension(self.url().unwrap()),
                }
            }

            Some(enclosure) => match enclosure.mime_type() {
                "audio/mpeg" => Some(".mp3"),
                "audio/mp4" => Some(".m4a"),
                "audio/ogg" => Some(".ogg"),
                _ => find_extension(self.url().unwrap()),
            },