/macos/Plac/Views/ZoneOptionsPanel.swift at 67dfb52c23887f356d2889db0c7f4608a8622ea7

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

import OSLog
import RoonKit
import SwiftUI

struct ZoneOptionsPanel: View {
	private var model: ZoneDataModel

	init(model: ZoneDataModel) {
		self.model = model
	}

	var body: some View {
		@Bindable var model = model

		Form {
			Picker(selection: $model.zone) {
				ForEach(model.zones) { (zone: TransportService.Zone) in
					Text(zone.displayName).tag(zone)
				}
			} label: {
				Text(
					String(
						localized: "ZoneOptionsPanel.ZonePicker",
						defaultValue: "Zone"
					)
				)
			}

			if let zone = model.zone {
				ForEach(zone.outputs) { output in
					Section {
						OutputRow(output: output, model: model)
					} header: {
						Text(output.displayName)
					}
				}
			}
		}
		.formStyle(.grouped)
	}
}

private struct OutputRow: View {
	private let logger = Logger()

	private let output: TransportService.Output
	private let model: ZoneDataModel
	@State private var volume: Float64

	var body: some View {
		switch output.volume?.type {
		case .some("incremental"):
			Stepper(
				label: {
					Text(
						String(
							localized: "ZoneOptionsPanel.StepVolumeLabel",
							defaultValue: "Volume Control"
						)
					)
				},
				onIncrement: {
					Task {
						do {
							let res = try await model.conn.request(
								.init(
									changeVolume: .init(
										outputID: output.id,
										value: 1.0,
										mode: .relative
									)
								)
							)

							_ = try TransportService.ChangeVolumeResponse(res)
						} catch {
							logger.warning("Failed to increment volume: \(error)")
						}
					}
				},
				onDecrement: {
					Task {
						do {
							let res = try await model.conn.request(
								.init(
									changeVolume: .init(
										outputID: output.id,
										value: -1.0,
										mode: .relative
									)
								)
							)

							_ = try TransportService.ChangeVolumeResponse(res)
						} catch {
							logger.warning("Failed to decrement volume: \(error)")
						}
					}
				}
			)
		case .none:
			Text(
				String(
					localized: "ZoneOptionsPanel.NoVolumeControl",
					defaultValue: "This output does not support volume control."
				)
			)
		case .some(let type):
			let min = output.volume?.min ?? 0
			let max = output.volume?.max ?? 100
			let format = { (value: Float64) in
				switch type {
				case "db":
					String(format: "%1.fdB", value)
				default:
					String(format: "%.f%%", ((value - min) / max) * 100)
				}
			}

			VStack {
				Slider(
					value: $volume,
					in: .init(uncheckedBounds: (min, max)),
				) {
					Text(
						String(
							localized: "ZoneOptionsPanel.VolumeSlider",
							defaultValue: "Volume",
							comment: "A label for volume slider."
						)
					)
				} minimumValueLabel: {
					Text(format(min))
				} maximumValueLabel: {
					Text(format(max))
				} onEditingChanged: { editing in
					// Issue API request only when user stopped editing (e.g., lift a finger)
					guard editing == false else {
						return
					}

					Task {
						do {
							let res = try await model.conn.request(
								.init(
									changeVolume: .init(
										outputID: output.id,
										value: volume,
										mode: .absolute
									)
								)
							)

							_ = try TransportService.ChangeVolumeResponse(res)
						} catch {
							logger.warning("Failed to change volume: \(error)")
						}
					}
				}

				Text(format(volume))
			}
		}
	}

	init(output: TransportService.Output, model: ZoneDataModel) {
		self.model = model
		self.output = output
		self.volume = output.volume?.value ?? 0
	}
}

// MARK: - Previews

private actor MockServer: Communicatable {
	var messages: AsyncStream<Moo> {
		AsyncStream { stream in }
	}

	func request(_ msg: consuming Moo) async throws -> Moo {
		try await request(msg: msg, timeout: nil)
	}

	func request(_ msg: consuming Moo, timeout: ContinuousClock.Instant.Duration)
		async throws -> Moo
	{
		try await request(msg: msg, timeout: timeout)
	}

	fileprivate enum MockRequestError: Error {
		case unsupportedMessage
		case invalidRequest
	}

	private func request(
		msg: Moo,
		timeout: ContinuousClock.Instant.Duration? = nil
	) async throws -> Moo {
		switch msg.service {
		case "\(TransportService.id)/subscribe_zones":
			let body = """
				{
					"zones": [
						{
							"zone_id": "0-foo",
							"display_name": "Foo",
							"outputs": [
								{
									"output_id": "foo-out1",
									"display_name": "Foo Output #1",
									"volume": {
										"type": "number",
										"min": 0,
										"max": 100,
										"step": 1,
										"value": 50,
										"is_muted": false
									}
								},
								{
									"output_id": "foo-out2",
									"display_name": "Foo Output #2",
									"volume": {
										"type": "incremental"
									}
								},
								{
									"output_id": "foo-out3",
									"display_name": "Foo Output #3",
									"volume": {
										"type": "db",
										"min": 0,
										"max": 85,
										"step": 0.1,
										"value": 21,
										"is_muted": false
									}
								}
							],
							"now_playing": {
								"seek_position": 0,
								"length": 10,
								"one_line": {
									"line1": "A song"
								},
								"two_line": {
									"line1": "A song",
									"line2": "That's it"
								},
								"three_line": {
									"line1": "A song",
									"line2": "Really, that's it"
								}
							},
							"state": "playing",
							"is_previous_allowed": true,
							"is_next_allowed": false,
							"is_pause_allowed": true,
							"is_play_allowed": true,
							"is_seek_allowed": true
						},
						{
							"zone_id": "1-bar",
							"display_name": "Bar",
							"outputs": [],
							"state": "stopped"
						}
					]
				}
				"""

			return Moo(
				verb: "COMPLETE",
				service: "Subscribed",
				headers: [
					"Content-Type": "application/json",
					"Content-Length": String(body.utf8.count, radix: 10),
				],
				body: body.data(using: .utf8)!
			)
		case "\(TransportService.id)/change_volume":
			let res = try msg.json(type: TransportService.ChangeVolumeRequest.self)
			print(
				"Got change_volume request for \(res.outputID), with \(res.value) in \(res.mode)"
			)

			return Moo(verb: "COMPLETE", service: "Success")
		default:
			throw MockRequestError.unsupportedMessage
		}
	}

	func send(_ msg: consuming Moo) async throws {
		// No-op
	}
}

#Preview {
	let model = ZoneDataModel(conn: MockServer())

	Task {
		try? await model.watchChanges()
	}

	return ZoneOptionsPanel(model: model)
}