/Plac/Views/ServerDiscoveryScreen.swift at 2f4ebd8e33083eac300a36200be0599de83e29ba

// 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 ServerDiscoveryScreen: View {
	@State private var servers: [RoonKit.Server] = []
	@State private var status: DiscoveryStatus = .loading

	var onConnectAction: ((RoonKit.Server) -> Void)?

	private let logger = Logger()

	var body: some View {
		PureView(
			servers: servers,
			status: status,
			onScan: {
				Task {
					await scan()
				}
			}
		)
		.onConnect { server in
			onConnectAction?(server)
		}
		.task {
			await scan()
		}
	}

	private func scan() async {
		status = .loading

		do {
			servers = try await RoonKit.Server.list()
			status = .loaded
		} catch {
			status = .failed(error)
		}
	}
}

extension ServerDiscoveryScreen {
	func onConnect(_ handler: @escaping (RoonKit.Server) -> Void)
		-> ServerDiscoveryScreen
	{
		var new = self
		new.onConnectAction = handler
		return new
	}
}

private enum DiscoveryStatus {
	case loading
	case loaded
	case failed(any Error)
}

private struct PureView: View {
	var servers: [RoonKit.Server]
	var status: DiscoveryStatus

	var onConnectAction: ((RoonKit.Server) -> Void)?
	var onScan: (() -> Void)? = nil

	@ScaledMetric private var lineSpace = 12

	private var busy: Bool {
		switch status {
		case .loading:
			true
		default:
			false
		}
	}

	var body: some View {
		NavigationSplitView {
			List(servers) { server in
				NavigationLink {
					VStack(alignment: .leading, spacing: lineSpace) {
						HStack {
							Text(server.name)
								.font(.title)

							Spacer()

							Button {
								onConnectAction?(server)
							} label: {
								Text(
									String(
										localized:
											"ServerDiscovery.Open",
										defaultValue:
											"Open",
										comment:
											"Label for a button that starts a connection."
									)
								)
							}
							.buttonStyle(.borderedProminent)
						}

						VStack(alignment: .leading) {
							Text(
								String(
									localized:
										"ServerDiscovery.Version",
									defaultValue: "Version",
									comment:
										"A label for server version field."
								)
							)
							.font(.headline)

							Text(server.version)
								.font(.subheadline)
						}

						VStack(alignment: .leading) {
							Text(
								String(
									localized:
										"ServerDiscovery.Host",
									defaultValue: "IP Address",
									comment:
										"A label for server host field."
								)
							)
							.font(.headline)

							Text(
								verbatim:
									"\(server.host):\(String(server.port, radix: 10))"
							)
							.font(.subheadline)
						}

						Spacer()
					}
					.padding()
				} label: {
					Text(server.name)
				}
			}
			.navigationTitle(
				Text(
					String(
						localized: "ServerDiscovery.Title",
						defaultValue: "Servers",
						comment:
							"Title of server discovery scene. Not visible on macOS."
					)
				)
			)
			.toolbar {
				ToolbarItem(placement: .navigation) {
					Button {
						if let onScan = onScan {
							onScan()
						}
					} label: {
						Label {
							Text(
								String(
									localized:
										"ServerDiscovery.Refresh",
									defaultValue: "Refresh",
									comment:
										"Icon label for refresh button."
								)
							)
						} icon: {
							Image(
								systemName:
									"arrow.trianglehead.clockwise"
							)
						}
					}
					.help(
						Text(
							String(
								localized:
									"ServerDiscovery.RefreshHelp",
								defaultValue: "Refresh server list",
								comment:
									"Help tooltip text for refresh button."
							)
						)
					)
					.disabled(busy)
				}
			}
		} detail: {
			switch status {
			case .loading:
				ContentUnavailableView {
					Label {
						Text(
							String(
								localized:
									"ServerDiscovery.Loading.Heading",
								defaultValue: "Scanning"
							)
						)
					} icon: {
						Image(systemName: "waveform.badge.magnifyingglass")
					}
					.symbolEffect(.variableColor)
				} description: {
					Text(
						String(
							localized:
								"ServerDiscovery.Loading.Description",
							defaultValue:
								"Scanning Roon servers on local network."
						)
					)
				}
			case .loaded:
				if servers.isEmpty {
					ContentUnavailableView {
						Label {
							Text(
								String(
									localized:
										"ServerDiscovery.Empty.Heading",
									defaultValue:
										"No server found"
								)
							)
						} icon: {
							Image(systemName: "square.dashed")
						}
					} description: {
						Text(
							String(
								localized:
									"ServerDiscovery.Empty.Description",
								defaultValue:
									"No Roon server found on local network."
							)
						)
					}
				} else {
					Text(
						String(
							localized: "ServerDiscovery.Placeholder",
							defaultValue: "Select server from list",
							comment:
								"Placeholder text for server details view."
						)
					)
				}
			case .failed(let error):
				switch error {
				case RoonKit.ServerLookupError.socketError(_),
					RoonKit.ServerLookupError.connectionClosed:
					ContentUnavailableView {
						Label {
							Text(
								String(
									localized:
										"ServerDiscovery.NetworkError.Heading",
									defaultValue: "Scan failed"
								)
							)
						} icon: {
							Image(systemName: "wifi.exclamationmark")
						}
					} description: {
						Text(
							String(
								localized:
									"ServerDiscovery.NetworkError.Description",
								defaultValue:
									"Failed to scan Roon servers due to network error."
							)
						)
					}
				default:
					ContentUnavailableView {
						Label {
							Text(
								String(
									localized:
										"ServerDiscovery.Error.Heading",
									defaultValue: "Scan failed"
								)
							)
						} icon: {
							Image(
								systemName:
									"exclamationmark.magnifyingglass"
							)
						}
					} description: {
						Text(
							String(
								localized:
									"ServerDiscovery.Error.Description",
								defaultValue:
									"An error occurred during a scan."
							)
						)
					}
				}
			}
		}
	}
}

extension PureView {
	func onConnect(_ handler: @escaping (RoonKit.Server) -> Void)
		-> PureView
	{
		var new = self
		new.onConnectAction = handler
		return new
	}
}

// MARK: - Preview

#Preview("Loaded") {
	let logger = Logger()

	let servers: [RoonKit.Server] = [
		.init(
			id: "foo",
			name: "Foo",
			version: "foo-0.0",
			host: "192.0.2.10",
			port: 9003
		),
		.init(
			id: "bar",
			name: "Bar",
			version: "bar-0.0",
			host: "198.51.100.8",
			port: 9003
		),
		.init(
			id: "baz",
			name: "Baz",
			version: "baz-0.0",
			host: "203.0.113.100",
			port: 8000
		),
	]

	PureView(servers: servers, status: .loaded)
		.refreshable {
			logger.debug("ServerDiscoverySceneList.refreshable")
		}
}
#Preview("No servers") {
	PureView(servers: [], status: .loaded)
}

#Preview("Loading") {
	PureView(servers: [], status: .loading)
}

#Preview("SocketError") {
	PureView(
		servers: [],
		status: .failed(
			RoonKit.ServerLookupError.socketError(
				RoonKit.SocketError.failedToGetDescriptor
			)
		)
	)
}

private enum MockUnknownError: Error {
	case doNotUseThisInApplicationCode
}

#Preview("Unknown error") {
	PureView(
		servers: [],
		status: .failed(MockUnknownError.doNotUseThisInApplicationCode)
	)
}