teamspeak-query-lib/src/cli.rs

use clap::{Args, Parser, Subcommand};
use telnet::Telnet;

use crate::parameter::{Parameter, ParameterList};
use crate::response::channel::ResponseChannel;
use crate::response::client::ResponseClient;
use crate::utils::SendTextMessageTarget;
use crate::wrappers;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
#[command(propagate_version = true)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
pub enum Commands {
    Channels(ChannelsArgs),
    Clients,
    Fetch(FetchArgs),
    Message(MessageArgs),
    Move(MoveArgs),
    Update(UpdateArgs),
}

#[derive(Args)]
pub struct ChannelsArgs {
    #[arg(long)]
    pub spacers: bool,
}

#[derive(Args)]
pub struct FetchArgs {
    #[arg(long)]
    strict_client: bool,
    #[arg(long)]
    strict_channel: bool,
    #[arg(long)]
    channel: Option<String>,
    #[arg(long)]
    client: Option<String>,
}

#[derive(Args)]
pub struct MessageArgs {
    #[arg(long)]
    strict_client: bool,
    #[arg(long)]
    client: Option<String>,
    #[arg(long)]
    server: bool,
    pub message: String,
}

#[derive(Args)]
pub struct MoveArgs {
    #[arg(long)]
    strict_client: bool,
    #[arg(long)]
    strict_channel: bool,
    channel: String,
    client: Option<String>,
}

#[derive(Args)]
pub struct UpdateArgs {
    #[arg(long, short)]
    name: Option<String>,
    #[arg(long, short)]
    away: Option<String>,
    #[arg(long, short)]
    back: bool,
    #[arg(long, short)]
    microphone: Option<bool>,
    #[arg(long, short)]
    speakers: Option<bool>,
}

impl FetchArgs {
    pub fn want_channel(&self) -> bool {
        self.channel.is_some()
    }

    pub fn want_client(&self) -> bool {
        self.client.is_some()
    }

    pub fn channel(&self, connection: &mut Telnet) -> Result<Option<ResponseChannel>, String> {
        if let Some(channel) = &self.channel {
            wrappers::find_channel(connection, channel, self.strict_channel)
        } else {
            Err("No channel specified.".to_string())
        }
    }
    pub fn client(&self, connection: &mut Telnet) -> Result<Option<ResponseClient>, String> {
        if let Some(client) = &self.client {
            wrappers::find_client(connection, client, self.strict_client)
        } else {
            Err("No client specified.".to_string())
        }
    }
}

impl MessageArgs {
    pub fn target(&self, connection: &mut Telnet) -> Result<SendTextMessageTarget, String> {
        if self.server {
            Ok(SendTextMessageTarget::Server)
        } else if let Some(client) = &self.client {
            if let Some(client) = wrappers::find_client(connection, client, self.strict_client)? {
                return Ok(SendTextMessageTarget::Client(client.cid));
            }
            return Err("Could not find client.".to_string());
        } else {
            Ok(SendTextMessageTarget::Channel)
        }
    }
}

impl MoveArgs {
    pub fn channel(&self, connection: &mut Telnet) -> Result<Option<ResponseChannel>, String> {
        wrappers::find_channel(connection, &self.channel, self.strict_channel)
    }
    pub fn client(&self, connection: &mut Telnet) -> Result<Option<ResponseClient>, String> {
        match &self.client {
            Some(client) => {
                wrappers::find_client(connection, client, self.strict_client)
            }
            None => {
                match wrappers::find_self(connection) {
                    Ok(client) => Ok(Some(client)),
                    Err(msg) => Err(msg)
                }
            }
        }
    }
}

impl UpdateArgs {
    pub fn to_parameter_list(&self) -> ParameterList {
        let mut params: ParameterList = Vec::new();

        if let Some(name) = &self.name {
            params.push(Parameter::new("client_nickname", name));
        }

        if let Some(away) = &self.away {
            params.push(Parameter::new("client_away_message", away));
            params.push(Parameter::new("client_away", "1"));
        }
        if self.back {
            params.push(Parameter::new("client_away", "0"));
        }

        if let Some(microphone) = self.microphone {
            params.push(Parameter::new("client_input_muted", &u8::from(!microphone).to_string()));
        }
        if let Some(speakers) = self.speakers {
            params.push(Parameter::new("client_output_muted", &u8::from(!speakers).to_string()));
        }

        params
    }
}

pub fn init() -> Commands {
    Cli::parse().command
}