extern crate multipart;
extern crate iron;
extern crate time;
//image converter
extern crate image;
extern crate crypto;
extern crate rustc_serialize;
use rustc_serialize::json;

use crypto::md5::Md5;
use crypto::digest::Digest;

use std::fs::File;
use std::io::Read;
use std::path::Path;
use multipart::server::{Multipart, Entries, SaveResult};

use iron::prelude::*;
use iron::status;
use iron::mime::Mime;

extern crate router;
use router::Router;

const INDEX_HTML: &'static [u8] = include_bytes!("../index.html");

#[derive(Debug, RustcDecodable, RustcEncodable)]
struct JsonResult  {
    ret: bool,
    data: String,
}

fn main() {
    let mut router = Router::new();

    router.get("/", | _: &mut Request| {
        let content_type = "text/html".parse::<Mime>().unwrap();
        Ok(Response::with((content_type, status::Ok, INDEX_HTML)))
    });
    router.post("upload", process_upload);
    //04fd905e6e449e50f9bf5095960bdb54
    router.get("/:md5", process_query);

    router.get("error", |_: &mut Request| {
      Ok(Response::with(status::BadRequest))
    });

    Iron::new(router).http("0.0.0.0:8080").unwrap();

    // Iron::new(process_upload).http("localhost:8080").expect("Could not bind localhost:8080");
}
///process query
fn process_query(request: &mut Request) -> IronResult<Response> {
   let ref md5 = request.extensions.get::<Router>().unwrap().find("md5").unwrap_or("/");
   let content_type = "image/jpeg".parse::<Mime>().unwrap();
   let img = match image::open(format!("{}.jpg",md5)) {
       Ok(img) => img,
       Err(e) => return Err(IronError::new(e, status::InternalServerError))
   };

   // let thumb = img.resize(128, 128, image::FilterType::Triangle);
   let mut buffer = vec![];

   match img.save(&mut buffer, image::JPEG) {
       Ok(_) => Ok(Response::with((content_type,iron::status::Ok, buffer))),
       Err(e) => Err(IronError::new(e, status::InternalServerError))
   }
}

/// Processes a request and returns response or an occured error.
fn process_upload(request: &mut Request) -> IronResult<Response> {
    // Getting a multipart reader wrapper
    match Multipart::from_request(request) {
        Ok(mut multipart) => {
            // Fetching all data and processing it.
            // save_all() reads the request fully, parsing all fields and saving all files
            // in a new temporary directory under the OS temporary directory.
            match multipart.save_all() {
                SaveResult::Full(entries) => process_entries(entries),
                SaveResult::Partial(entries, error) => {
                    try!(process_entries(entries));
                    Err(IronError::new(error, status::InternalServerError))
                }
                SaveResult::Error(error) => Err(IronError::new(error, status::InternalServerError)),
            }
        }
        Err(_) => {
            Ok(Response::with((status::BadRequest, "The request is not multipart")))
        }
    }
}

/// Processes saved entries from multipart request.
/// Returns an OK response or an error.
fn process_entries(entries: Entries) -> IronResult<Response> {
    let mut md5s = String::new();
    for (name, field) in entries.fields {
        println!(r#"Field "{}": "{}""#, name, field);
    }

    for (name, savedfile) in entries.files {
        let filename = match savedfile.filename {
            Some(s) => s,
            None => "None".into(),
        };
        let file_start = time::now();
        let mut file = match File::open(savedfile.path) {
            Ok(file) => file,
            Err(error) => {
                return Err(IronError::new(error,
                                          (status::InternalServerError,
                                           "Server couldn't save file")))
            }
        };
        let file_end = time::now();//
        println!("file load!start : {},end :{},duration:{}",file_start.rfc3339(),file_end.rfc3339(),file_end-file_start);
        //caculate md5
        let mut buffer = Vec::new();
        // read the whole file
        file.read_to_end(&mut buffer).unwrap();
        let mut hasher = Md5::new();
        hasher.input(&buffer);
        let md5 = hasher.result_str();
        // println!("{}", md5);
        md5s = md5s + &md5 + ",";
        let md5_end = time::now();//
        println!("md5 load!start : {},end :{},duration:{}",file_end.rfc3339(),md5_end.rfc3339(),md5_end-file_end);
        //image file
        let img = match image::load_from_memory(&buffer){
            Ok(file) => file,
            Err(error) => {
                return Err(IronError::new(error,
                                          (status::InternalServerError,
                                           "Unsupported image format")))
            }
        };
        let img_end = time::now();//
        println!("img load!start : {},end :{},duration:{}",md5_end.rfc3339(),img_end.rfc3339(),img_end-md5_end);

        let ref mut fout = File::create(&Path::new(&*(md5+".jpg"))).unwrap();
        // The dimensions method returns the images width and height
        // println!("dimensions {:?}", img.dimensions());
        // The color method returns the image's ColorType
        // println!("{:?}", img.color());

        // Write the contents of this image to the Writer in PNG format.
        let _ = img.save(fout, image::JPEG).unwrap();

        let save_end = time::now();//
        println!("save file!start : {},end :{},duration:{}",img_end.rfc3339(),save_end.rfc3339(),save_end-img_end);

        println!(r#"Field "{}" is file "{}":"#, name, filename);
    }
    let content_type = "application/json".parse::<Mime>().unwrap();
    let object = JsonResult{
        ret:true,
        data:md5s,
    };
    Ok(Response::with((content_type, status::Ok, json::encode(&object).unwrap())))
    // Ok(Response::with((status::Ok, md5s)))
}

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<html>
    <head>
        <script>
            var totals = 1;
            function addInput()
            {
                var newItemText=document.createTextNode("Choose file:");
                var newItemInput=document.createElement("input");
                newItemInput.name="userfile"+(totals++);
                newItemInput.type="file";
                var addfile=document.getElementById("bt_addfile");
                var submit=document.getElementById("bt_submit");
                var newItemBr=document.createElement("br");

                var myform=document.getElementById("upform");
                myform.appendChild(newItemText);
                myform.appendChild(newItemInput);
                myform.appendChild(addfile);
                myform.appendChild(newItemBr);
                myform.appendChild(submit);
            }
        </script>
    </head>
    <h1>Welcome to images' World!</h1>
    <p>Upload image(s) to server:</p>
    <form enctype="multipart/form-data" action="/upload" method=post target=_blank id="upform">
        Choose file:<input name="userfile" type="file">
        <input type="button" value="+" onclick="addInput()" id="bt_addfile">
        </br>
        <input type="submit" value="upload" id="bt_submit">
    </form>
</html>

[package]
name = "upfile"
version = "0.1.0"
authors = ["mignet <[email protected]>"]

[dependencies]
iron = "0.2"
image = "*"
time = "*"
router = "*"
rustc-serialize = "*"
rust-crypto = "0.2.35"

[dependencies.multipart]
version = "0.5.1"
default-features = false
features = ["server", "iron"]

mignet@Master:~/rust-projects/upfile$ cargo run
   Compiling upfile v0.1.0 (file:///home/mignet/rust-projects/upfile)
     Running `target/debug/upfile`
file load!start : 2016-04-17T16:00:49+08:00,end :2016-04-17T16:00:49+08:00,duration:PT0.000094890S
md5 load!start : 2016-04-17T16:00:49+08:00,end :2016-04-17T16:00:49+08:00,duration:PT0.023411631S
img load!start : 2016-04-17T16:00:49+08:00,end :2016-04-17T16:00:52+08:00,duration:PT2.621793752S
save file!start : 2016-04-17T16:00:52+08:00,end :2016-04-17T16:00:55+08:00,duration:PT3.651583434S
Field "userfile" is file "StarUml.png":
---------------------------------------------------------------
mignet@Master:~/rust-projects/upfile$ cargo run --release
   Compiling upfile v0.1.0 (file:///home/mignet/rust-projects/upfile)
     Running `target/release/upfile`
file load!start : 2016-04-17T16:02:28+08:00,end :2016-04-17T16:02:28+08:00,duration:PT0.000099016S
md5 load!start : 2016-04-17T16:02:28+08:00,end :2016-04-17T16:02:28+08:00,duration:PT0.001155275S
img load!start : 2016-04-17T16:02:28+08:00,end :2016-04-17T16:02:28+08:00,duration:PT0.055703035S
save file!start : 2016-04-17T16:02:28+08:00,end :2016-04-17T16:02:28+08:00,duration:PT0.375560153S
Field "userfile" is file "StarUml.png":