use tokio::net::TcpListener;
use std::sync::Arc;
use rust_mc_proto_tokio::{prelude::*, MCConnTcp, MinecraftConnection, Packet, ProtocolError};

/*

    Example of simple server that sends motd 
    to client like a vanilla minecraft server

*/

struct MinecraftServer {
    server_ip: String,
    server_port: u16,
    motd: String
}

impl MinecraftServer {
    fn new(server_ip: &str,
            server_port: u16,
            motd: &str) -> Self {
        MinecraftServer {
            server_ip: server_ip.to_string(),
            server_port,
            motd: motd.to_string()
        }
    }

    async fn start(self) {
        let addr = self.server_ip.clone() + ":" + &self.server_port.to_string();
        let listener = TcpListener::bind(addr).await.unwrap();

        let this = Arc::new(self);

        while let Ok((stream, _)) = listener.accept().await {
            tokio::spawn({
                let this = this.clone();

                async move {
                    Self::accept_client(this, MinecraftConnection::new(stream)).await.unwrap();
                }
            });
        }
    }

    async fn accept_client(self: Arc<Self>, mut conn: MCConnTcp) -> Result<(), ProtocolError> {
        let mut handshake = false;
        
        loop {
            let Ok(mut packet) = conn.read_packet().await else { break; };
    
            if handshake {
                if packet.id() == 0x00 {
                    let motd = self.motd.clone();

                    let mut status = Packet::empty(0x00);
                    status.write_string(&motd).await?;
                    conn.write_packet(&status).await?;
                } else if packet.id() == 0x01 {
                    let mut status = Packet::empty(0x01);
                    status.write_long(packet.read_long().await?).await?;
                    conn.write_packet(&status).await?;
                }
            } else if packet.id() == 0x00 {
                let protocol_version = packet.read_i32_varint().await?;
                let server_address = packet.read_string().await?;
                let server_port = packet.read_unsigned_short().await?;
                let next_state = packet.read_u8_varint().await?;
    
                if next_state != 1 { break; }
    
                println!(
                    "{} > protocol: {} server: {}:{}", 
                    conn.get_ref().peer_addr().unwrap(), 
                    protocol_version, 
                    server_address, 
                    server_port
                );
    
                handshake = true;
            } else {
                break;
            }
        }
    
        conn.close().await;
    
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    let server = MinecraftServer::new(
        "127.0.0.1", 
        25565, 
        "{
            \"version\":{
                \"protocol\":765,
                \"name\":\"Version name\"
            },
            \"players\":{
                \"online\":0,
                \"max\":1,
                \"sample\":[
                    {
                        \"uuid\": \"\",
                        \"name\": \"Notch\"
                    }
                ]
            },
            \"description\": {
                \"text\": \"Hello World!\",
                \"color\": \"red\",
                \"bold\": true
            },
            \"favicon\": \"data:image/png;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=\"
        }"
    );

    server.start().await;
}