1use std::io::IsTerminal;
2
3use sonos_sdk::{SeekTarget, SonosSystem};
4
5use super::{
6 format_duration_human, format_time_ms, parse_duration, playback_icon, playback_label,
7 require_speaker_only, resolve_group, resolve_speaker, validate_seek_time, Commands,
8 GlobalFlags, OnOff, QueueAction,
9};
10use crate::config::Config;
11use crate::diagnostics;
12use crate::errors::CliError;
13
14pub fn run_command(
15 cmd: Commands,
16 system: &SonosSystem,
17 config: &Config,
18 global: &GlobalFlags,
19) -> Result<String, CliError> {
20 let spk = || resolve_speaker(system, config, global);
21
22 match cmd {
23 Commands::Speakers => cmd_speakers(system),
24 Commands::Groups => cmd_groups(system),
25 Commands::Status => cmd_status(system, config, global),
26 Commands::Join => cmd_join(system, config, global),
27 Commands::Leave => cmd_leave(system, config, global),
28 Commands::Bass { level } => cmd_bass(system, config, global, level),
29 Commands::Treble { level } => cmd_treble(system, config, global, level),
30 Commands::Loudness { state } => cmd_loudness(system, config, global, state),
31 Commands::Sleep { duration } => cmd_sleep(system, config, global, &duration),
32 Commands::Queue { action } => cmd_queue(system, config, global, action),
33 Commands::Config { .. } => unreachable!("config commands dispatched before discovery"),
34
35 Commands::Play => {
36 let s = spk()?;
37 s.play()?;
38 Ok(format!("Playing ({})", s.name))
39 }
40 Commands::Pause => {
41 let s = spk()?;
42 s.pause()?;
43 Ok(format!("Paused ({})", s.name))
44 }
45 Commands::Stop => {
46 let s = spk()?;
47 s.stop()?;
48 Ok(format!("Stopped ({})", s.name))
49 }
50 Commands::Next => {
51 let s = spk()?;
52 s.next()?;
53 Ok(format!("Next track ({})", s.name))
54 }
55 Commands::Previous => {
56 let s = spk()?;
57 s.previous()?;
58 Ok(format!("Previous track ({})", s.name))
59 }
60 Commands::Seek { position } => {
61 validate_seek_time(&position)?;
62 let s = spk()?;
63 s.seek(SeekTarget::Time(position.clone()))?;
64 Ok(format!("Seeked to {} ({})", position, s.name))
65 }
66 Commands::Mode { mode } => {
67 let s = spk()?;
68 s.set_play_mode(mode.to_sdk())?;
69 Ok(format!("Mode set to {:?} ({})", mode, s.name))
70 }
71 Commands::Volume { level } => cmd_volume(system, config, global, level),
72 Commands::Mute => cmd_mute(system, config, global, true),
73 Commands::Unmute => cmd_mute(system, config, global, false),
74 }
75}
76
77fn cmd_speakers(system: &SonosSystem) -> Result<String, CliError> {
80 let speakers = system.speakers();
81 if speakers.is_empty() {
82 eprintln!("{}", diagnostics::discovery_hint());
83 return Ok("No speakers found".to_string());
84 }
85 let lines: Vec<String> = speakers
86 .iter()
87 .map(|s| {
88 let state = s.playback_state.fetch().ok();
89 let vol = s.volume.fetch().ok();
90 let group_name = s
91 .group()
92 .and_then(|g| g.coordinator().map(|c| c.name))
93 .unwrap_or_default();
94
95 let state_str = state
96 .as_ref()
97 .map(|st| format!("{} {}", playback_icon(st), playback_label(st)))
98 .unwrap_or_default();
99 let vol_str = vol.map(|v| format!("vol:{}", v.0)).unwrap_or_default();
100
101 let mut parts = vec![s.name.clone()];
102 if !state_str.is_empty() {
103 parts.push(state_str);
104 }
105 if !vol_str.is_empty() {
106 parts.push(vol_str);
107 }
108 if !group_name.is_empty() {
109 parts.push(format!("({group_name})"));
110 }
111 parts.join(" ")
112 })
113 .collect();
114 Ok(lines.join("\n"))
115}
116
117fn cmd_groups(system: &SonosSystem) -> Result<String, CliError> {
118 let groups = system.groups();
119 if groups.is_empty() {
120 eprintln!("{}", diagnostics::discovery_hint());
121 return Ok("No groups found".to_string());
122 }
123 let lines: Vec<String> = groups
124 .iter()
125 .map(|g| {
126 let coord = g.coordinator();
127 let coord_name = coord
128 .as_ref()
129 .map(|c| c.name.clone())
130 .unwrap_or_else(|| "unknown".to_string());
131
132 let state = coord.as_ref().and_then(|c| c.playback_state.fetch().ok());
133 let track = coord.as_ref().and_then(|c| c.current_track.fetch().ok());
134 let vol = g.volume.fetch().ok();
135
136 let state_str = state
137 .as_ref()
138 .map(|st| format!("{} {}", playback_icon(st), playback_label(st)))
139 .unwrap_or_default();
140 let track_str = track
141 .as_ref()
142 .map(|t| {
143 let d = t.display();
144 if d == "Unknown" {
145 t.uri
146 .as_deref()
147 .filter(|u| !u.is_empty() && !u.starts_with("x-rincon:"))
148 .map(|_| "Playing (no metadata)".to_string())
149 .unwrap_or(d)
150 } else {
151 d
152 }
153 })
154 .unwrap_or_default();
155 let vol_str = vol.map(|v| format!("vol:{}", v.0)).unwrap_or_default();
156
157 let mut parts = vec![coord_name];
158 if !state_str.is_empty() {
159 parts.push(state_str);
160 }
161 if !track_str.is_empty() {
162 parts.push(track_str);
163 }
164 if !vol_str.is_empty() {
165 parts.push(vol_str);
166 }
167 parts.join(" ")
168 })
169 .collect();
170 Ok(lines.join("\n"))
171}
172
173fn cmd_volume(
174 system: &SonosSystem,
175 config: &Config,
176 global: &GlobalFlags,
177 level: u8,
178) -> Result<String, CliError> {
179 if global.speaker.is_some() && global.group.is_none() {
181 let s = resolve_speaker(system, config, global)?;
182 s.set_volume(level)?;
183 return Ok(format!("Volume set to {} ({})", level, s.name));
184 }
185 let g = resolve_group(system, config, global)?;
187 let name = g
188 .coordinator()
189 .map(|c| c.name)
190 .unwrap_or_else(|| "unknown".to_string());
191 g.set_volume(level as u16)?;
192 Ok(format!("Volume set to {level} ({name})"))
193}
194
195fn cmd_mute(
196 system: &SonosSystem,
197 config: &Config,
198 global: &GlobalFlags,
199 muted: bool,
200) -> Result<String, CliError> {
201 let label = if muted { "Muted" } else { "Unmuted" };
202 if global.speaker.is_some() && global.group.is_none() {
204 let s = resolve_speaker(system, config, global)?;
205 s.set_mute(muted)?;
206 return Ok(format!("{} ({})", label, s.name));
207 }
208 let g = resolve_group(system, config, global)?;
210 let name = g
211 .coordinator()
212 .map(|c| c.name)
213 .unwrap_or_else(|| "unknown".to_string());
214 g.set_mute(muted)?;
215 Ok(format!("{label} ({name})"))
216}
217
218fn cmd_status(
219 system: &SonosSystem,
220 config: &Config,
221 global: &GlobalFlags,
222) -> Result<String, CliError> {
223 let spk = resolve_speaker(system, config, global)?;
224 let state = spk.playback_state.fetch().ok();
225 let track = spk.current_track.fetch().ok();
226 let pos = spk.position.fetch().ok();
227 let vol = spk.volume.fetch().ok();
228
229 let state_str = state
230 .as_ref()
231 .map(|st| format!("{} {}", playback_icon(st), playback_label(st)))
232 .unwrap_or_else(|| "unknown".to_string());
233 let track_str = track
234 .as_ref()
235 .map(|t| {
236 let d = t.display();
237 if d == "Unknown" {
238 t.uri
239 .as_deref()
240 .filter(|u| !u.is_empty() && !u.starts_with("x-rincon:"))
241 .map(|_| "Playing (no metadata)".to_string())
242 .unwrap_or(d)
243 } else {
244 d
245 }
246 })
247 .unwrap_or_default();
248 let pos_str = pos
249 .as_ref()
250 .map(|p| {
251 format!(
252 "{}/{}",
253 format_time_ms(p.position_ms),
254 format_time_ms(p.duration_ms)
255 )
256 })
257 .unwrap_or_default();
258 let vol_str = vol.map(|v| format!("vol:{}", v.0)).unwrap_or_default();
259
260 let mut parts = vec![spk.name.clone(), state_str];
261 if !track_str.is_empty() {
262 parts.push(track_str);
263 }
264 if !pos_str.is_empty() {
265 parts.push(pos_str);
266 }
267 if !vol_str.is_empty() {
268 parts.push(vol_str);
269 }
270 Ok(parts.join(" "))
271}
272
273fn cmd_join(
274 system: &SonosSystem,
275 config: &Config,
276 global: &GlobalFlags,
277) -> Result<String, CliError> {
278 let raw_speaker = global
279 .speaker
280 .as_deref()
281 .ok_or_else(|| CliError::Validation("--speaker is required for join".into()))?;
282 let raw_group = global
283 .group
284 .as_deref()
285 .ok_or_else(|| CliError::Validation("--group is required for join".into()))?;
286 let speaker_name = config.resolve_alias(raw_speaker);
287 let group_name = config.resolve_alias(raw_group);
288 let spk = system
289 .speaker(speaker_name)
290 .ok_or_else(|| CliError::SpeakerNotFound(speaker_name.into()))?;
291 let grp = system
292 .group(group_name)
293 .ok_or_else(|| CliError::GroupNotFound(group_name.into()))?;
294 grp.add_speaker(&spk)?;
295 Ok(format!("{speaker_name} joined {group_name}"))
296}
297
298fn cmd_leave(
299 system: &SonosSystem,
300 config: &Config,
301 global: &GlobalFlags,
302) -> Result<String, CliError> {
303 let raw_speaker = global
304 .speaker
305 .as_deref()
306 .ok_or_else(|| CliError::Validation("--speaker is required for leave".into()))?;
307 let speaker_name = config.resolve_alias(raw_speaker);
308 let spk = system
309 .speaker(speaker_name)
310 .ok_or_else(|| CliError::SpeakerNotFound(speaker_name.into()))?;
311 let group_name = spk
312 .group()
313 .and_then(|g| g.coordinator().map(|c| c.name))
314 .unwrap_or_else(|| "its group".into());
315 spk.leave_group()?;
316 Ok(format!("{speaker_name} left {group_name}"))
317}
318
319fn cmd_bass(
320 system: &SonosSystem,
321 config: &Config,
322 global: &GlobalFlags,
323 level: i8,
324) -> Result<String, CliError> {
325 let spk = require_speaker_only(system, config, global, "bass")?;
326 spk.set_bass(level)?;
327 Ok(format!("Bass set to {} ({})", level, spk.name))
328}
329
330fn cmd_treble(
331 system: &SonosSystem,
332 config: &Config,
333 global: &GlobalFlags,
334 level: i8,
335) -> Result<String, CliError> {
336 let spk = require_speaker_only(system, config, global, "treble")?;
337 spk.set_treble(level)?;
338 Ok(format!("Treble set to {} ({})", level, spk.name))
339}
340
341fn cmd_loudness(
342 system: &SonosSystem,
343 config: &Config,
344 global: &GlobalFlags,
345 state: OnOff,
346) -> Result<String, CliError> {
347 let spk = require_speaker_only(system, config, global, "loudness")?;
348 let enabled = matches!(state, OnOff::On);
349 spk.set_loudness(enabled)?;
350 if enabled {
351 Ok(format!("Loudness enabled ({})", spk.name))
352 } else {
353 Ok(format!("Loudness disabled ({})", spk.name))
354 }
355}
356
357fn cmd_sleep(
358 system: &SonosSystem,
359 config: &Config,
360 global: &GlobalFlags,
361 duration: &str,
362) -> Result<String, CliError> {
363 let spk = resolve_speaker(system, config, global)?;
364 if duration == "cancel" {
365 spk.cancel_sleep_timer()?;
366 Ok(format!("Sleep timer cancelled ({})", spk.name))
367 } else {
368 let hh_mm_ss = parse_duration(duration)?;
369 let human = format_duration_human(duration);
370 spk.configure_sleep_timer(&hh_mm_ss)?;
371 Ok(format!("Sleep timer set for {} ({})", human, spk.name))
372 }
373}
374
375fn cmd_queue(
376 system: &SonosSystem,
377 config: &Config,
378 global: &GlobalFlags,
379 action: Option<QueueAction>,
380) -> Result<String, CliError> {
381 let spk = resolve_speaker(system, config, global)?;
382 match action {
383 None => {
384 let info = spk.get_media_info()?;
385 if info.nr_tracks == 0 {
386 return Ok(format!("queue is empty ({})", spk.name));
387 }
388 Ok(format!("{} — {} tracks", spk.name, info.nr_tracks))
389 }
390 Some(QueueAction::Add { uri }) => {
391 spk.add_uri_to_queue(&uri, "", 0, false)?;
392 Ok(format!("Added to queue ({})", spk.name))
393 }
394 Some(QueueAction::Clear) => {
395 if std::io::stdin().is_terminal() && !global.no_input {
396 eprint!("Clear queue for {}? [y/N] ", spk.name);
397 let mut input = String::new();
398 std::io::stdin()
399 .read_line(&mut input)
400 .map_err(|e| CliError::Validation(e.to_string()))?;
401 if !input.trim().eq_ignore_ascii_case("y") {
402 return Ok("Cancelled".into());
403 }
404 }
405 spk.remove_all_tracks_from_queue()?;
406 Ok(format!("Queue cleared ({})", spk.name))
407 }
408 }
409}