/macos/plac/MainView.swift at a4dd6513116b7262a37feffe8f934c8a08881ade

// 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

enum MainViewState {
	case loading
	case found(Connection)
	case findError(PlacKit.plac_discovery_scan_result_code)
	case null_pointer
	case not_found
}

struct MainView: View {
	var serverId: CoreServer.ID?

	@State private var state: MainViewState = .loading

	@AppStorage("PlacApp.token") private var savedToken: String?
	@AppStorage("PlacApp.serverIp") private var serverIp: String?
	@AppStorage("PlacApp.serverPort") private var serverPort: Int?

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

	var body: some View {
		VStack {
			switch state {
			case .loading:
				ProgressView()
			case .found(let conn):
				ConnectedView(conn: conn)
					.onAuthorize { token in
						savedToken = token
					}
			case .findError(_):
				ContentUnavailableView {
					Label(
						"Server not found",
						systemImage: "exclamationmark.magnifyingglass"
					)
				} description: {
					// TODO: Tidy
					Text("Server not found")
				}
			case .not_found:
				ContentUnavailableView {
					Label(
						"Server not found",
						systemImage: "exclamationmark.magnifyingglass"
					)
				} description: {
					Text("Selected server does not found on local network.")
				}
			case .null_pointer:
				ContentUnavailableView {
					Label(
						"Unable to connect",
						systemImage: "exclamationmark.magnifyingglass"
					)
				} description: {
					Text(
						"Failed to retrieve server connection information. Out of memory."
					)
				}
			}
		}
		.onAppear {
			if let serverId = serverId {
				queue.async {
					let ptr = findServer(serverId)
					guard let ptr = ptr else {
						logger.error("Failed to scan servers: Out of memory")
						DispatchQueue.main.async {
							state = .null_pointer
						}
						return
					}

					let result = ScanResult(ptr: ptr)

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

					if result.entries.count < 1 {
						DispatchQueue.main.async {
							state = .not_found
						}
						return
					}

					DispatchQueue.main.async {
						let entry = result.entries[0]

						serverIp = entry.ipAddress
						serverPort = Int(entry.port)

						state = .found(
							Connection(server: entry, token: savedToken)
						)
					}
				}
			}
		}
	}

	func findServer(_ serverId: String) -> UnsafeMutablePointer<
		PlacKit.plac_discovery_scan_result
	>? {
		if let ip = serverIp, let port = serverPort {
			return PlacKit.plac_discovery_resolve(serverId, ip, UInt16(port))
		} else {
			return PlacKit.plac_discovery_find(serverId)
		}
	}
}

enum ConnectionState<TZone: Zone & Identifiable> {
	case authorizing
	case authorized(zone_id: String?, zones: [String: TZone])
}

struct ConnectedView: View {
	let conn: Connection

	@State private var zone_id: String? = nil
	@State private var zones: [String: CoreZone] = [:]

	private let queue = DispatchQueue(label: "plac.event-loop")

	var onAuthorizeAction: ((_ token: String) -> Void)?

	var body: some View {
		let state: Binding<ConnectionState<CoreZone>> = .init(
			get: {
				if let zone_id = zone_id {
					.authorized(zone_id: zone_id, zones: zones)
				} else {
					.authorizing
				}
			},

			set: {
				newValue in
				switch newValue {
				case .authorizing:
					zone_id = nil
				case .authorized(let newZoneId, _):
					zone_id = newZoneId
				}
			}
		)

		PureConnectedView(state: state)
			.onAppear {
				startLoop()
			}
			.focusedSceneValue(conn)
	}

	func startLoop() {
		queue.async {
			let logger = Logger()

			logger.debug("Starting getEvent loop...")

			while true {
				let event = conn.getEvent()

				guard let event = event else {
					logger.debug("Got null event, quitting")
					return
				}

				switch event {
				case .connected(let ev):
					onAuthorizeAction?(ev.token)
					conn.subscribeZoneChanges()
					break
				case .connectionError(let ev):
					logger.error("Failed to connect: \(ev.code.rawValue)")
					break
				case .zoneList(let ev):
					DispatchQueue.main.async {
						for zone in ev.addedZones {
							zones[zone.id] = zone
						}

						for zone in ev.changedZones {
							zones[zone.id] = zone
						}

						for id in ev.removedZoneIds {
							zones.removeValue(forKey: id)
							if zone_id == id {
								zone_id = nil
							}
						}

						if zone_id == nil {
							zone_id = zones.first?.value.id
						}
					}
					break
				}
			}
		}
	}
}

extension ConnectedView {
	func onAuthorize(_ handler: @escaping (String) -> Void) -> ConnectedView {
		var new = self
		new.onAuthorizeAction = handler
		return new
	}
}

struct PureConnectedView<TZone: Zone & Identifiable>: View {
	@Binding var state: ConnectionState<TZone>

	var body: some View {
		switch state {
		case .authorized(let zone_id, let zones):
			let zoneIdProxy: Binding<String?> = .init(
				get: { zone_id },
				set: { newId in state = .authorized(zone_id: newId, zones: zones) }
			)

			VStack(spacing: 0) {
				NavigationSplitView {
					List {
						NavigationLink {
							Text("LIBRARY")
						} label: {
							Text("Library")
						}

						NavigationLink {
							Text("DISCOVER")
						} label: {
							Text("Discover")
						}
					}
				} detail: {
				}

				Divider()

				PlaybackBar<TZone>(zone_id: zoneIdProxy, zones: zones)
					.frame(maxWidth: .infinity)
			}
		case .authorizing:
			ContentUnavailableView {
				Label(
					"Requesting Access",
					systemImage: "lock.circle.dotted"
				)
				.symbolEffect(.pulse)
			} description: {
				Text(
					"Connecting to your Roon Server. Enable access at \"Settings > Extensions\" in official Roon Client application."
				)
			}
		}
	}
}

#Preview("Layout") {
	@Previewable @State var state: ConnectionState<MockZone> = .authorized(
		zone_id: "foo",
		zones: [
			"foo": MockZone(
				id: "foo",
				name: "Foo",
				playback: PlacKit.PLAC_TRANSPORT_PLAYBACK_PLAYING,
				nowPlaying: MockNowPlaying(
					line1: "My great song",
					line2: "Some untrusted artist",
					seek: (5, 3 * 60 + 30)
				)
			),
			"bar": MockZone(
				id: "bar",
				name: "Bar",
				playback: PlacKit.PLAC_TRANSPORT_PLAYBACK_STOPPED
			),
		]
	)

	PureConnectedView<MockZone>(state: $state)
}

#Preview("Authorizing") {
	@Previewable @State var state: ConnectionState<MockZone> = .authorizing

	PureConnectedView<MockZone>(state: $state)
}