use std::{fmt::Display, net::SocketAddr, time::Duration};

use serde::{Deserialize, Serialize};
use tokio::{io::Interest, net::TcpSocket};

use crate::Status;

use super::IntoService;

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Tcp {
    pub address: SocketAddr,
    #[serde(default = "super::default_interval")]
    pub interval: Duration,
}

impl Display for Tcp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "tcp://{}", self.address)
    }
}

impl Tcp {
    async fn check(address: SocketAddr) -> Result<(), std::io::Error> {
        let sock = TcpSocket::new_v4()?;
        sock.set_keepalive(true)?;

        let conn = sock.connect(address).await?;
        // TODO: figure out how to wait for connection to close
        conn.ready(Interest::READABLE).await?;
        Ok(())
    }
}

impl IntoService for Tcp {
    async fn into_service(self, tx: tokio::sync::watch::Sender<Status>) {
        let mut interval = tokio::time::interval(self.interval);

        loop {
            interval.tick().await;
            let res = Self::check(self.address).await;
            tx.send_if_modified(|s| s.update(res.into()));
        }
    }
}