[package]
name = "yaydl"
description = "yet another youtube (and more) down loader"
version = "0.2.5"
authors = ["Cthulhux <git@tuxproject.de>"]
edition = "2018"
license = "CDDL-1.0"
repository = "https://code.rosaelefanten.org/yaydl"
categories = ["command-line-utilities"]
keywords = ["youtube", "vimeo"]

[dependencies]
anyhow = "1.0"
clap = "3.0.0-beta.2"
indicatif = "0.15.0"
inventory = "0.1.9"
qstring = "0.7.2"
regex = "1.4.1"
reqwest = { version = "0.10.8", features = ["blocking"] }
serde_json = "1.0"


urlencoding = "1.1.1"

[profile.release]
lto = true

static mut VIDEO_TITLE: String = String::new();

unsafe fn get_video_info(url: &str) -> Result<Value> {
    if VIDEO_INFO.is_empty() {
        // We need to fetch the video information first.
        // Those are hidden behing a config file defined in the page source code.
        // Search for: window.vimeo.clip_page_config.player = {"config_url":"(.+?)"

        let body = reqwest::blocking::get(url)?.text()?;
        let re =
            Regex::new("window.vimeo.clip_page_config.player = .\"config_url\":\"(?P<URL>.+?)\"")
                .unwrap();
        let search = re.captures(&body).unwrap();

        // While we're grepping the source code: Vimeo also hides
        // the video title here.

        let video_info_url = search
            .name("URL")
            .map_or("", |u| u.as_str())
            .replace("\\", "");

        // The "config_url" body is a JSON structure.
        // Grab and store it:
        let config_body = reqwest::blocking::get(&video_info_url)?.text()?;

        VIDEO_INFO = config_body;
    }

    // Return it:
    let v: Value = serde_json::from_str(&VIDEO_INFO)?;
    Ok(v)
}

unsafe fn get_video_info(id: &str) -> Result<Value> {
    if VIDEO_INFO.is_empty() {
        // We need to fetch the video information first.
        let video_url = format!(
            "https://www.youtube.com/get_video_info?video_id={}&el=embedded&ps=default",
            id
        );
        let res = reqwest::blocking::get(video_url.as_str())?;
        let body = res.text()?;

        // Try to find the encoded JSON object in the response.
        let qs = QString::from(body.as_str());
        let json = qs.get("player_response").unwrap_or("");

        VIDEO_INFO = json.replace("+", " ");
    }

// Yet Another Youtube Down Loader
// - main.rs file -

use anyhow::Result;
use clap::{App, Arg};
use indicatif::{ProgressBar, ProgressStyle};
use reqwest::{blocking::Client, header, Url};
use std::{
    fs,
    io::{self, copy, Read},
    path::{Path, PathBuf},
};


mod definitions;
mod ffmpeg;
mod handlers;

struct DownloadProgress<R> {
    inner: R,

            n
        })
    }
}

fn download(url: &str, filename: &str) -> Result<()> {
    let url = Url::parse(url)?;
    let client = Client::new();

    // Find the video size:
    let total_size = {
        let resp = client.head(url.as_str()).send()?;
        if resp.status().is_success() {
            resp.headers()
                .get(header::CONTENT_LENGTH)
                .and_then(|ct_len| ct_len.to_str().ok())
                .and_then(|ct_len| ct_len.parse().ok())
                .unwrap_or(0)

        } else {
            return Err(anyhow::Error::msg(format!(
                "Couldn't download URL: {}. Error: {:?}",
                url,
                resp.status(),
            )));
        }
    };

    let mut request = client.get(url.as_str());

    // Display a progress bar:
    let pb = ProgressBar::new(total_size);
    pb.set_style(ProgressStyle::default_bar()
                 .template("{spinner:.green} [{elapsed_precise}] [{bar:40.green/blue}] {bytes}/{total_bytes} ({eta})")
                 .progress_chars("#>-"));

    let file = Path::new(filename);

    if file.exists() {
        // Continue the file:
        let size = file.metadata()?.len() - 1;

        request = request.header(header::RANGE, format!("bytes={}-", size));
        pb.inc(size);
    }


    let mut source = DownloadProgress {
        progress_bar: pb,
        inner: request.send()?,
    };

    let mut dest = fs::OpenOptions::new()
        .create(true)
        .append(true)
        .open(&file)?;