#![allow(unused_imports)]
#![deny(bare_trait_objects)]

use getopts::Options;
use log::*;
use mio::{net::*, *};
use std::{
    env,
    str::FromStr as _,
    time::{Duration, Instant},
};

mod core;
mod handlers;
mod protocol;
mod server;
mod utils;

use crate::server::network::{NetworkLayer, NetworkLayerBuilder};

const PROGRAM_NAME: &'_ str = "Hedgewars Game Server";

fn main() {
    env_logger::init();

    info!("Hedgewars game server, protocol {}", utils::SERVER_VERSION);

    let args: Vec<String> = env::args().collect();
    let mut opts = Options::new();

    opts.optopt("p", "port", "port - defaults to 46631", "PORT");
    opts.optflag("h", "help", "help");
    let matches = match opts.parse(&args[1..]) {
        Ok(m) => m,
        Err(e) => {
            println!("{}\n{}", e, opts.short_usage(""));
            return;
        }
    };
    if matches.opt_present("h") {
        println!("{}", opts.usage(PROGRAM_NAME));
        return;
    }

    let port = matches
        .opt_str("p")
        .and_then(|s| u16::from_str(&s).ok())
        .unwrap_or(46631);
    let address = format!("0.0.0.0:{}", port).parse().unwrap();

    let listener = TcpListener::bind(address).unwrap();

    let mut poll = Poll::new().unwrap();
    let mut hw_builder = NetworkLayerBuilder::default().with_listener(listener);

    #[cfg(feature = "tls-connections")]
    {
        let address = format!("0.0.0.0:{}", port + 1).parse().unwrap();
        hw_builder = hw_builder.with_secure_listener(TcpListener::bind(address).unwrap());
    }

    let mut hw_network = hw_builder.build(&poll);
    hw_network.register(&poll).unwrap();

    let mut events = Events::with_capacity(1024);

    let mut time = Instant::now();

    loop {
        let timeout = if hw_network.has_pending_operations() {
            Some(Duration::from_millis(1))
        } else {
            None
        };

        poll.poll(&mut events, timeout).unwrap();

        for event in events.iter() {
            if event.is_readable() {
                match event.token() {
                    token @ (utils::SERVER_TOKEN | utils::SECURE_SERVER_TOKEN) => {
                        match hw_network.accept_client(&poll, token) {
                            Ok(()) => (),
                            Err(e) => debug!("Error accepting client: {}", e),
                        }
                    }
                    #[cfg(feature = "official-server")]
                    utils::IO_TOKEN => match hw_network.handle_io_result(&poll) {
                        Ok(()) => (),
                        Err(e) => debug!("Error in IO task: {}", e),
                    },
                    Token(token) => match hw_network.client_readable(&poll, token) {
                        Ok(()) => (),
                        Err(e) => debug!("Error reading from client socket {}: {}", token, e),
                    },
                }
            }
            if event.is_writable() {
                match event.token() {
                    utils::SERVER_TOKEN | utils::SECURE_SERVER_TOKEN | utils::IO_TOKEN => {
                        unreachable!()
                    }
                    Token(token) => match hw_network.client_writable(&poll, token) {
                        Ok(()) => (),
                        Err(e) => debug!("Error writing to client socket {}: {}", token, e),
                    },
                }
            }
        }

        match hw_network.on_idle(&poll) {
            Ok(()) => (),
            Err(e) => debug!("Error in idle handler: {}", e),
        };

        if time.elapsed() > Duration::from_secs(1) {
            time = Instant::now();
            match hw_network.handle_timeout(&mut poll) {
                Ok(()) => (),
                Err(e) => debug!("Error in timer event: {}", e),
            }
        }
    }
}