Visual Intelligence Image Search Integration

import AppIntents
import VisualIntelligence
import Vision
import UIKit
import VideoToolbox

// MARK: - App Entity

struct AlbumEntity: AppEntity {
    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Album"
    static var defaultQuery = AlbumEntityQuery()

    var id: String
    var name: String
    var artistName: String
    var thumbnailURL: URL?

    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(
            title: "\(name)",
            subtitle: "\(artistName)",
            image: thumbnailURL.map { .init(url: $0) }
        )
    }
}

// MARK: - Entity Query (standard App Intents lookup)

struct AlbumEntityQuery: EntityQuery {
    func entities(for identifiers: [String]) async throws -> [AlbumEntity] {
        MusicCatalog.shared.albums(for: identifiers)
    }
}

// MARK: - Visual Intelligence Intent Value Query

struct AlbumImageSearchQuery: IntentValueQuery {
    typealias Value = AlbumEntity

    func values(for requirement: SemanticContentDescriptor) async throws -> [AlbumEntity] {
        guard let pixelBuffer = requirement.pixelBuffer else { return [] }

        // Convert CVPixelBuffer -> CGImage
        var cgImage: CGImage?
        VTCreateCGImageFromCVPixelBuffer(pixelBuffer, options: nil, imageOut: &cgImage)
        guard let image = cgImage else { return [] }

        // Generate a feature print for the captured image
        let request = GenerateImageFeaturePrintRequest()
        let results = try await request.perform(on: image)
        guard let queryPrint = results.first?.featurePrint else { return [] }

        // Compare against pre-computed catalog prints
        let maxDistance: Float = 0.45
        let matches = MusicCatalog.shared.allAlbums.compactMap { album -> (AlbumEntity, Float)? in
            guard let catalogPrint = album.featurePrint else { return nil }
            var distance: Float = 0
            try? catalogPrint.computeDistance(&distance, to: queryPrint)
            return distance < maxDistance ? (album.entity, distance) : nil
        }

        return matches
            .sorted { $0.1 < $1.1 }
            .prefix(4)
            .map(\.0)
    }
}

// MARK: - Open Intent (navigates to album on tap)

struct OpenAlbumIntent: OpenIntent {
    static var title: LocalizedStringResource = "Open Album"
    @Parameter(title: "Album") var target: AlbumEntity

    @MainActor
    func perform() async throws -> some IntentResult {
        AppNavigator.shared.navigate(to: .album(id: target.id))
        return .result()
    }
}

// MARK: - Minimal catalog stub (replace with real data layer)

struct CatalogAlbum {
    var entity: AlbumEntity
    var featurePrint: VNFeaturePrintObservation?
}

class MusicCatalog {
    static let shared = MusicCatalog()
    var allAlbums: [CatalogAlbum] = []
    func albums(for ids: [String]) -> [AlbumEntity] {
        allAlbums.filter { ids.contains($0.entity.id) }.map(\.entity)
    }
}