mod mime;
mod server;
use std::env;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::path::Path;

fn help() {
    let version = match option_env!("CARGO_PKG_VERSION") {
        Some(v) => v,
        None => "",
    };

    println!("usage: sheldond {}", version);
    println!("  -c, --config\t\tpath to the configuration file");
}

fn parse_args() -> Option<String> {
    let mut args = env::args();
    loop {
        match args.next() {
            Some(arg) => {
                if arg == "-h" || arg == "--help" {
                    help();
                    return None;
                }
                if arg == "-c" || arg == "--config" {
                    let config_fname = args.next().unwrap();
                    return Some(config_fname);
                }
            }
            None => break,
        }
    }

    Some("/etc/sheldond.conf".to_string())
}

fn parse_config(fname: String) -> server::ServerConfig {
    println!("reading configuration from: {}", fname);

    let path = Path::new(&fname);
    let mut config = server::ServerConfig::new();

    let file = match File::open(path) {
        Ok(file) => BufReader::new(file),
        Err(_) => {
            panic!("could not open config file: {}", fname);
        }
    };

    for rline in file.lines() {
        let line = rline.unwrap();
        if line == "" || line.starts_with("#") {
            continue;
        }

        let mut parts = line.split_whitespace();

        let key = parts.next().unwrap();

        if parts.next().unwrap() != "=" {
            panic!("malformatted line in config: {}", line);
        }

        let val = parts.next().unwrap().to_string();

        match key {
            "default_host" => config.set_default_host(val),
            "gem_root" => config.set_gem_root(val),
            "listen" => config.add_addr(val),
            "user" => config.set_user(val),
            "group" => config.set_group(val),
            "cert_key" => config.set_cert_key(val),
            "cert_chain" => config.set_cert_chain(val),
            _ => {
                panic!("unknown key in config: {}", key);
            }
        }
    }

    return config;
}

fn main() {
    let config_fname = match parse_args() {
        Some(config_fname) => config_fname,
        None => {
            return;
        }
    };
    let config = parse_config(config_fname);

    let server = server::Server::new(&config);
    server.serve();
}