extern crate futures;
extern crate tokio;
extern crate tokio_threadpool;

// use std::{thread, time};
use std::time::{Duration, Instant};
use std::net::SocketAddr;

use futures::prelude::*;

use tokio::io;
// use tokio::prelude::*;
use tokio::timer::Interval;
// use tokio_threadpool::ThreadPool;
use tokio::runtime::Builder;
use tokio::net::{{TcpStream, TcpListener}};

fn prepare_server() -> Box<Future<Item = (), Error = io::Error> + Send> {
    let addr = "127.0.0.1:8080".parse::<std::net::SocketAddr>().unwrap();
    let listener = TcpListener::bind(&addr).unwrap();
    let server = listener
        .incoming()
        .for_each(move |socket: tokio::net::TcpStream| {
            let address = socket.peer_addr().expect("");
            println!("Received connection from {}", address);
            Ok(())
        });
    Box::new(server)
}

fn delay_future() -> Box<Future<Item = (), Error = io::Error> + Send> {
    let wait_time = Duration::from_millis(100);
    let now = Instant::now();
    let task = Interval::new(now, wait_time)
        .map_err(|e| panic!("interval errored; err={:?}", e))
        .take(10)
        .for_each(|instant| {
            println!("fire; instant={:?}", instant);
            Ok(())
        });
    Box::new(task)
}

fn connect_future() -> Box<Future<Item = (), Error = io::Error> + Send> {
    println!("Executing connect future...");
    let server_addr = "94.130.182.25:443".parse::<SocketAddr>().unwrap();
    let server_conn = TcpStream::connect(&server_addr);
    let task = server_conn
        .map_err(|err| eprintln!("{}", err))
        .then(|socket| {
            println!("conn successful on {:?}", socket);
            Ok(())
        });
    println!("End Future");
    Box::new(task)
}


fn main() -> Result<(),String> {
    let mut pool = Builder::new()
        .core_threads(4)
        .build()
        .unwrap();

    pool.spawn(delay_future().map_err(|e| eprintln!("future error {}", e)));
    pool.spawn(connect_future().map_err(|e| eprintln!("future error {}", e)));
    pool.spawn(prepare_server().map_err(|e| eprintln!("future error {}", e)));
    // kills the future thread
    pool.shutdown_on_idle().wait().expect("shutdown error!");
    Ok(())
}