/macos/plac/MainView.swift at 065d06d63f822a0c917351982567be33e10c1f0a

// 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(CoreServer)
	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

	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 server):
				ConnectedView(server: server)
			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 = PlacKit.plac_discovery_find(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 {
						state = .found(result.entries[0])
					}
				}
			}
		}
	}
}

struct ConnectedView: View {
	private var conn: Connection

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

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

	var body: some View {
		PureConnectedView(zone_id: $zone_id, zones: zones)
			.onAppear {
				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(_):
							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
						}
					}
				}
			}
	}

	init(server: CoreServer) {
		conn = Connection(server: server)
	}
}

struct PureConnectedView<TZone: Zone & Identifiable>: View {
	@Binding var zone_id: String?

	var zones: [String: TZone] = [:]

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

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

			Divider()

			PlaybackBar<TZone>(zone_id: $zone_id, zones: zones)
				.frame(maxWidth: .infinity)
		}
	}
}

#Preview("Layout") {
	@Previewable @State var zone_id: String? = "foo"

	var zones: [String: MockZone] = [
		"foo": MockZone(
			id: "foo",
			name: "Foo",
			playback: PlacKit.PLAC_TRANSPORT_PLAYBACK_PLAYING
		),
		"bar": MockZone(
			id: "bar",
			name: "Bar",
			playback: PlacKit.PLAC_TRANSPORT_PLAYBACK_STOPPED
		),
	]

	PureConnectedView<MockZone>(zone_id: $zone_id, zones: zones)
}

struct PlaybackBar<TZone: Zone & Identifiable>: View {
	@Binding var zone_id: String?

	var zones: [String: TZone] = [:]

	private var zone: TZone? {
		zones.first(where: { _, zone in
			zone.id == zone_id
		})?.value
	}

	var body: some View {
		HStack {
			HStack {
				if zone?.playback == PlacKit.PLAC_TRANSPORT_PLAYBACK_PLAYING {
					Button {
					} label: {
						Label("Pause", systemImage: "pause.fill")
					}
				} else {
					Button {
					} label: {
						Label("Play", systemImage: "play.fill")
					}
				}
			}
			.labelStyle(.iconOnly)
			.buttonStyle(.borderless)
			.font(.system(size: 20))

			Spacer()

			if zones.count > 0 && zone_id != nil {
				Picker("Zone", selection: $zone_id) {
					ForEach(
						zones.values.sorted(by: {
							$0.id < $1.id
						})
					) { zone in
						Text(zone.name).tag(zone.id as String?)
					}
				}
				.scaledToFit()
			}
		}
		.padding([.horizontal], 10)
		.padding([.vertical], 8)
	}
}

#Preview("PlaybackBar") {
	@Previewable @State var zone_id: String? = "foo"

	var zones: [String: MockZone] = [
		"foo": MockZone(
			id: "foo",
			name: "Foo",
			playback: PlacKit.PLAC_TRANSPORT_PLAYBACK_PLAYING
		),
		"bar": MockZone(
			id: "bar",
			name: "Bar",
			playback: PlacKit.PLAC_TRANSPORT_PLAYBACK_STOPPED
		),
	]

	PlaybackBar(zone_id: $zone_id, zones: zones)
}