use clap::{CommandFactory, Parser};
use std::io::IsTerminal;
use std::process::ExitCode;
use sonos_sdk::{SdkError, SonosSystem};
mod cli;
mod config;
mod diagnostics;
mod errors;
mod logging;
mod tui;
use cli::{run_command, Cli, Commands, ConfigAction};
use config::Config;
fn main() -> ExitCode {
let cli = Cli::parse();
let mut config = Config::load();
let is_tui = cli.command.is_none() && std::io::stdout().is_terminal();
logging::init_logging(cli.global.verbose, is_tui);
if let Some(Commands::Config { action }) = &cli.command {
return handle_config_command(action.as_ref(), &mut config, &cli.global);
}
match cli.command {
None => {
if std::io::stdout().is_terminal() {
match tui::run(config) {
Ok(()) => ExitCode::SUCCESS,
Err(e) => {
eprintln!("error: {e}");
if format!("{e:?}").contains("DiscoveryFailed") {
eprintln!("{}", diagnostics::discovery_hint());
}
ExitCode::from(1)
}
}
} else {
eprintln!("error: no command specified and stdout is not a terminal");
ExitCode::from(1)
}
}
Some(cmd) => {
let system = match SonosSystem::new() {
Ok(s) => s,
Err(e) => {
tracing::debug!("{e:?}");
eprintln!("error: {e}");
if matches!(&e, SdkError::DiscoveryFailed(_)) {
eprintln!("{}", diagnostics::discovery_hint());
diagnostics::offer_open_settings(&cli.global);
} else {
eprintln!("Check that your speakers are on the same network, then retry.");
}
return ExitCode::from(1);
}
};
match run_command(cmd, &system, &config, &cli.global) {
Ok(msg) => {
if !cli.global.quiet {
println!("{msg}");
}
ExitCode::SUCCESS
}
Err(e) => {
tracing::debug!("{e:?}");
eprintln!("error: {e}");
if let Some(hint) = e.recovery_hint() {
eprintln!("{hint}");
}
e.exit_code()
}
}
}
}
}
fn handle_config_command(
action: Option<&ConfigAction>,
config: &mut Config,
global: &cli::GlobalFlags,
) -> ExitCode {
let result = match action {
None => {
let mut cmd = Cli::command();
let config_cmd = cmd.find_subcommand_mut("config").unwrap();
config_cmd.print_help().ok();
return ExitCode::from(2);
}
Some(ConfigAction::Alias { name, alias }) => match (name, alias) {
(None, _) => cmd_config_alias_list(config),
(Some(name), None) => cmd_config_alias_clear(config, name),
(Some(name), Some(alias)) => cmd_config_alias_set(config, name, alias),
},
};
match result {
Ok(msg) => {
if !global.quiet && !msg.is_empty() {
println!("{msg}");
}
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
e.exit_code()
}
}
}
fn cmd_config_alias_list(config: &Config) -> Result<String, errors::CliError> {
if config.aliases.is_empty() {
return Ok("No aliases configured".to_string());
}
let mut lines: Vec<String> = config
.aliases
.iter()
.map(|(name, alias)| format!("{alias} \u{2192} {name}"))
.collect();
lines.sort();
Ok(lines.join("\n"))
}
fn cmd_config_alias_set(
config: &mut Config,
name: &str,
alias: &str,
) -> Result<String, errors::CliError> {
if alias.is_empty() {
return Err(errors::CliError::Validation(
"alias must not be empty".to_string(),
));
}
if alias.contains(char::is_whitespace) {
return Err(errors::CliError::Validation(
"alias must not contain whitespace".to_string(),
));
}
for (existing_name, existing_alias) in &config.aliases {
if existing_alias == alias && existing_name != name {
return Err(errors::CliError::Validation(format!(
"alias \"{alias}\" is already used by \"{existing_name}\""
)));
}
}
config.set_alias(name, alias);
config
.save()
.map_err(|e| errors::CliError::Config(e.to_string()))?;
Ok(format!("Alias set: {alias} \u{2192} {name}"))
}
fn cmd_config_alias_clear(config: &mut Config, name: &str) -> Result<String, errors::CliError> {
match config.clear_alias(name) {
Some(old_alias) => {
config
.save()
.map_err(|e| errors::CliError::Config(e.to_string()))?;
Ok(format!("Alias cleared: {old_alias} \u{2192} {name}"))
}
None => Err(errors::CliError::Validation(format!(
"no alias configured for \"{name}\""
))),
}
}