use futures::TryStreamExt;
use regex::Regex;
use serde::{Deserialize, Serialize};
use url::Url;

use std::ops::RangeBounds;
use std::path::Path;

#[derive(Deserialize, Serialize)]
pub struct Resource {
    pub mime: String,
    pub url: url::Url,
}

#[derive(Deserialize, Serialize)]
pub struct Page {
    pub resources: Vec<Resource>,
    pub id: u32,
}

#[derive(Deserialize)]
pub struct Item {
    pub scans: Vec<Page>,
}

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("{0}")]
    Io(#[from] std::io::Error),
    #[error("{0}")]
    Http(#[from] reqwest::Error),
    #[error("{0}")]
    Serde(#[from] serde_json::Error),
}

#[must_use]
pub fn resource_id_from_url(url: &Url) -> String {
    Regex::new(r"item/([a-zA-Z0-9-]+,)?([a-zA-Z0-9]+)")
        .expect("correct regexp")
        .captures(url.path())
        .unwrap()
        .get(2)
        .unwrap()
        .as_str()
        .to_string()
}

pub async fn list_pages<R>(url: &Url, range: R) -> Result<Vec<Page>, Error>
where
    R: RangeBounds<usize>,
{
    let mut url = url.clone();
    let resource_id = resource_id_from_url(&url);
    let path = format!("/api/entities/{}/", resource_id);
    url.set_path(&path);

    let mut item: Item = reqwest::get(url.as_str()).await?.json().await?;
    for page in &mut item.scans {
        page.resources.retain(|r| r.mime == "image/jpeg");
    }
    Ok(item.scans.drain(range).collect())
}

pub async fn download_page_image(url: &Url, output_path: &Path) -> Result<(), Error> {
    use async_compat::CompatExt;
    use tokio::io::AsyncWriteExt;

    let mut file = tokio::fs::OpenOptions::new()
        .append(true)
        .create_new(true)
        .open(output_path)
        .await?;

    let mut response = reqwest::get(url.as_str())
        .await?
        .bytes_stream()
        .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))
        .into_async_read();

    futures::io::copy(&mut response, &mut file.compat_mut()).await?;

    file.flush().await?;

    Ok(())
}