extern crate notify;
extern crate hyper;
extern crate regex_env;

use notify::{RecommendedWatcher, Watcher, RecursiveMode};
use std::sync::mpsc::{channel, Sender, Receiver};
use notify::DebouncedEvent;
use std::time::Duration;

use std::io::BufWriter;
use std::io::prelude::*;
use std::fs::File;

use std::path::Path;
use std::path::PathBuf;

use hyper::Client;

use regex_env::env;

fn main() {
    let (tx, rx) = channel();

    if let Err(e) = setup(tx) {
        println!("{}", e);
        std::process::exit(1);
    }

    println!("Waiting for changes to /etc/letsencrypt/live... Hit Ctrl-C to stop.");

    handle(rx);
}

fn setup(tx: Sender<DebouncedEvent>) -> Result<(), String> {
    let mut watcher: RecommendedWatcher = match Watcher::new(tx, Duration::from_secs(1)) {
        Ok(i) => i,
        Err(e) => {
            let msg = format!("Failed to initialise notify ({})", e);
            return Err(msg);
        }
    };

    if let Err(e) = watcher.watch("/etc/letsencrypt/live", RecursiveMode::Recursive) {
        let msg = format!("Something went wrong watching the folder /etc/letsencrypt/live: {}", e);
        return Err(msg);
    };

    Ok(())
}

fn handle(rx: Receiver<DebouncedEvent>) {
    while let Ok(event) = rx.recv() {
        let _ = match event {
            DebouncedEvent::Create(file) => created(file),
            DebouncedEvent::Write(file) => created(file),
            DebouncedEvent::Remove(file) => removed(file),
            DebouncedEvent::Rename(from, to) => renamed(from, to),
            DebouncedEvent::Chmod(file) => created(file),
            _ => continue
        };
    }
}

fn created(p: PathBuf) {
    if Path::new(&p).is_dir() && Path::new(&p.join("privkey.pem")).is_file() && Path::new(&p.join("fullchain.pem")).is_file() {
        let paths = vec![
            p.join("privkey.pem"),
            p.join("fullchain.pem"),
        ];

        if let Ok(site_name) = p.strip_prefix("/etc/letsencrypt/live") {
            let mut buffer = Vec::new();

            for path in paths {
                let mut file = File::open(path).expect("Unable to open file");

                let _ = file.read_to_end(&mut buffer);
            };

            if let Some(name) = site_name.to_str() {
                let output_file = format!("/var/certs/letsencrypt/{}.pem", name);

                if !Path::new("/var/certs/letsencrypt").is_dir() {
                    let _ = match std::fs::create_dir("/var/certs/letsencrypt") {
                        Err(e) => {
                            println!("Error creating the directory /var/certs/letsencrypt: {}", e);
                        },
                        Ok(t) => t,
                    };
                }

                let output = File::create(output_file).expect("Unable to create file");

                let mut f = BufWriter::new(output);

                f.write_all(&buffer).expect("Unable to write data");
            }
        }
    }

    notify();
}

fn renamed(from: PathBuf, to: PathBuf) {
    created(to);
    removed(from);
}

fn removed(p: PathBuf) {
    if let Ok(site_name) = p.strip_prefix("/etc/letsencrypt/live") {
        if let Some(name) = site_name.to_str() {
            let output_file = format!("/var/certs/letsencrypt/{}.pem", name);

            if Path::new(&output_file).is_file() {
                let _ = std::fs::remove_file(output_file);
            }
        }
    }

    notify();
}

fn notify() {
    if let Some(ip) = env(r"^loadbalancer.ip=(.*)$", "/var/www/config/global/.env") {
        let response = Client::new().head(&format!("http://{}:9999", ip)).send();

        match response {
            Ok(res) => println!("Response: {}", res.status),
            Err(e) => println!("Error: {}", e),
        }
    } else {
        println!("Unable to notify the load balancer, IP address not found in global env file");
    }
}