mod rotctl;

use tokio::{
    self,
    io::{AsyncBufReadExt, AsyncWriteExt, BufStream},
    net::{TcpListener, TcpStream},
};

use rotctl::Command;

use std::io;

async fn process_socket(socket: TcpStream) {
    let mut stream = BufStream::new(socket);

    let mut line = String::new();

    let mut az = 0.0;
    let mut el = 0.0;

    loop {
        if let Ok(n) = stream.read_line(&mut line).await {
            if n == 0 {
                return;
            }

            println!("> {}", line);

            match rotctl::parse_command(&line) {
                Ok(cmd) => match cmd {
                    Command::GetPos => {
                        stream
                            .write_all(format!("{}\n{}\n", az, el).as_bytes())
                            .await
                            .unwrap();
                        stream.flush().await.unwrap();
                    }
                    Command::SetPos(new_az, new_el) => {
                        az = new_az;
                        el = new_el;
                        stream.write_all("RPRT 0\n".as_bytes()).await.unwrap();
                        stream.flush().await.unwrap();
                    }
                    Command::Stop => {
                        stream.write_all("RPRT 0\n".as_bytes()).await.unwrap();
                        stream.flush().await.unwrap();
                    }
                    Command::Exit => {
                        stream.write_all("RPRT 0\n".as_bytes()).await.unwrap();
                        stream.flush().await.unwrap();
                        return;
                    }
                    _ => {}
                },
                Err(msg) => {
                    stream.write_all(msg.as_bytes()).await.unwrap();
                    stream.flush().await.unwrap();
                }
            }

            line.clear();
        } else {
            return;
        }
    }
}

#[tokio::main]
async fn main() -> io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (socket, _) = listener.accept().await?;
        tokio::spawn(async move {
            process_socket(socket).await;
        });
    }
}