use std::{
    error::Error,
    ffi::OsStr,
    fmt,
    fs::File,
    io::Read,
    path::{Path, PathBuf},
};

use flate2::read::GzDecoder;
use reqwest::{Client, Response, Url};
use thiserror::Error;

pub use flate2;
pub use reqwest;

pub struct Fetcher {
    pub client: Client,
}
impl Default for Fetcher {
    fn default() -> Self {
        Self {
            client: Client::new(),
        }
    }
}
impl Fetcher {
    pub fn new() -> Self {
        Self::default()
    }
    pub fn open<F: Fetchable>(&mut self, resource: F) -> Result<F::Reader, F::Error> {
        resource.reader_for(self)
    }
}

pub trait Fetchable {
    type Reader: Read;
    type Error: Error;

    fn reader_for(self, f: &mut Fetcher) -> Result<Self::Reader, Self::Error>;
}

impl Fetchable for &str {
    type Reader = Box<dyn Read>;
    type Error = UrlFetchError;

    fn reader_for(self, f: &mut Fetcher) -> Result<Self::Reader, Self::Error> {
        match Url::parse(self) {
            Ok(path) => path.reader_for(f),
            Err(_) => Path::new(self).reader_for(f).map_err(UrlFetchError::from),
        }
    }
}

#[derive(Error, Debug)]
pub enum UrlFetchError {
    #[error("io error: {0}")]
    IoError(#[from] std::io::Error),
    #[error("reqwest error: {0}")]
    ReqwestError(#[from] reqwest::Error),
}
impl Fetchable for Url {
    type Reader = Box<dyn Read>;
    type Error = UrlFetchError;

    fn reader_for(self, f: &mut Fetcher) -> Result<Self::Reader, Self::Error> {
        match self.to_file_path() {
            Ok(path) => path.reader_for(f).map_err(UrlFetchError::from),
            Err(()) => f
                .client
                .get(self)
                .send()?
                .reader_for(f)
                .map_err(UrlFetchError::from),
        }
    }
}

impl Fetchable for Response {
    type Reader = Box<dyn Read>;
    type Error = reqwest::Error;

    fn reader_for(self, _f: &mut Fetcher) -> Result<Self::Reader, Self::Error> {
        if self
            .headers()
            .get(reqwest::header::CONTENT_TYPE)
            .map(|v| v == "application/x-gzip")
            .unwrap_or(false)
            || self
                .headers()
                .get(reqwest::header::CONTENT_DISPOSITION)
                .and_then(|v| v.to_str().ok().map(|s| s.contains(".gz")))
                .unwrap_or(false)
        {
            Ok(Box::new(GzDecoder::new(self)))
        } else {
            Ok(Box::new(self))
        }
    }
}

impl Fetchable for &Path {
    type Reader = Box<dyn Read>;
    type Error = std::io::Error;

    fn reader_for(self, _f: &mut Fetcher) -> Result<Self::Reader, Self::Error> {
        let file = File::open(self)?;

        if self.extension().map(|ext| ext == "gz").unwrap_or(false) {
            Ok(Box::new(GzDecoder::new(file)))
        } else {
            Ok(Box::new(file))
        }
    }
}
impl Fetchable for PathBuf {
    type Reader = Box<dyn Read>;
    type Error = std::io::Error;

    fn reader_for(self, f: &mut Fetcher) -> Result<Self::Reader, Self::Error> {
        (&*self).reader_for(f)
    }
}

#[derive(Error, Debug)]
pub enum UrlJoinError {
    #[error("url parse error: {0}")]
    ParseError(#[from] url::ParseError),
    #[error("invalid utf-8 in url")]
    Utf8Error,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Resource {
    Url(Url),
    PathBuf(PathBuf),
}
impl Fetchable for Resource {
    type Reader = Box<dyn Read>;
    type Error = UrlFetchError;

    fn reader_for(self, f: &mut Fetcher) -> Result<Self::Reader, Self::Error> {
        match self {
            Self::Url(url) => url.reader_for(f),
            Self::PathBuf(path) => path.reader_for(f).map_err(UrlFetchError::from),
        }
    }
}
impl Resource {
    pub fn join<S: AsRef<OsStr>>(mut self, resource: S) -> Result<Self, UrlJoinError> {
        match self {
            Self::Url(url) => url
                .join(resource.as_ref().to_str().ok_or(UrlJoinError::Utf8Error)?)
                .map(Self::Url)
                .map_err(UrlJoinError::from),
            Self::PathBuf(ref mut path) => {
                path.set_file_name(resource.as_ref());
                Ok(self)
            },
        }
    }
}
impl From<PathBuf> for Resource {
    fn from(path: PathBuf) -> Self {
        Self::PathBuf(path)
    }
}
impl From<Url> for Resource {
    fn from(url: Url) -> Self {
        Self::Url(url)
    }
}
impl From<String> for Resource {
    fn from(s: String) -> Self {
        match Url::parse(&s) {
            Ok(path) => Self::Url(path),
            Err(_) => Self::PathBuf(PathBuf::from(s)),
        }
    }
}
impl From<&str> for Resource {
    fn from(s: &str) -> Self {
        match Url::parse(s) {
            Ok(path) => Self::Url(path),
            Err(_) => Self::PathBuf(PathBuf::from(s)),
        }
    }
}
impl AsRef<OsStr> for Resource {
    fn as_ref(&self) -> &OsStr {
        match self {
            Self::Url(url) => OsStr::new(url.as_str()),
            Self::PathBuf(path) => OsStr::new(path),
        }
    }
}
impl fmt::Display for Resource {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::Url(url) => url.fmt(f),
            Self::PathBuf(path) => path.display().fmt(f),
        }
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for Resource {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Url(url) => serializer.serialize_str(url.as_str()),
            Self::PathBuf(path) => path.serialize(serializer),
        }
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Resource {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        <&str>::deserialize(deserializer).map(Self::from)
    }
}