/macos/plac/ServerDiscoveryScene.swift at ca23543aacec9e1c7d72960c62508b81ace972c5

// 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 PlacKit
import SwiftUI
import os

struct ServerDiscovery: View {
	@State private var servers: [CoreServer] = []
	@State private var status: ServerDiscoverySceneListStatus = .loading

	private let logger = Logger()
	private let queue = DispatchQueue(label: "plac.server-discovery")

	var body: some View {
		ServerDiscoverySceneList(
			servers: servers,
			status: status,
			onScan: {
				scan()
			}
		)
		.onAppear {
			scan()
		}
	}

	private func scan() {
		status = .loading

		queue.async {
			let ptr = PlacKit.plac_discovery_scan()
			guard let ptr = ptr else {
				logger.error("Failed to scan servers: Out of memory")
				DispatchQueue.main.async {
					status = .null_pointer
				}
				return
			}

			let result = ScanResult(ptr: ptr)

			if result.code != PlacKit.PLAC_DISCOVERY_SCAN_RESULT_OK {
				DispatchQueue.main.async {
					status = .failed(result.code)
				}
				return
			}

			DispatchQueue.main.async {
				status = .loaded
				servers = result.entries
			}
		}
	}
}

enum ServerDiscoverySceneListStatus {
	case loading
	case loaded
	case failed(PlacKit.plac_discovery_scan_result_code)
	case null_pointer
}

struct ServerDiscoverySceneList<TServer: Server & Identifiable>: View {
	@Environment(\.openWindow) private var openWindow
	@Environment(\.dismissWindow) private var dismissWindow

	var servers: [TServer]
	var status: ServerDiscoverySceneListStatus

	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: TServer) in
				NavigationLink {
					VStack(alignment: .leading, spacing: lineSpace) {
						HStack {
							Text(server.name)
								.font(.title)

							Spacer()

							Button {
								openWindow(id: "main-window", value: server.id)
								dismissWindow(id: "discovery-window")
							} label: {
								Text("Open")
							}
							.buttonStyle(.borderedProminent)
						}

						VStack(alignment: .leading) {
							Text("Version")
								.font(.headline)

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

						VStack(alignment: .leading) {
							Text("IP address")
								.font(.headline)

							// TODO: Display IP address
							Text(server.id)
								.font(.subheadline)
						}

						Spacer()
					}
					.padding()
				} label: {
					Text(server.name)
				}
			}
			.navigationTitle("Servers")
			.toolbar {
				ToolbarItem(placement: .navigation) {
					Button {
						if let onScan = onScan {
							onScan()
						}
					} label: {
						Label("Reload", systemImage: "arrow.trianglehead.clockwise")
					}
					.help("Reload server list")
					.disabled(busy)
				}
			}
		} detail: {
			switch status {
			case .loading:
				ContentUnavailableView {
					Label("Scanning", systemImage: "waveform.badge.magnifyingglass")
						.symbolEffect(.variableColor)
				} description: {
					Text("Scanning Roon servers on local network.")
				}
			case .loaded:
				if servers.isEmpty {
					ContentUnavailableView {
						Label("No servers", systemImage: "square.dashed")
					} description: {
						Text("No Roon server found on local network.")
					}
				} else {
					Text("Select a server from list")
				}
			case .null_pointer:
				ContentUnavailableView {
					Label(
						"Unable to scan",
						systemImage: "exclamationmark.magnifyingglass"
					)
				} description: {
					Text("Failed to allocate memory for scan operation.")
				}
			case .failed(let code):
				switch code {
				case PlacKit.PLAC_DISCOVERY_SCAN_RESULT_SOCKET_ERROR:
					ContentUnavailableView {
						Label(
							"Unable to scan",
							systemImage: "wifi.exclamationmark"
						)
					} description: {
						Text("Failed to scan Roon servers due to network error.")
					}
				case PlacKit.PLAC_DISCOVERY_SCAN_RESULT_NETWORK_UNAVAILABLE:
					ContentUnavailableView {
						Label(
							"Network unavailable",
							systemImage: "wifi.exclamationmark"
						)
					} description: {
						Text("Network access is required for scanning Roon servers.")
					}
				case PlacKit.PLAC_DISCOVERY_SCAN_RESULT_UNKNOWN:
					ContentUnavailableView {
						Label(
							"Unable to scan",
							systemImage: "exclamationmark.magnifyingglass"
						)
					} description: {
						Text("An error occurred during a scan operation.")
					}
				case PlacKit.PLAC_DISCOVERY_SCAN_RESULT_OUT_OF_MEMORY:
					ContentUnavailableView {
						Label(
							"Unable to scan",
							systemImage: "exclamationmark.magnifyingglass"
						)
					} description: {
						Text("Failed to allocate memory for scan operation.")
					}
				case PlacKit.PLAC_DISCOVERY_SCAN_RESULT_SOCKET_PERMISSION_DENIED:
					ContentUnavailableView {
						Label(
							"Unable to access network",
							systemImage: "wifi.exclamationmark"
						)
					} description: {
						Text("Access to local network rejected.")
					}
				default:
					ContentUnavailableView {
						Label(
							"Unable to scan",
							systemImage: "exclamationmark.magnifyingglass"
						)
					} description: {
						Text("Unexpected error happened (platform misbehaving).")
					}
				}
			}
		}
	}
}

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

	let servers: [MockServer] = [
		MockServer(id: "foo", name: "Foo", version: "foo-0.0"),
		MockServer(id: "bar", name: "Bar", version: "bar-0.0"),
		MockServer(id: "baz", name: "Baz", version: "baz-0.0"),
	]

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

#Preview("Loading") {
	ServerDiscoverySceneList<MockServer>(servers: [], status: .loading)
}

#Preview("OOM") {
	ServerDiscoverySceneList<MockServer>(servers: [], status: .null_pointer)
}

#Preview("SocketError") {
	ServerDiscoverySceneList<MockServer>(
		servers: [],
		status: .failed(PlacKit.PLAC_DISCOVERY_SCAN_RESULT_SOCKET_ERROR)
	)
}
#Preview("NetworkUnavailable") {
	ServerDiscoverySceneList<MockServer>(
		servers: [],
		status: .failed(PlacKit.PLAC_DISCOVERY_SCAN_RESULT_NETWORK_UNAVAILABLE)
	)
}