extern crate reqwest;
extern crate hyper;
extern crate pretty_bytes;
extern crate regex;

use std::fmt;
use std::error::Error;
use regex::Regex;
use hyper::header::{ContentType, ContentLength};
use pretty_bytes::converter::convert;
use reqwest::mime;
use reqwest::mime::Mime;

#[derive(Debug)]
enum ParserError {
    ReqwestFailed(reqwest::Error),
    RegexError(regex::Error),
    WebPageTitleInvalid,
    LengthInvalid,
    TypeInvalid,
    Unknown
}

impl From<reqwest::Error> for ParserError {
    fn from(err: reqwest::Error) -> ParserError { ParserError::ReqwestFailed(err) }
}

impl From<regex::Error> for ParserError {
    fn from(err: regex::Error) -> ParserError { ParserError::RegexError(err) }
}

enum MetaData {
    Webpage { title: String },
    Image { extension: String, resolution: (u64, u64), size: u64 },
    File { extension : String, size: u64 },
}

impl fmt::Display for MetaData {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            MetaData::Webpage => write!(f, "{}", self.title),
            _ => write!(f, "a")
        }
    }
}

fn get_metadata(url: &str) -> Result<MetaData, ParserError> {
    let mut response = reqwest::get(url)?;

    let length = response.headers().get::<ContentLength>()
        .ok_or(ParserError::LengthInvalid)
        .map(|ct_len| **ct_len)?;

    let mime = response.headers().get::<ContentType>()
        .ok_or(ParserError::TypeInvalid)?
        .0.clone();

    let metadata = match mime.type_() {
        mime::IMAGE => Ok(MetaData::Image { extension: mime.subtype().to_string(), resolution: (0, 0), size: length }),
        mime::TEXT => {
            let html_string = response.text()?;
            let re = Regex::new(r"\<title\>(.*)\<\/title\>")?;
            let cap = re.captures(&html_string).ok_or(ParserError::WebPageTitleInvalid)?;

            Ok(MetaData::Webpage { title: cap[0].into() })
        }

        _ => Ok(MetaData::File { extension: mime.subtype().to_string(), size: length })
    };

    metadata
}

fn main() {

}