#![feature(proc_macro_hygiene, decl_macro)]

use std::fs;
use std::fs::File;
use std::io::{Read, Write};

#[macro_use] extern crate rocket;
use rocket::Data;

use tempfile::NamedTempFile;

use sha3::{Digest, Sha3_256};

const MAX_FILE_SIZE: u64 = 1024 * 1024;

#[get("/")]
fn index() -> &'static str {
    "POST /upload/<file_extension>"
}

#[get("/<id>")]
fn download(id: String) -> Option<File> {
    let extloc = id.rfind('.')?;
    let noext: String = id.chars().take(extloc).collect();
    let ext: String = id.chars().skip(extloc).collect();
    let filename = format!("./files/{}{}", noext, ext);
    File::open(&filename).ok()
}

#[post("/upload/<ext>", data = "<paste>")]
fn upload(ext: String, paste: Data) -> Result<String, std::io::Error> {
    // write data to file and hasher
    let mut tmp_file = NamedTempFile::new()?;
    let mut reader = paste.open().take(MAX_FILE_SIZE);
    let mut buffer: [u8; 1024] = [0; 1024];
    let mut hasher = Sha3_256::new();

    while let Ok(read_bytes) = reader.read(&mut buffer) {
        if read_bytes == 0 { // EOF has been reached
            break ;
        }
        hasher.input(&buffer[0..read_bytes]);
        tmp_file.write_all(&buffer[0..read_bytes])?;
    }

    // generate filename
    let mut filename = String::new();
    let digest = hasher.result();

    for idx in 0..32 {
        filename.push_str(&format!("{:x}", digest[idx]));
    }

    // save tmpfile
    tmp_file.persist(format!("./files/{}", filename))?;

    // return filename
    Ok(format!("{}.{}", filename, ext))
}

fn main() {

    if let Err(_) = fs::read_dir("./files/") {
        println!("Failed to open the directory ./files/");
        fs::create_dir("./files/").unwrap();
    }

    rocket::ignite()
        .mount("/", routes![index, download, upload])
        .launch();
}