mod db;
mod parser;

use crate::db::*;
use crate::parser::*;

use std::io;

use tokio::net::TcpListener;

const ADDR: &'static str = "0.0.0.0:7700";
const BUFSIZE: usize = 1024;

#[tokio::main]
async fn main() {
    //test();
    let conn = connectdb().unwrap();
    initdb(&conn).unwrap();
    apiserver().await.unwrap();
}

#[allow(dead_code)]
fn test() {
    use bcd_convert::BcdNumber;
    let data: Vec<u8> = vec![0x36, 0x31, 0x33, 0x32, 0x31, 0x31, 0x38];
    let code = BcdNumber::try_from(&data as &[u8]).unwrap();
    println!("{code}");
    std::process::exit(0);
}

async fn apiserver() -> io::Result<()> {
    let listener = match TcpListener::bind(ADDR).await {
        Ok(o) => o,
        Err(e) => {
            println!("error: {e}");
            std::process::exit(1);
        }
    };

    loop {
        let (socket, _remote_addr) = listener.accept().await?;
        tokio::spawn(async move {
            let mut buf = vec![0; BUFSIZE];
            loop {
                let mut terminal_id = 0;
                match socket.readable().await {
                    Ok(_) => {
                        match socket.try_read(&mut buf) {
                            Ok(_) => match handle(&buf) {
                                Some(o) => match socket.try_write(&o) {
                                    Ok(_) => {}
                                    Err(ref e) if e.kind() == io::ErrorKind::BrokenPipe => {
                                        println!("broken pipe: {e}");
                                        break;
                                    }
                                    Err(e) => {
                                        println!("error: {e}");
                                        break;
                                    }
                                },
                                None => {
                                    break;
                                }
                            },
                            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                                continue;
                            }
                            Err(e) => {
                                println!("error read: {e}");
                            }
                        };
                    }
                    Err(e) => {
                        println!("error socket readable: {e}");
                    }
                }
                match socket.writable().await {
                    Ok(_) => {
                        let msg = Message::default();
                    }
                    Err(e) => {
                        println!("error socket writable: {e}")
                    }
                }
            }
        });
    }
}

fn handle(buf: &Vec<u8>) -> Option<Vec<u8>> {
    let mut rawdata = InboundDataWrapper::new(buf.to_vec());
    let reply = match parse_inbound_msg(&mut rawdata) {
        Ok(o) => {
            println!("query: {}", o);
            //println!("raw query: {:X?}", o.to_raw());
            Message::store(&o);
            Message::set_reply(o)
        }
        Err(e) => {
            println!("parse inbound message error: {}", e);
            return None;
        }
    };

    match reply {
        Some(o) => {
            println!("reply: {}", o);
            //println!("raw reply {:X?}", o.to_raw());
            println!("--------------");
            return Some(o.to_raw().into());
        }
        None => {
            return None;
        }
    }
}