use crate::config::Context;

use serde_json;
use std::io;
use std::sync::Arc;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpSocket;
use tokio::sync::RwLock;

pub async fn apiserver(ctxarc: &Arc<RwLock<Context>>) -> io::Result<()> {
    let ctxarc = ctxarc.clone();
    let addr;
    {
        let ctx = ctxarc.read().await;
        addr = ctx.cfg.api.parse().unwrap();
    }

    let socket = TcpSocket::new_v4().unwrap();
    socket.bind(addr).unwrap();
    socket.set_reuseaddr(true).unwrap();
    let listener = socket.listen(1024).unwrap();

    tokio::spawn(async move {
        loop {
            //apitx.send(String::from("")).await.unwrap();
            match listener.accept().await {
                Ok((stream, _addr)) => {
                    //let mut buf = [0; 1024];
                    let data;
                    {
                        let ctx = ctxarc.read().await;
                        data = serde_json::to_string(&ctx.blocklist);
                    }

                    match data {
                        Ok(dt) => {
                            let (_reader, mut writer) = stream.into_split();
                            match writer.write_all(format!("{dt}").as_bytes()).await {
                                Ok(_) => {}
                                Err(err) => {
                                    println!("{err}");
                                }
                            }
                        }
                        Err(err) => {
                            println!("unable to serialize data: {err}");
                        }
                    }
                }
                Err(err) => {
                    println!("couldn't get client: {}", err)
                }
            }
        }
    });
    Ok(())
}