use std::{
    io::{prelude::*, BufReader, Lines},
    net::{TcpListener, TcpStream},
};
use std::thread::available_parallelism;
use crate::thread_pool::ThreadPool;

mod thread_pool;


fn main() {
    // start server on localhost (for remote access use: 0.0.0.0)
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    
    // create thread pool (size = no. of cpu cores)
    let pool = ThreadPool::new(available_parallelism().unwrap().get());

    // handling function for incoming requests
    for stream in listener.incoming() {
        let stream = stream.unwrap();

        // pass request to thread pool
        pool.execute(|| {
            handle_connection(stream);
        });
    }
    println!("Shutting down.");
}


fn handle_connection(mut stream: TcpStream) {
    // clone TcpStream for simultaneous receiving and sending
    let mut stream2: TcpStream = stream.try_clone().unwrap();

    // initialize reading buffer (for better performance!)
    let buf_reader: BufReader<&mut TcpStream> = BufReader::new(&mut stream);
    // request: read received text line by line (continuous until connection closed)
    let request: Lines<BufReader<&mut TcpStream>> = buf_reader.lines();

    println!("Request: {:#?}", request);

    // processing function for every text line received by request (terminates when conn closed)
    for elem in request
    {
        // store received line in variable s
        let s = elem.unwrap();
        println!("{:?}", s);

        // send received line back to sender (append LF)
        stream2.write_all(s.as_bytes()).unwrap();
        stream2.write_all(b"\n").unwrap();
    }
}