/macos/Plac/Views/ConnectedScreen.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 ConnectedScreen: View {
	private let logger = Logger()

	@Environment(ImageURLBuilderDataModel.self) var builder

	@State private var model: ZoneDataModel
	@State private var browsing: BrowsingDataModel

	@State private var hierarchies = [
		BrowseService.Hierarchy.browse,
		BrowseService.Hierarchy.playlists,
		BrowseService.Hierarchy.albums,
		BrowseService.Hierarchy.artists,
		BrowseService.Hierarchy.composers,
		BrowseService.Hierarchy.genres,
		BrowseService.Hierarchy.settings,
		BrowseService.Hierarchy.internetRadio,
	]

	init(conn: Communicatable & Connectable, host: String, port: UInt16) {
		let browsing = BrowsingDataModel(conn: conn)
		self.browsing = browsing

		model = ZoneDataModel(
			conn: conn,
			browsing: browsing,
			imageURLBuilder: ImageURLBuilderDataModel(host: host, port: port)
		)
	}

	private let actionQueue = DispatchQueue(
		label: "plac.ConnectedView.actionQueue"
	)

	var body: some View {
		let shouldDisplayMessage = Binding {
			return browsing.message != nil
		} set: { _ in
			browsing.message = nil
		}

		VStack(spacing: 0) {
			NavigationSplitView {
				List(hierarchies, id: \.self, selection: $browsing.hierarchy) {
					hierarchy in
					switch hierarchy {
					case .browse:
						Text(
							String(
								localized: "ConnectedScene.Category.Explore",
								defaultValue: "Explore"
							)
						)
					case .playlists:
						Text(
							String(
								localized: "ConnectedScene.Category.Playlists",
								defaultValue: "Playlists"
							)
						)
					case .settings:
						Text(
							String(
								localized: "ConnectedScene.Category.Settings",
								defaultValue: "Settings"
							)
						)
					case .albums:
						Text(
							String(
								localized: "ConnectedScene.Category.Albums",
								defaultValue: "Albums"
							)
						)
					case .artists:
						Text(
							String(
								localized: "ConnectedScene.Category.Artists",
								defaultValue: "Artists"
							)
						)
					case .genres:
						Text(
							String(
								localized: "ConnectedScene.Category.Genres",
								defaultValue: "Genres"
							)
						)
					case .composers:
						Text(
							String(
								localized: "ConnectedScene.Category.Composers",
								defaultValue: "Composers"
							)
						)
					case .search:
						Text(
							String(
								localized: "ConnectedScene.Category.Search",
								defaultValue: "Search"
							)
						)
					case .internetRadio:
						Text(
							String(
								localized: "ConnectedScene.Category.InternetRadio",
								defaultValue: "Internet Radios"
							)
						)
					}
				}
			} detail: {
				if browsing.hierarchy != nil {
					NavigationStack(path: $browsing.stack) {
						Browser(model: browsing)
							.navigationDestination(for: BrowseService.Item.self) { item in
								Browser(model: browsing, item: item)
							}
					}
				}
			}
			.alert(
				Text(
					String(
						localized: "ConnectedScene.ServerMessage.Title",
						defaultValue: "Message from Roon server"
					)
				),
				isPresented: shouldDisplayMessage,
				presenting: browsing.message
			) { _ in
				Button(
					String(
						localized: "ConnectedScene.ServerMessage.Dismiss",
						defaultValue: "Dismiss"
					)
				) {
					browsing.message = nil
				}
			} message: { message in
				Text(message)
			}

			Divider()

			PlaybackBar()
				.frame(maxWidth: .infinity)
				.environment(model)
		}
		.task {
			// macOS, iPadOS and visionOS renders `NavigationSplitView` with columns whereas
			// iOS renders stacked views. In columns layout, having no default selection or
			// placeholder content ("select a category") is not user-friendly.
			// In iPad, the situation got worse; it hides sidebar on startup in portrait
			// orientation, so user will see blank browsing area. Placeholder won't help
			// this case at all.
			#if os(macOS)
				let shouldHaveDefaultHierarchy = true
			#else
				let shouldHaveDefaultHierarchy =
					UIDevice.current.userInterfaceIdiom == .pad
					|| UIDevice.current.userInterfaceIdiom == .vision
			#endif

			if shouldHaveDefaultHierarchy {
				browsing.hierarchy = .browse
			}
		}
		.task {
			do {
				try await model.watchChanges()
			} catch {
				logger.error("Failed to watch zone changes: \(error)")
			}
		}
	}
}

// MARK: - Preview

private enum MockError: Error {
	case notImplementedInMock
}

private struct MockPage {
	let browse: String
	let load: String

	func browseMsg() throws -> Moo {
		let bytes = browse.data(using: .utf8)!

		return Moo(
			verb: "COMPLETE",
			service: "Success",
			headers: [
				"Content-Type": "application/json",
				"Content-Length": String(bytes.count, radix: 10),
			],
			body: bytes,
		)
	}

	func loadMsg() throws -> Moo {
		let bytes = load.data(using: .utf8)!

		return Moo(
			verb: "COMPLETE",
			service: "Success",
			headers: [
				"Content-Type": "application/json",
				"Content-Length": String(bytes.count, radix: 10),
			],
			body: bytes,
		)
	}
}

private actor MockServer {
	var stack: [MockPage] = []
}

extension MockServer: Communicatable {
	var root: MockPage {
		.init(
			browse: """
					{
						"action": "list",
						"list": {
							"title": "Mock Page",
							"subtitle": "Various responses",
							"level": 0
						}
					}
				""",
			load: """
					{
						"list": {
							"title": "Mock Page",
							"subtitle": "Various responses",
							"level": 0
						},
						"items": [
							{
								"title": "List",
								"item_key": "mock-list",
								"hint": "list"
							},
							{
								"title": "Slow List",
								"item_key": "mock-slow-list",
								"hint": "list"
							},
							{
								"title": "Action List",
								"item_key": "mock-action_list",
								"hint": "action_list"
							},
							{
								"title": "Action",
								"item_key": "mock-action",
								"hint": "action"
							},
							{
								"title": "Header",
								"item_key": "mock-header",
								"hint": "header"
							},
							{
								"title": "Unknown",
								"item_key": "mock-unknown"
							}
						]
					}
				"""
		)
	}

	var rootAction: MockPage {
		.init(
			browse: """
					{
						"action": "list",
						"list": {
							"title": "Mock Page",
							"subtitle": "Various responses",
							"level": 0
						},
						"message": "You performed an action."
					}
				""",
			load: root.load
		)
	}

	var list: MockPage {
		.init(
			browse: """
					{
						"action": "list",
						"list": {
							"title": "List",
							"level": 1
						}
					}
				""",
			load: """
					{
						"list": {
							"title": "List",
							"subtitle": "Various responses",
							"level": 1
						},
						"items": [
							{
								"title": "Action",
								"item_key": "mock-list-action",
								"hint": "action"
							},
							{
								"title": "Item 1",
								"subtitle": "This is 1st item",
								"item_key": "mock-list-item1",
								"hint": "action_list"
							},
							{
								"title": "Item 2",
								"subtitle": "This is 2nd item",
								"item_key": "mock-list-item2",
								"hint": "action_list"
							},
							{
								"title": "Item 3",
								"subtitle": "This is 3rd item",
								"item_key": "mock-list-item3",
								"hint": "action_list"
							},
							{
								"title": "Item 4",
								"subtitle": "This is 4th item",
								"item_key": "mock-list-item4",
								"hint": "action_list"
							}
						]
					}
				"""
		)
	}

	var messages: AsyncStream<Moo> {
		AsyncStream { stream in
			stream.finish()
		}
	}

	enum RequestError: Error {
		case noBody
		case notImplemented
	}

	func request(_ msg: consuming Moo) async throws -> Moo {
		switch msg.service {
		case "\(BrowseService.id)/browse":
			guard let body = msg.body, let data = body.data(using: .utf8) else {
				throw RequestError.noBody
			}

			let req = try JSONDecoder().decode(
				BrowseService.BrowseRequest.self,
				from: data
			)

			guard req.hierarchy == .browse else {
				return Moo(verb: "COMPLETE", service: "MockNotImplemented")
			}

			if req.popAll == .some(true) {
				stack = []
			} else if let pop = req.popLevels {
				stack = Array(stack[0...(stack.count - Int(pop))])
			} else if let itemKey = req.itemKey {
				switch itemKey {
				case "mock-list":
					stack.append(list)
				case "mock-slow-list":
					try await Task.sleep(for: .milliseconds(500))
					stack.append(list)
				case "mock-action":
					try await Task.sleep(for: .milliseconds(300))
					print("Got action: \(itemKey)")
					stack = []
					return try rootAction.browseMsg()
				case "mock-list-action":
					try await Task.sleep(for: .milliseconds(300))
					print("Got action: \(itemKey)")
					stack.removeLast()
				default:
					return Moo(verb: "COMPLETE", service: "UnknownItemKey")
				}
			}

			let page = stack.last ?? root

			return try page.browseMsg()
		case "\(BrowseService.id)/load":
			guard let body = msg.body, let data = body.data(using: .utf8) else {
				throw RequestError.noBody
			}

			let req = try JSONDecoder().decode(
				BrowseService.LoadRequest.self,
				from: data
			)

			guard req.hierarchy == .browse else {
				return Moo(verb: "COMPLETE", service: "MockNotImplemented")
			}

			let page = stack.last ?? root

			return try page.loadMsg()
		default:
			throw RequestError.notImplemented
		}
	}

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

	func send(_ msg: consuming Moo) async throws {}
}

extension MockServer: Connectable {
	var serverID: String? { "mock-server" }
	var host: String { "192.0.2.1" }
	var port: UInt16 { 9003 }

	func connect() async throws {}
	func disconnect() {}
	func lifetime() async {
		await withCheckedContinuation { (_: CheckedContinuation<Void, Never>) in
		}
	}
}

#Preview {
	ConnectedScreen(conn: MockServer(), host: "localhost", port: 8080)
}