/macos/plac/DataModels/BrowsingDataModel.swift at 8e5bf3791c53abe28ea817418a998e03f06d1261

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

enum BrowsePage {
	case loading
	case loaded(BrowseService.List, [BrowseService.Item])
	case failed(any Error)
}

@MainActor
@Observable
final class BrowsingDataModel {
	@ObservationIgnored
	private let logger = Logger()

	@ObservationIgnored
	private var loading: Task<Void, Never>? = nil

	var hierarchy: BrowseService.Hierarchy? = nil {
		didSet {
			stack = []
		}
	}

	var zone: TransportService.Zone? = nil

	private var _stack: [BrowseService.Item] = []

	var stack: [BrowseService.Item] {
		get {
			return _stack
		}

		set {
			let oldValue = _stack
			_stack = newValue

			guard let last = _stack.last else {
				loadRootPage()
				return
			}

			if oldValue.count > _stack.count {
				popPages(items: Array(oldValue[_stack.count...]))
				return
			}

			loadPage(item: last)
		}
	}

	var rootPage: BrowsePage? = nil
	var pages: [BrowseService.Item: BrowsePage] = [:]

	@ObservationIgnored
	private let conn: Communicatable

	init(conn: Communicatable) {
		self.conn = conn
	}

	enum LoadError: Error {
		case hierarchyNotSet
		case nonListResponse
	}

	private func loadRootPage() {
		guard let hierarchy = hierarchy else {
			return
		}

		if let loading = self.loading {
			loading.cancel()
		}

		pages = [:]

		self.loading = Task {
			rootPage = .loading
			do {
				logger.debug("Moving browse cursor to root on \(hierarchy.rawValue)")

				let browse = try BrowseService.BrowseResponse(
					try await conn.request(
						Moo(
							browse: .init(
								hierarchy: hierarchy,
								zoneOrOutputID: zone?.id,
								popAll: true
							)
						)
					)
				)

				guard browse.action == .list else {
					throw LoadError.nonListResponse
				}

				logger.debug("Loading root page of \(hierarchy.rawValue)")

				let load = try BrowseService.LoadResponse(
					try await conn.request(
						Moo(
							load: .init(hierarchy: hierarchy, count: UInt(UInt16.max))
						)
					)
				)

				logger.debug("Got root page for \(hierarchy.rawValue)")

				rootPage = .loaded(load.list, load.items)
			} catch {
				logger.error(
					"Unable to load root page of \(hierarchy.rawValue): \(error)"
				)
				rootPage = .failed(error)
			}
		}
	}

	private func popPages(items: [BrowseService.Item]) {
		guard let hierarchy = hierarchy else {
			return
		}

		if let loading = self.loading {
			loading.cancel()
		}

		for item in items {
			pages[item] = nil
		}

		let level = items.count

		self.loading = Task {
			do {
				logger.debug("Popping \(level) levels")

				let browse = try BrowseService.BrowseResponse(
					try await conn.request(
						Moo(
							browse: .init(
								hierarchy: hierarchy,
								zoneOrOutputID: zone?.id,
								popLevels: UInt(level)
							)
						)
					)
				)

				switch browse.action {
				case .list:
					guard let list = browse.list else {
						logger.warning("Roon server returned list action without payload")
						return
					}

					let item = stack.last

					do {
						logger.debug("Updating the new current page after pop")
						let load = try BrowseService.LoadResponse(
							try await conn.request(
								Moo(
									load: .init(
										hierarchy: hierarchy,
										level: list.level,
										count: UInt(UInt16.max)
									)
								)
							)
						)

						if let item = item {
							pages[item] = .loaded(load.list, load.items)
						} else {
							rootPage = .loaded(load.list, load.items)
						}
					} catch {
						logger.error("Unable to load topmost page after pop: \(error)")
					}
				default:
					// TODO: Handle other cases
					break
				}

			} catch {
				logger.error("Unable to pop pages: \(error)")
			}
		}
	}

	private func loadPage(item: BrowseService.Item) {
		guard let hierarchy = hierarchy else {
			return
		}

		if let loading = self.loading {
			loading.cancel()
		}

		guard let item = self.stack.last else {
			logger.warning("Attempt to load page ")
			return
		}

		self.loading = Task {
			pages[item] = .loading

			do {
				logger.debug(
					"Moving browse cursor to \(item.title)/\(item.itemKey ?? "<nil>")/\(self.stack.count)"
				)

				let browse = try BrowseService.BrowseResponse(
					try await conn.request(
						Moo(
							browse: .init(
								hierarchy: hierarchy,
								itemKey: item.itemKey,
								zoneOrOutputID: zone?.id
							)
						)
					)
				)

				guard browse.action == .list else {
					logger.info(
						"Only list action is supported for now: got \(browse.action.rawValue)"
					)
					throw LoadError.nonListResponse
				}

				guard let list = browse.list else {
					logger.error(
						"Roon server returned list action, but list property is empty"
					)
					throw LoadError.nonListResponse
				}

				// Some items do automatically pop server stack. Clients have to guess that by
				// inspecting list's level and comparing that to the locally maintained stack.
				if list.level < _stack.count - 1 {
					logger.debug("Detected server pop, shrinking local stack")
					_stack = Array(_stack[0..<Int(list.level)])
					pages[item] = nil
					return
				}

				logger.debug(
					"Loading page at \(item.title)/\(item.itemKey ?? "<nil>")/\(self.stack.count)"
				)

				let load = try BrowseService.LoadResponse(
					try await conn.request(
						Moo(
							load: .init(
								hierarchy: hierarchy,
								level: list.level,
								count: UInt(UInt16.max)
							)
						)
					)
				)

				logger.debug("Got page for \(item.title)")

				pages[item] = .loaded(load.list, load.items)
			} catch {
				logger.error("Unable to load page: \(error)")
				pages[item] = .failed(error)
			}
		}
	}

	func reload() {
		stack = stack
	}
}