use std::io::prelude::*;
use std::{fs::File, env::args};

use actix_files as fs;
use actix_web::{web, middleware, App, HttpServer, HttpResponse, Result, web::Query, middleware::Logger};

use askama::Template;
use listenfd::ListenFd;
use ron::de::from_reader;
use serde::Deserialize;
use env_logger;

use itertools::Itertools;

mod consts;
mod db;

#[derive(Template)]
#[template(path = "main.html")]
struct MainTemplate<'a> {
    test: &'a str,
}

#[derive(Deserialize)]
pub struct Request {
   m: Option<String>
}

fn main_page(query: Query<Request>) -> Result<HttpResponse> {

    let main_template = MainTemplate { test: &"* test *" };

    let s = main_template.render().unwrap();
    Ok(HttpResponse::Ok().content_type("text/html").body(s))
}

#[derive(Debug, Deserialize)]
struct Config {
    port: u16
}

fn get_exe_name() -> String {
    let first_arg = std::env::args().nth(0).unwrap();
    let sep: &[_] = &['\\', '/'];
    first_arg[first_arg.rfind(sep).unwrap()+1..].to_string()
}

fn main() -> std::io::Result<()> {
    if process_args() { return Ok(()) }

    println!("Starting RUP as web server...");

    let config: Config = {
        let f = File::open(consts::FILE_CONF).unwrap_or_else(|_| panic!("Failed to open configuration file {}", consts::FILE_CONF));
        match from_reader(f) {
            Ok(c) => c,
            Err(e) => panic!("Failed to load config: {}", e)
        }
    };

    println!("Configuration: {:?}", config);

    // let database_connection = db::create_or_update();

    std::env::set_var("RUST_LOG", "actix_web=info");
    env_logger::init();

    let mut listenfd = ListenFd::from_env();
    let mut server =
        HttpServer::new(
            || {
                App::new()
                    .wrap(middleware::Compress::default())
                    .wrap(Logger::default())
                    .wrap(Logger::new("%a %{User-Agent}i"))
                    .service(web::resource("/").to(main_page))
                    .service(fs::Files::new("/static", "static").show_files_listing())
            }
        );

    server =
        if let Some(l) = listenfd.take_tcp_listener(0).unwrap() {
            server.listen(l).unwrap()
        } else {
            server.bind(&format!("0.0.0.0:{}", config.port)).unwrap()
        };

    server.run()
}

fn process_args() -> bool {
    fn print_usage() {
        println!("Usage:");
        println!(" {} [--help] [--test]", get_exe_name());
    }

    let args: Vec<String> = args().collect();

    if args.iter().any(|arg| arg == "--help") {
        print_usage();
        return true
    } else if args.iter().any(|arg| arg == "--test") {
        let database_connection = db::create_or_update();
        return true
    }

    false
}