jellyflood/Shared/ViewModels/LibrarySearchViewModel.swift

//
// Swiftfin is subject to the terms of the Mozilla Public
// License, v2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at https://mozilla.org/MPL/2.0/.
//
// Copyright (c) 2022 Jellyfin & Jellyfin Contributors
//

import Combine
import CombineExt
import Foundation
import JellyfinAPI
import SwiftUI

final class LibrarySearchViewModel: ViewModel {

	@Published
	var supportedItemTypeList = [ItemType]()

	@Published
	var selectedItemType: ItemType = .movie

	@Published
	var movieItems = [BaseItemDto]()
	@Published
	var showItems = [BaseItemDto]()
	@Published
	var episodeItems = [BaseItemDto]()

	@Published
	var suggestions = [BaseItemDto]()

	var searchQuerySubject = CurrentValueSubject<String, Never>("")
	var parentID: String?

	init(parentID: String?) {
		self.parentID = parentID
		super.init()

		searchQuerySubject
			.filter { !$0.isEmpty }
			.debounce(for: 0.25, scheduler: DispatchQueue.main)
			.sink(receiveValue: search)
			.store(in: &cancellables)
		setupPublishersForSupportedItemType()

		requestSuggestions()
	}

	func setupPublishersForSupportedItemType() {
		Publishers.CombineLatest3($movieItems, $showItems, $episodeItems)
			.debounce(for: 0.25, scheduler: DispatchQueue.main)
			.map { arg -> [ItemType] in
				var typeList = [ItemType]()
				if !arg.0.isEmpty {
					typeList.append(.movie)
				}
				if !arg.1.isEmpty {
					typeList.append(.series)
				}
				if !arg.2.isEmpty {
					typeList.append(.episode)
				}
				return typeList
			}
			.receive(on: DispatchQueue.main)
			.sink(receiveValue: { [weak self] typeList in
				withAnimation {
					self?.supportedItemTypeList = typeList
				}
			})
			.store(in: &cancellables)

		$supportedItemTypeList
			.receive(on: DispatchQueue.main)
			.withLatestFrom($selectedItemType)
			.compactMap { selectedItemType in
				if self.supportedItemTypeList.contains(selectedItemType) {
					return selectedItemType
				} else {
					return self.supportedItemTypeList.first
				}
			}
			.sink(receiveValue: { [weak self] itemType in
				withAnimation {
					self?.selectedItemType = itemType
				}
			})
			.store(in: &cancellables)
	}

	func requestSuggestions() {
		ItemsAPI.getItemsByUserId(userId: SessionManager.main.currentLogin.user.id,
		                          limit: 20,
		                          recursive: true,
		                          parentId: parentID,
		                          includeItemTypes: [.movie, .series],
		                          sortBy: ["IsFavoriteOrLiked", "Random"],
		                          imageTypeLimit: 0,
		                          enableTotalRecordCount: false,
		                          enableImages: false)
			.trackActivity(loading)
			.receive(on: DispatchQueue.main)
			.sink(receiveCompletion: { [weak self] completion in
				self?.handleAPIRequestError(completion: completion)
			}, receiveValue: { [weak self] response in
				self?.suggestions = response.items ?? []
			})
			.store(in: &cancellables)
	}

	func search(with query: String) {
		ItemsAPI.getItemsByUserId(userId: SessionManager.main.currentLogin.user.id, limit: 50, recursive: true, searchTerm: query,
		                          sortOrder: [.ascending], parentId: parentID,
		                          fields: [.primaryImageAspectRatio, .seriesPrimaryImage, .seasonUserData, .overview, .genres, .people],
		                          includeItemTypes: [.movie], sortBy: ["SortName"], enableUserData: true,
		                          enableImages: true)
			.trackActivity(loading)
			.receive(on: DispatchQueue.main)
			.sink(receiveCompletion: { [weak self] completion in
				self?.handleAPIRequestError(completion: completion)
			}, receiveValue: { [weak self] response in
				self?.movieItems = response.items ?? []
			})
			.store(in: &cancellables)
		ItemsAPI.getItemsByUserId(userId: SessionManager.main.currentLogin.user.id, limit: 50, recursive: true, searchTerm: query,
		                          sortOrder: [.ascending], parentId: parentID,
		                          fields: [.primaryImageAspectRatio, .seriesPrimaryImage, .seasonUserData, .overview, .genres, .people],
		                          includeItemTypes: [.series], sortBy: ["SortName"], enableUserData: true,
		                          enableImages: true)
			.trackActivity(loading)
			.receive(on: DispatchQueue.main)
			.sink(receiveCompletion: { [weak self] completion in
				self?.handleAPIRequestError(completion: completion)
			}, receiveValue: { [weak self] response in
				self?.showItems = response.items ?? []
			})
			.store(in: &cancellables)
		ItemsAPI.getItemsByUserId(userId: SessionManager.main.currentLogin.user.id, limit: 50, recursive: true, searchTerm: query,
		                          sortOrder: [.ascending], parentId: parentID,
		                          fields: [.primaryImageAspectRatio, .seriesPrimaryImage, .seasonUserData, .overview, .genres, .people],
		                          includeItemTypes: [.episode], sortBy: ["SortName"], enableUserData: true,
		                          enableImages: true)
			.trackActivity(loading)
			.receive(on: DispatchQueue.main)
			.sink(receiveCompletion: { [weak self] completion in
				self?.handleAPIRequestError(completion: completion)
			}, receiveValue: { [weak self] response in
				self?.episodeItems = response.items ?? []
			})
			.store(in: &cancellables)
	}
}