use anyhow::Context;
use bytes::Bytes;
use thiserror::Error;
use tokio_stream::StreamExt;

mod exec;
mod terminal;

#[derive(Debug, Error)]
enum ServiceError {
    #[error("received an invalid body format for a valid message")]
    BodyFormatError,
}

async fn route_message(message: crate::messaging::Message) -> Result<(), ServiceError> {
    match message.subject() {
        crate::messaging::Subject::Health => {}
        crate::messaging::Subject::Exec => {
            let ctx = Ctx::with_body(message.body())?;
            let _ = self::exec::exec(ctx).await;
        }
        crate::messaging::Subject::OpenTerminal => {
            let ctx = Ctx::with_body(message.body())?;
            let _ = self::terminal::open_terminal(ctx).await;
        }
    }

    Ok(())
}

struct Ctx<T> {
    body: T,
    // input_streams:
}

impl<T> Ctx<T>
where
    T: TryFrom<Bytes>,
{
    fn with_body(body: Bytes) -> Result<Self, ServiceError> {
        Ok(Self {
            body: body
                .try_into()
                .map_err(|_err| ServiceError::BodyFormatError)?,
        })
    }
}

pub async fn init_services(client: crate::messaging::Client) -> anyhow::Result<()> {
    let mut message_stream = client
        .subscribe()
        .await
        .context("could not initialize services system")?;

    tokio::spawn(async move {
        while let Some(message) = message_stream.next().await {
            // TODO: How do i handle this error?
            if let Err(err) = route_message(message).await {
                tracing::warn!("{}", err);
            };
        }
    });

    Ok(())
}