use std::{collections::HashMap, sync::Arc};

use futures::Stream;
use http::Http;
use serde::Deserialize;
use systemd::Systemd;
use tcp::Tcp;
use tokio::{
    sync::watch::{Receiver, Sender},
    task::JoinHandle,
};
use tokio_stream::wrappers::WatchStream;

use crate::{Error, Status};

pub mod http;
pub mod systemd;
pub mod tcp;

pub type ServiceHandles = Arc<HashMap<String, ServiceHandle>>;

pub trait ServiceSpawner {
    fn spawn(
        self,
        tx: Sender<Status>,
    ) -> impl std::future::Future<Output = Result<(), Error>> + std::marker::Send + 'static;
}

#[derive(Debug)]
pub struct ServiceHandle {
    pub handle: JoinHandle<Result<(), Error>>,
    pub rx: Receiver<Status>,
}

impl ServiceHandle {
    pub fn new(service: impl ServiceSpawner) -> Self {
        let (tx, rx) = tokio::sync::watch::channel(Status::default());
        let handle = tokio::spawn(service.spawn(tx));
        Self { handle, rx }
    }

    pub fn status(&self) -> Status {
        self.rx.borrow().clone()
    }

    pub fn into_stream(&self) -> impl Stream<Item = Status> {
        WatchStream::new(self.rx.clone())
    }
}

#[derive(Debug, Clone, Deserialize)]
#[serde(untagged)]
pub enum Service {
    Http(Http),
    Tcp(Tcp),
    Systemd(Systemd),
}

impl From<Service> for ServiceHandle {
    fn from(value: Service) -> Self {
        match value {
            Service::Http(s) => ServiceHandle::new(s),
            Service::Tcp(s) => ServiceHandle::new(s),
            Service::Systemd(s) => ServiceHandle::new(s),
        }
    }
}