Kordophone/kpcli/src/daemon/mod.rs

use crate::printers::{ConversationPrinter, MessagePrinter};
use anyhow::Result;
use clap::Subcommand;
use dbus::blocking::{Connection, Proxy};
use prettytable::table;

const DBUS_NAME: &str = "net.buzzert.kordophonecd";
const DBUS_PATH: &str = "/net/buzzert/kordophonecd/daemon";

mod dbus_interface {
    #![allow(unused)]
    include!(concat!(env!("OUT_DIR"), "/kordophone-client.rs"));
}

use dbus_interface::NetBuzzertKordophoneRepository as KordophoneRepository;
use dbus_interface::NetBuzzertKordophoneSettings as KordophoneSettings;

#[derive(Subcommand)]
pub enum Commands {
    /// Gets all known conversations.
    Conversations,

    /// Runs a full sync operation for a conversation and its messages.
    Sync { conversation_id: Option<String> },

    /// Runs a sync operation for the conversation list.
    SyncList,

    /// Prints the server Kordophone version.
    Version,

    /// Configuration options
    Config {
        #[command(subcommand)]
        command: ConfigCommands,
    },

    /// Waits for signals from the daemon.
    Signals,

    /// Prints the messages for a conversation.
    Messages {
        conversation_id: String,
        last_message_id: Option<String>,
    },

    /// Deletes all conversations.
    DeleteAllConversations,

    /// Enqueues an outgoing message to be sent to a conversation.
    SendMessage {
        conversation_id: String,
        text: String,
    },
}

#[derive(Subcommand)]
pub enum ConfigCommands {
    /// Prints the current settings.
    Print,

    /// Sets the server URL.
    SetServerUrl { url: String },

    /// Sets the username.
    SetUsername { username: String },
}

impl Commands {
    pub async fn run(cmd: Commands) -> Result<()> {
        let mut client = DaemonCli::new()?;
        match cmd {
            Commands::Version => client.print_version().await,
            Commands::Conversations => client.print_conversations().await,
            Commands::Sync { conversation_id } => client.sync_conversations(conversation_id).await,
            Commands::SyncList => client.sync_conversations_list().await,
            Commands::Config { command } => client.config(command).await,
            Commands::Signals => client.wait_for_signals().await,
            Commands::Messages {
                conversation_id,
                last_message_id,
            } => {
                client
                    .print_messages(conversation_id, last_message_id)
                    .await
            }
            Commands::DeleteAllConversations => client.delete_all_conversations().await,
            Commands::SendMessage {
                conversation_id,
                text,
            } => client.enqueue_outgoing_message(conversation_id, text).await,
        }
    }
}

struct DaemonCli {
    conn: Connection,
}

impl DaemonCli {
    pub fn new() -> Result<Self> {
        Ok(Self {
            conn: Connection::new_session()?,
        })
    }

    fn proxy(&self) -> Proxy<&Connection> {
        self.conn
            .with_proxy(DBUS_NAME, DBUS_PATH, std::time::Duration::from_millis(5000))
    }

    pub async fn print_version(&mut self) -> Result<()> {
        let version = KordophoneRepository::get_version(&self.proxy())?;
        println!("Server version: {}", version);
        Ok(())
    }

    pub async fn print_conversations(&mut self) -> Result<()> {
        let conversations = KordophoneRepository::get_conversations(&self.proxy(), 100, 0)?;
        println!("Number of conversations: {}", conversations.len());

        for conversation in conversations {
            println!("{}", ConversationPrinter::new(&conversation.into()));
        }

        Ok(())
    }

    pub async fn sync_conversations(&mut self, conversation_id: Option<String>) -> Result<()> {
        if let Some(conversation_id) = conversation_id {
            KordophoneRepository::sync_conversation(&self.proxy(), &conversation_id)
                .map_err(|e| anyhow::anyhow!("Failed to sync conversation: {}", e))
        } else {
            KordophoneRepository::sync_all_conversations(&self.proxy())
                .map_err(|e| anyhow::anyhow!("Failed to sync conversations: {}", e))
        }
    }

    pub async fn sync_conversations_list(&mut self) -> Result<()> {
        KordophoneRepository::sync_conversation_list(&self.proxy())
            .map_err(|e| anyhow::anyhow!("Failed to sync conversations: {}", e))
    }

    pub async fn print_messages(
        &mut self,
        conversation_id: String,
        last_message_id: Option<String>,
    ) -> Result<()> {
        let messages = KordophoneRepository::get_messages(
            &self.proxy(),
            &conversation_id,
            &last_message_id.unwrap_or_default(),
        )?;
        println!("Number of messages: {}", messages.len());

        for message in messages {
            println!("{}", MessagePrinter::new(&message.into()));
        }

        Ok(())
    }

    pub async fn enqueue_outgoing_message(
        &mut self,
        conversation_id: String,
        text: String,
    ) -> Result<()> {
        let outgoing_message_id =
            KordophoneRepository::send_message(&self.proxy(), &conversation_id, &text)?;
        println!("Outgoing message ID: {}", outgoing_message_id);
        Ok(())
    }

    pub async fn wait_for_signals(&mut self) -> Result<()> {
        use dbus::Message;
        mod dbus_signals {
            pub use super::dbus_interface::NetBuzzertKordophoneRepositoryConversationsUpdated as ConversationsUpdated;
        }

        let _id = self.proxy().match_signal(
            |h: dbus_signals::ConversationsUpdated, _: &Connection, _: &Message| {
                println!("Signal: Conversations updated");
                true
            },
        );

        println!("Waiting for signals...");
        loop {
            self.conn.process(std::time::Duration::from_millis(1000))?;
        }
    }

    pub async fn config(&mut self, cmd: ConfigCommands) -> Result<()> {
        match cmd {
            ConfigCommands::Print => self.print_settings().await,
            ConfigCommands::SetServerUrl { url } => self.set_server_url(url).await,
            ConfigCommands::SetUsername { username } => self.set_username(username).await,
        }
    }

    pub async fn print_settings(&mut self) -> Result<()> {
        let server_url = KordophoneSettings::server_url(&self.proxy()).unwrap_or_default();
        let username = KordophoneSettings::username(&self.proxy()).unwrap_or_default();

        let table = table!(
            [ b->"Server URL",      &server_url ],
            [ b->"Username",        &username ]
        );
        table.printstd();

        Ok(())
    }

    pub async fn set_server_url(&mut self, url: String) -> Result<()> {
        KordophoneSettings::set_server_url(&self.proxy(), url)
            .map_err(|e| anyhow::anyhow!("Failed to set server URL: {}", e))
    }

    pub async fn set_username(&mut self, username: String) -> Result<()> {
        KordophoneSettings::set_username(&self.proxy(), username)
            .map_err(|e| anyhow::anyhow!("Failed to set username: {}", e))
    }

    pub async fn delete_all_conversations(&mut self) -> Result<()> {
        KordophoneRepository::delete_all_conversations(&self.proxy())
            .map_err(|e| anyhow::anyhow!("Failed to delete all conversations: {}", e))
    }
}