version = "0.12.1"

version = "0.13.0"

lazy_static = "1.3"
rayon = "1.1"
regex = "1.2"
reqwest = "0.9"

lazy_static = "1.4"
futures = "0.3.1"
rayon = "1.3"
regex = "1.3"
reqwest = { version = "0.10", features = ["default-tls", "json"] }

semver-parser = "0.9.0"

semver-parser = "0.9.0"
tokio = { version = "0.2", features = ["full"]}

use rayon::prelude::*;

pub fn update_subscription(sub: &mut Subscription) -> Result<()> {

pub async fn update_subscription(sub: &mut Subscription, config: Option<Config>) -> Result<()> {

    let resp = reqwest::get(&sub.url)?;
    let podcast = Podcast::from(Channel::read_from(BufReader::new(resp))?);

    let resp = reqwest::get(&sub.url).await?.bytes().await?;
    let podcast = Podcast::from(Channel::read_from(BufReader::new(&resp[..]))?);

        podcast.episodes()[..podcast.episodes().len() - sub.num_episodes]
            .par_iter()
            .map(|ep| download::download(podcast.title(), ep))
            .flat_map(std::result::Result::err)
            .for_each(|err| eprintln!("Error: {}", err));

        let mut d_vec = vec![];
        let subscription_limit = config.unwrap_or_else(|| Config::default()).download_subscription_limit.unwrap_or(-1);
        let mut episodes = podcast.episodes()[..podcast.episodes().len() - sub.num_episodes].to_vec();
        episodes.reverse();
        if 0 < subscription_limit {
            for ep in episodes.iter().take(subscription_limit as usize) {
                d_vec.push(download::download(podcast.title().into(), ep.clone()));
            }
        } else {
            for ep in episodes.iter() {
                d_vec.push(download::download(podcast.title().into(), ep.clone()));
            }
        }
        for c in futures::future::join_all(d_vec).await.iter() {
            if let Err(err) = c {
                println!("Error: {}", err);
            }
        }

pub fn update_rss(state: &mut State) {

pub async fn update_rss(state: &mut State, config: Option<Config>) -> Result<()> {

    let _result: Vec<Result<()>> = state
        .subscriptions_mut()
        .par_iter_mut()
        .map(|sub: &mut Subscription| update_subscription(sub))
        .collect();

    let mut d_vec = vec![];
    for sub in state.subscriptions_mut() {
        d_vec.push(update_subscription(sub, config));
    }
    for c in futures::future::join_all(d_vec).await.iter() {
        if let Err(err) = c {
            println!("Error: {}", err);
        }
    }

    Ok(())

pub fn check_for_update(version: &str) -> Result<()> {

pub async fn check_for_update(version: &str) -> Result<()> {

        reqwest::get("https://raw.githubusercontent.com/njaremko/podcast/master/Cargo.toml")?
            .text()?;

        reqwest::get("https://raw.githubusercontent.com/njaremko/podcast/master/Cargo.toml")
            .await?
            .text()
            .await?;

pub fn download(state: &mut State, matches: &ArgMatches) -> Result<()> {

pub async fn download(state: &mut State, matches: &ArgMatches<'_>) -> Result<()> {

                download::download_range(&state, podcast, ep)?

                download::download_range(&state, podcast, ep).await?

                )?

                )
                .await?

                download::download_episode_by_num(&state, podcast, ep)?

                download::download_episode_by_num(&state, podcast, ep).await?

        None => download::download_all(&state, podcast)?,

        None => download::download_all(&state, podcast).await?,

pub fn subscribe(state: &mut State, config: Config, matches: &ArgMatches) -> Result<()> {

pub async fn subscribe(state: &mut State, config: Config, matches: &ArgMatches<'_>) -> Result<()> {

    sub(state, config, url)?;

    sub(state, config, url).await?;

fn sub(state: &mut State, config: Config, url: &str) -> Result<()> {
    state.subscribe(url)?;
    download::download_rss(config, url)?;

async fn sub(state: &mut State, config: Config, url: &str) -> Result<()> {
    state.subscribe(url).await?;
    download::download_rss(config, url).await?;

pub fn search(state: &mut State, config: Config, matches: &ArgMatches) -> Result<()> {

pub async fn search(state: &mut State, config: Config, matches: &ArgMatches<'_>) -> Result<()> {

    let resp = search::search_for_podcast(podcast)?;

    let resp = search::search_for_podcast(podcast).await?;

    let rss_resp = search::retrieve_rss(&resp.found()[n])?;

    let rss_resp = search::retrieve_rss(&resp.found()[n]).await?;

        Some(r) => sub(state, config, r)?,

        Some(r) => sub(state, config, r).await?,

pub fn handle_matches(

pub async fn handle_matches(

    app: &mut App,
    matches: &ArgMatches,

    app: &mut App<'_, '_>,
    matches: &ArgMatches<'_>,

            arg_parser::download(state, matches)?;

            arg_parser::download(state, matches).await?;

            arg_parser::subscribe(state, config, matches)?;

            arg_parser::subscribe(state, config, matches).await?;

            arg_parser::search(state, config, matches)?;

            arg_parser::search(state, config, matches).await?;

            update_rss(state);

            update_rss(state, Some(config)).await?;

            check_for_update(version)?;

            check_for_update(version).await?;

use rayon::prelude::*;

pub fn download_range(state: &State, p_search: &str, e_search: &str) -> Result<(), Error> {

pub async fn download_range(state: &State, p_search: &str, e_search: &str) -> Result<(), Error> {

    let mut d_vec = vec![];

            episodes_to_download
                .par_iter()
                .map(|ep_num| &episodes[episodes.len() - ep_num])
                .map(|ep| download(podcast.title(), ep))
                .flat_map(std::result::Result::err)
                .for_each(|err| println!("Error: {}", err));

            for ep_num in episodes_to_download {
                let d = download(podcast.title().into(), episodes[episodes.len() - ep_num].clone());
                d_vec.push(d);
            } 
        }
    }
    for c in futures::future::join_all(d_vec).await.iter() {
        if let Err(err) = c {
            println!("Error: {}", err);

pub fn download_episode_by_num(state: &State, p_search: &str, e_search: &str) -> Result<(), Error> {

pub async fn download_episode_by_num(
    state: &State,
    p_search: &str,
    e_search: &str,
) -> Result<(), Error> {

        let mut d_vec = vec![];

                download(podcast.title(), &episodes[episodes.len() - ep_num])?;

                d_vec.push(download(podcast.title().into(), episodes[episodes.len() - ep_num].clone()));
            }
        }
        for c in futures::future::join_all(d_vec).await.iter() {
            if let Err(err) = c {
                println!("Error: {}", err);

        download_episode_by_name(state, p_search, e_search, false)?;

        download_episode_by_name(state, p_search, e_search, false).await?;

pub fn download(podcast_name: &str, episode: &Episode) -> Result<(), Error> {

pub async fn download(podcast_name: String, episode: Episode) -> Result<(), Error> {

            let resp = reqwest::get(url)?;

            let resp = reqwest::get(url).await?.bytes().await?;

            let mut reader = BufReader::new(resp);

            let mut reader = BufReader::new(&resp[..]);

pub fn download_episode_by_name(

pub async fn download_episode_by_name(

    let mut d_vec = vec![];

                filtered_episodes
                    .map(|ep| download(podcast.title(), ep))
                    .flat_map(std::result::Result::err)
                    .for_each(|err| eprintln!("Error: {}", err));

                for ep in filtered_episodes {
                    let d = download(podcast.title().into(), ep.clone());
                    d_vec.push(d);
                }

                filtered_episodes
                    .take(1)
                    .map(|ep| download(podcast.title(), ep))
                    .flat_map(std::result::Result::err)
                    .for_each(|err| eprintln!("Error: {}", err));

                for ep in filtered_episodes.take(1) {
                    let d = download(podcast.title().into(), ep.clone());
                    d_vec.push(d);
                }

        }  
    }
    for c in futures::future::join_all(d_vec).await.iter() {
        if let Err(err) = c {
            println!("Error: {}", err);

pub fn download_all(state: &State, p_search: &str) -> Result<(), Error> {

pub async fn download_all(state: &State, p_search: &str) -> Result<(), Error> {

    let mut d_vec = vec![];

            utils::already_downloaded(podcast.title()).map(|downloaded| {
                podcast
                    .episodes()
                    .par_iter()

            for downloaded in utils::already_downloaded(podcast.title()) {
                let episodes = podcast.episodes();
                for e in episodes
                    .iter()

                    .map(|e| download(podcast.title(), e))
                    .flat_map(std::result::Result::err)
                    .for_each(|err| eprintln!("Error: {}", err))
            })?;

                    .cloned()
                {
                    let d = download(podcast.title().into(), e);
                    d_vec.push(d);
                }
            }
        }
    }
    for c in futures::future::join_all(d_vec).await.iter() {
        if let Err(err) = c {
            println!("Error: {}", err);

pub fn download_rss(config: Config, url: &str) -> Result<(), Error> {
    let channel = utils::download_rss_feed(url)?;
    let mut download_limit = config.auto_download_limit as usize;

pub async fn download_rss(config: Config, url: &str) -> Result<(), Error> {
    let channel = utils::download_rss_feed(url).await?;
    let mut download_limit = config.auto_download_limit.unwrap_or(1) as usize;

        episodes[..download_limit]
            .par_iter()
            .map(|ep| download(podcast.title(), ep))
            .flat_map(std::result::Result::err)
            .for_each(|err| eprintln!("Error downloading {}: {}", podcast.title(), err));

        let mut d_vec = vec![];
        for ep in episodes[..download_limit].iter() {
            d_vec.push(download(podcast.title().into(), ep.clone()));
        }
        for c in futures::future::join_all(d_vec).await.iter() {
            if let Err(err) = c {
                eprintln!("Error downloading {}: {}", podcast.title(), err)
            }
        }

const VERSION: &str = "0.12.1";

const VERSION: &str = "0.13.0";

fn main() -> Result<()> {

#[tokio::main]
async fn main() -> Result<()> {

    let mut state = State::new(VERSION)?;

    let mut state = State::new(VERSION).await?;

    command_handler::handle_matches(&VERSION, &mut state, config, &mut app, &matches)?;

    command_handler::handle_matches(&VERSION, &mut state, config, &mut app, &matches).await?;

use serde_json;

pub fn search_for_podcast(podcast: &str) -> Result<Response, Error> {

pub async fn search_for_podcast(podcast: &str) -> Result<Response, Error> {

    let resp = reqwest::get(&url)?;
    let r: Response = serde_json::from_reader(resp)?;

    let r = reqwest::get(&url).await?.json::<Response>().await?;

pub fn search_for_episode(podcast: &str, ep: &str) -> Result<Response, Error> {

pub async fn search_for_episode(podcast: &str, ep: &str) -> Result<Response, Error> {

    let resp = reqwest::get(&url)?;
    let r: Response = serde_json::from_reader(resp)?;

    let r = reqwest::get(&url).await?.json::<Response>().await?;

pub fn retrieve_rss(podcast: &str) -> Result<RssResponse, Error> {

pub async fn retrieve_rss(podcast: &str) -> Result<RssResponse, Error> {

    let resp = reqwest::get(&url)?;
    let r: RssResponse = serde_json::from_reader(resp)?;

    let r = reqwest::get(&url).await?.json::<RssResponse>().await?;

use crate::errors::*;

fn create_new_config_file(path: &PathBuf) -> Result<Config> {

fn create_new_config_file(path: &PathBuf) -> Result<Config, Box<dyn std::error::Error>> {

    let download_limit = 1;

        auto_download_limit: download_limit,

        auto_download_limit: Some(1),
        download_subscription_limit: Some(1),

#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]

#[derive(Copy, Clone, Debug, Default, PartialEq, Serialize, Deserialize)]

    pub auto_download_limit: i64,

    pub auto_download_limit: Option<i64>,
    pub download_subscription_limit: Option<i64>,

    pub fn new() -> Result<Config> {

    pub fn new() -> Result<Config, Box<dyn std::error::Error>> {

    pub fn new(version: &str) -> Result<State> {

    pub async fn new(version: &str) -> Result<State, Box<dyn std::error::Error>> {

                update_rss(&mut state);
                check_for_update(&state.version)?;

                let config = Config::new()?;
                update_rss(&mut state, Some(config)).await?;
                check_for_update(&state.version).await?;

    pub fn subscribe(&mut self, url: &str) -> Result<()> {

    pub async fn subscribe(&mut self, url: &str) -> Result<(), Box<dyn std::error::Error>> {

        let podcast = Podcast::from(Channel::from_url(url)?);

        let resp = reqwest::get(url).await?.bytes().await?;
        let channel = Channel::read_from(BufReader::new(&resp[..]))?;
        let podcast = Podcast::from(channel);

    pub fn save(&self) -> Result<()> {

    pub fn save(&self) -> Result<(), Box<dyn std::error::Error>> {

    pub fn from_url(url: &str) -> Result<Podcast> {

    pub fn from_url(url: &str) -> Result<Podcast, Box<dyn std::error::Error>> {

    pub fn from_title(title: &str) -> Result<Podcast> {

    pub fn from_title(title: &str) -> Result<Podcast, Box<dyn std::error::Error>> {

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

use std::io::{self, BufReader, Write};

pub fn download_rss_feed(url: &str) -> Result<Channel> {

pub async fn download_rss_feed(url: &str) -> Result<Channel> {

    let mut resp = reqwest::get(url)?;
    let mut content: Vec<u8> = Vec::new();
    resp.read_to_end(&mut content)?;
    let channel = Channel::read_from(BufReader::new(&content[..]))?;

    let resp = reqwest::get(url).await?.bytes().await?;
    let channel = Channel::read_from(BufReader::new(&resp[..]))?;

    file.write_all(&content)?;

    file.write_all(&resp)?;