/Plac/DataModels/BrowsingDataModel.swift at ba48c64adedec96c7c457b4d42436d32a3505c89

// 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 BrowseItemGroup: Identifiable, Hashable {
	let title: String?
	let items: [BrowseService.Item]

	var id: Int {
		self.hashValue
	}

	init(title: String? = nil, items: [BrowseService.Item]) {
		self.title = title
		self.items = items
	}

	static func groupInto(items: [BrowseService.Item]) -> [BrowseItemGroup] {
		var groups: [BrowseItemGroup] = []

		var currentTitle: String?
		var currentItems: [BrowseService.Item] = []

		for item in items {
			if let last = currentItems.last {
				let isProbablyDifferentItemKind =
					((last.imageKey == nil) != (item.imageKey == nil))
					|| ((last.subtitle == nil) != (item.subtitle == nil))

				if isProbablyDifferentItemKind {
					groups.append(.init(title: currentTitle, items: currentItems))
					currentTitle = nil
					currentItems = []
				}
			}

			switch item.hint {
			case .header:
				if currentTitle != nil || currentItems.count > 0 {
					groups.append(.init(title: currentTitle, items: currentItems))
				}

				currentItems = []
				currentTitle = item.title
			default:
				currentItems.append(item)
			}
		}

		if currentTitle != nil || currentItems.count > 0 {
			groups.append(.init(title: currentTitle, items: currentItems))
		}

		return groups
	}
}

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

extension BrowsePage {
	func isLoading() -> Bool {
		switch self {
		case .loading:
			true
		default:
			false
		}
	}
}

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

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

	private let id: UUID = .init()

	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] = [:]
	var message: String? = nil

	@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,
								multiSessionKey: id.uuidString,
								zoneOrOutputID: zone?.id,
								popAll: true
							)
						)
					)
				)

				if let msg = browse.message {
					message = msg
				}

				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,
								multiSessionKey: id.uuidString,
								count: UInt(UInt16.max),
							)
						)
					)
				)

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

				rootPage = .loaded(
					load.list,
					BrowseItemGroup.groupInto(items: 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,
								multiSessionKey: id.uuidString,
								zoneOrOutputID: zone?.id,
								popLevels: UInt(level)
							)
						)
					)
				)

				if let msg = browse.message {
					message = msg
				}

				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,
										multiSessionKey: id.uuidString,
										level: list.level,
										count: UInt(UInt16.max)
									)
								)
							)
						)

						if let item = item {
							pages[item] = .loaded(
								load.list,
								BrowseItemGroup.groupInto(items: load.items)
							)
						} else {
							rootPage = .loaded(
								load.list,
								BrowseItemGroup.groupInto(items: 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)")
			}
		}
	}

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

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

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

			let list: BrowseService.List
			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,
								multiSessionKey: id.uuidString,
								itemKey: item.itemKey,
								zoneOrOutputID: zone?.id
							)
						)
					)
				)

				if let msg = browse.message {
					message = msg
				}

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

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

				list = responseList
			} catch {
				logger.error("Unable to browse page: \(error)")
				pages[item] = .failed(error)
				return
			}

			var itemToLoad: BrowseService.Item = item

			// 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 {
				_stack = Array(_stack[0..<Int(list.level)])
				pages[item] = nil

				guard let lastItem = _stack.last else {
					logger.debug("Server-side pop to root page")
					return
				}

				itemToLoad = lastItem
			}

			let item = itemToLoad

			do {
				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,
								multiSessionKey: id.uuidString,
								level: list.level,
								count: UInt(UInt16.max)
							)
						)
					)
				)

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

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

	func reload() {
		stack = stack
	}
}