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