use tokio::{io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader}, net::{tcp::WriteHalf, TcpListener}, sync::mpsc};
use tokio::sync::broadcast;
use std::{collections::HashMap, net::SocketAddr};
use tokio::net::TcpStream;
use crate::{message::{Message, MessageKind}, message_read::MessageReader, server};

#[derive(Debug)]
pub struct Server {
    pub host: String,
    pub port: u16,
}

impl Server {
    pub fn new(host: impl Into<String>, port: u16) -> Self {
        Server {
            host: host.into(),
            port,
        }
    }

    async fn process_connection(mut stream: TcpStream, addr: SocketAddr) -> anyhow::Result<()> {
        let (mut rd, mut wr) = stream.split();

        let message = Message::new(&addr.to_string(), MessageKind::Test, "risposta")?.as_bytes_vec()?;
        wr.write_all(&message).await?;

        let mut message_reader = MessageReader::new();
        let mut buf = Vec::with_capacity(4);

        match rd.read_exact(&mut buf).await {
            Ok(0) => {
                println!("connection closed by client");
                return Ok(())
            },
            Ok(n) => {
                let mut buf = Vec::with_capacity(n);
                rd.read_exact(&mut buf).await?;
                let message = message_reader.read(&buf).expect("fallito lettura buffer");
                println!("{:?}", message);
            },
            Err(e) => eprintln!("failed reading from socket: {}", e),
        }

        Ok(())
    }

    #[allow(unreachable_code)]
    #[tracing::instrument]
    pub async fn run(&mut self) -> anyhow::Result<()> {
        let listener = TcpListener::bind(format!(
            "{}:{}",
            self.host,
            self.port
        )).await?;

        println!("Server is running on {}:{}", self.host, self.port);

        // let mut db = HashMap::new();

        loop {
            match listener.accept().await {
                Ok((stream, addr)) => {
                    println!("connected to: {}", addr);
                    tokio::spawn(async move {
                        Self::process_connection(stream, addr).await;
                    });
                },
                Err(e) => eprintln!("error connecting: {}", e) 
            }
        }
      
        Ok(())
    }
}