#![feature(async_await)]

use std::path::PathBuf;

use tokio;
use tokio::codec::{Framed, LinesCodec};
use tokio::net::TcpListener;
use tokio::prelude::*;

use slog::Drain;
use slog::{error, info, o};
use slog_async;
use slog_term;

use rocksdb::DB;

use blob::BlobServer;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let decorator = slog_term::TermDecorator::new().stderr().build();
    let drain = slog_term::CompactFormat::new(decorator).build().fuse();
    let drain = slog_async::Async::new(drain).build().fuse();
    let log = slog::Logger::root(drain, o!("version" => env!("CARGO_PKG_VERSION")));

    let addr = "127.0.0.1:8080".parse().unwrap();
    let mut listener = TcpListener::bind(&addr)?;
    info!(log, "Listening on: {}", addr);

    info!(log, "initializing");
    let kv = DB::open_default(PathBuf::from("/Users/dialtone/dev/rust/blob/db")).unwrap();

    // Have to use an Arc here unfortunately
    let db = std::sync::Arc::new(BlobServer::new(log.clone(), kv));

    loop {
        match listener.accept().await {
            Ok((socket, _)) => {
                // And here I clone stuff from the Arc or from the log that implements Clone
                let logc = log.clone();
                let dbc = db.clone();

                tokio::spawn(async move {
                    let mut lines = Framed::new(socket, LinesCodec::new());

                    while let Some(result) = lines.next().await {
                        match result {
                            Ok(line) => match dbc.handle_request(&line) {
                                Ok(resp) => {
                                    let response = resp.serialize();
                                    if let Err(e) = lines.send(response).await {
                                        error!(logc, "error on sending response; error = {:?}", e);
                                    }
                                }
                                Err(e) => {
                                    error!(logc, "error on processing the request; error = {:?}", e)
                                }
                            },
                            Err(e) => {
                                error!(logc, "error on decoding from socket; error = {:?}", e);
                            }
                        }
                    }
                });
            }
            Err(e) => error!(log, "error accepting socket; error = {:?}", e),
        }
    }
}