Camera, Media and Photos

// Packages/FieldNotesKit/Sources/FieldNotesServices/Persistence/PhotoDataStoring.swift
import Foundation
import SwiftData
import FieldNotesModel

/// Stores and loads the bytes behind a `PhotoAttachment`.
public protocol PhotoDataStoring: Sendable {
    func savePhoto(_ data: Data, as attachment: PhotoAttachment, toNote noteID: Note.ID) async throws
    func photoData(for attachmentID: PhotoAttachment.ID) async throws -> Data?
}

public enum PhotoStoreError: Error {
    case noteNotFound
    case storeUnavailable
}

// SwiftDataNotePersistence is the @ModelActor defined on the SwiftData page; this extension adds photo storage.
extension SwiftDataNotePersistence: PhotoDataStoring {
    public func savePhoto(_ data: Data, as attachment: PhotoAttachment, toNote noteID: Note.ID) async throws {
        var descriptor = FetchDescriptor<NoteRecord>(predicate: #Predicate { $0.id == noteID })
        descriptor.fetchLimit = 1
        guard let note = try modelContext.fetch(descriptor).first else { throw PhotoStoreError.noteNotFound }
        note.photos.append(PhotoRecord(id: attachment.id, fileName: attachment.fileName, data: data))
        try modelContext.save()
    }

    public func photoData(for attachmentID: PhotoAttachment.ID) async throws -> Data? {
        var descriptor = FetchDescriptor<PhotoRecord>(predicate: #Predicate { $0.id == attachmentID })
        descriptor.fetchLimit = 1
        return try modelContext.fetch(descriptor).first?.data
    }
}

// FieldNotes/Photos/PhotoStoreEnvironment.swift
import SwiftUI
import FieldNotesServices

extension EnvironmentValues {
    @Entry var photoStore: (any PhotoDataStoring)? = nil
}

// FieldNotes/FieldNotesApp.swift (excerpt: the Settings, MenuBarExtra and ImmersiveSpace scenes are unchanged)
@main
struct FieldNotesApp: App {
    // AppServices (Background Execution) owns the store and the SwiftData persistence it writes through.
    @State private var store = AppServices.shared.store
    private let persistence = AppServices.shared.persistence

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(store)
                .environment(\.photoStore, persistence)
                .task { await store.load() }
        }
    }
}

// FieldNotes/Photos/NoteStore+Photos.swift
import Foundation
import FieldNotesModel
import FieldNotesServices

extension NoteStore {
    func attachPhoto(_ data: Data, as attachment: PhotoAttachment, toNote noteID: Note.ID,
                     using photoStore: (any PhotoDataStoring)?) async throws {
        guard let photoStore else { throw PhotoStoreError.storeUnavailable }
        await waitForPendingWrites()
        try await photoStore.savePhoto(data, as: attachment, toNote: noteID)
        if let index = notes.firstIndex(where: { $0.id == noteID }) {
            notes[index].attachments.append(attachment)
        }
    }
}

// FieldNotes/Photos/NotePhotoPicker.swift
import SwiftUI
import PhotosUI
import FieldNotesModel
import FieldNotesServices

struct NotePhotoPicker: View {
    @Environment(NoteStore.self) private var store
    @Environment(\.photoStore) private var photoStore
    @State private var selection: [PhotosPickerItem] = []
    @State private var isImporting = false
    @State private var failedImports = 0
    let noteID: Note.ID

    var body: some View {
        PhotosPicker(selection: $selection,
                     maxSelectionCount: 5,
                     selectionBehavior: .ordered,
                     matching: .any(of: [.images, .screenshots]),
                     preferredItemEncoding: .current) {
            Label("Add Photos", systemImage: "photo.badge.plus")
        }
        .disabled(isImporting)
        .onChange(of: selection) { _, items in
            guard !items.isEmpty else { return }
            Task { await importPhotos(items) }
        }
        .alert("\(failedImports) photos couldn't be added", isPresented: .constant(failedImports > 0)) {
            Button("OK") { failedImports = 0 }
        }
    }

    private func importPhotos(_ items: [PhotosPickerItem]) async {
        isImporting = true
        defer { isImporting = false; selection = [] }
        for item in items {
            do {
                guard let data = try await item.loadTransferable(type: Data.self) else { continue }
                let fileExtension = item.supportedContentTypes.first?.preferredFilenameExtension ?? "jpg"
                let attachment = PhotoAttachment(id: UUID(), fileName: "\(UUID().uuidString).\(fileExtension)")
                try await store.attachPhoto(data, as: attachment, toNote: noteID, using: photoStore)
            } catch {
                // A failed item is counted and reported; the others still import.
                failedImports += 1
            }
        }
    }
}

#Preview {
    let note = Note(title: "Oak by the river")
    NotePhotoPicker(noteID: note.id)
        .environment(NoteStore(notes: [note]))
}

// FieldNotes/Photos/AttachmentThumbnail.swift
import SwiftUI
import ImageIO
import FieldNotesModel

struct AttachmentThumbnail: View {
    @Environment(\.photoStore) private var photoStore
    @Environment(\.displayScale) private var displayScale
    @State private var image: CGImage?
    let attachment: PhotoAttachment
    var size: CGFloat = 72

    var body: some View {
        Group {
            if let image {
                Image(decorative: image, scale: displayScale)
                    .resizable()
                    .scaledToFill()
            } else {
                Rectangle().fill(.quaternary)
                    .overlay { ProgressView() }
            }
        }
        .frame(width: size, height: size)
        .clipShape(.rect(cornerRadius: 10))
        .accessibilityLabel("Photo attachment")
        .task(id: attachment.id) {
            guard let data = try? await photoStore?.photoData(for: attachment.id) else { return }
            image = await Self.downsample(data, maxPixelSize: size * displayScale)
        }
    }

    /// Decodes a thumbnail off the main actor without building the full-size bitmap.
    @concurrent
    private static func downsample(_ data: Data, maxPixelSize: CGFloat) async -> CGImage? {
        let sourceOptions = [kCGImageSourceShouldCache: false] as CFDictionary
        guard let source = CGImageSourceCreateWithData(data as CFData, sourceOptions) else { return nil }
        let thumbnailOptions = [
            kCGImageSourceCreateThumbnailFromImageAlways: true,
            kCGImageSourceCreateThumbnailWithTransform: true,   // respect the EXIF orientation
            kCGImageSourceShouldCacheImmediately: true,         // decode now, not on first draw
            kCGImageSourceThumbnailMaxPixelSize: maxPixelSize
        ] as CFDictionary
        return CGImageSourceCreateThumbnailAtIndex(source, 0, thumbnailOptions)
    }
}

// FieldNotes/Views/NoteDetail.swift (excerpt)
if !note.attachments.isEmpty {
    ScrollView(.horizontal) {
        LazyHStack(spacing: 8) {
            ForEach(note.attachments) { attachment in
                AttachmentThumbnail(attachment: attachment)
            }
        }
        .padding(.horizontal)
    }
    .scrollIndicators(.hidden)
}

// FieldNotes/Photos/PhotoLibraryAccess.swift
#if os(iOS) || os(macOS) || os(visionOS)   // PhotoKit's library APIs aren't on watchOS
import Photos

enum PhotoLibraryAccess {
    /// Asks for read access once; later calls return the stored answer without a prompt.
    static func requestReadAccess() async -> PHAuthorizationStatus {
        let current = PHPhotoLibrary.authorizationStatus(for: .readWrite)
        guard current == .notDetermined else { return current }
        return await PHPhotoLibrary.requestAuthorization(for: .readWrite)
    }

    /// Photos taken within `interval` seconds of the note's date, newest first.
    static func photos(near date: Date, within interval: TimeInterval = 3_600) -> PHFetchResult<PHAsset> {
        let options = PHFetchOptions()
        options.predicate = NSPredicate(format: "mediaType == %d AND creationDate > %@ AND creationDate < %@",
                                        PHAssetMediaType.image.rawValue,
                                        date.addingTimeInterval(-interval) as NSDate,
                                        date.addingTimeInterval(interval) as NSDate)
        options.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]
        return PHAsset.fetchAssets(with: options)
    }
}
#endif

// FieldNotes/Photos/NearbyPhotosLoader.swift
#if os(iOS) || os(macOS) || os(visionOS)
import Photos
#if canImport(UIKit)
import UIKit
typealias PlatformImage = UIImage
#else
import AppKit
typealias PlatformImage = NSImage
#endif

struct NearbyThumbnail {
    let image: PlatformImage?
    let isFinal: Bool
}

@MainActor
final class NearbyPhotosLoader {
    private let imageManager = PHCachingImageManager()
    private let targetSize = CGSize(width: 200, height: 200)

    func prefetch(_ assets: [PHAsset]) {
        imageManager.startCachingImages(for: assets, targetSize: targetSize,
                                        contentMode: .aspectFill, options: nil)
    }

    func requestThumbnail(for asset: PHAsset, update: @escaping @MainActor (NearbyThumbnail) -> Void) {
        imageManager.requestImage(for: asset, targetSize: targetSize,
                                  contentMode: .aspectFill, options: nil) { image, info in
            let isDegraded = (info?[PHImageResultIsDegradedKey] as? Bool) ?? false
            MainActor.assumeIsolated { update(NearbyThumbnail(image: image, isFinal: !isDegraded)) }
        }
    }
}
#endif

// FieldNotes/Media/AttachmentVideoPlayer.swift
import SwiftUI
import AVKit

struct AttachmentVideoPlayer: View {
    let url: URL
    let caption: String
    @State private var player: AVPlayer?

    var body: some View {
        VideoPlayer(player: player) {
            Text(caption)
                .font(.footnote)
                .padding(8)
                .background(.thinMaterial, in: .capsule)
                .padding()
                .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
        }
        .aspectRatio(16 / 9, contentMode: .fit)
        .task(id: url) { player = AVPlayer(url: url) }
        .onDisappear { player?.pause() }
    }
}

// FieldNotes/Media/SystemVideoPlayer.swift
#if os(iOS) || os(visionOS)
import SwiftUI
import AVKit

struct SystemVideoPlayer: UIViewControllerRepresentable {
    let player: AVPlayer

    func makeUIViewController(context: Context) -> AVPlayerViewController {
        let controller = AVPlayerViewController()
        controller.player = player
        controller.allowsPictureInPicturePlayback = true
        controller.canStartPictureInPictureAutomaticallyFromInline = true
        return controller
    }

    func updateUIViewController(_ controller: AVPlayerViewController, context: Context) {
        controller.player = player
    }
}
#endif

// FieldNotes/Media/AudioSessionConfigurator.swift
#if os(iOS) || os(watchOS) || os(visionOS)
import AVFAudio

enum AudioSessionConfigurator {
    static func activateForPlayback() throws {
        let session = AVAudioSession.sharedInstance()
        try session.setCategory(.playback, mode: .spokenAudio)
        try session.setActive(true)
    }

    static func activateForRecording() throws {
        let session = AVAudioSession.sharedInstance()
        try session.setCategory(.playAndRecord, mode: .default, options: [.defaultToSpeaker, .allowBluetoothHFP])
        try session.setActive(true)
    }

    /// Lets music or a podcast that FieldNotes interrupted resume.
    static func deactivate() throws {
        try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
    }
}
#endif

// FieldNotes/Media/FieldRecordingPlayer.swift
import AVFoundation
import NowPlaying
import Observation

@available(iOS 27, macOS 27, watchOS 27, visionOS 27, *)
@Observable
@MainActor
final class FieldRecordingPlayer: MediaSessionRepresentable {
    let id = UUID().uuidString
    var recordingTitle: String
    var noteTitle: String
    private(set) var isPlaying = false
    private(set) var elapsedTime: TimeInterval = 0
    private(set) var timestamp = Date.now
    @ObservationIgnored private let player: AVPlayer
    @ObservationIgnored private let duration: TimeInterval
    @ObservationIgnored private var session: MediaSession<FieldRecordingPlayer>?

    init(url: URL, recordingTitle: String, noteTitle: String, duration: TimeInterval) {
        self.player = AVPlayer(url: url)
        self.recordingTitle = recordingTitle
        self.noteTitle = noteTitle
        self.duration = duration
    }

    // What the Lock Screen shows.
    var content: (any MediaContentRepresentable)? {
        GenericContent(id: id, title: recordingTitle, subtitle: noteTitle,
                       type: .audio, duration: .finite(duration), artwork: nil)
    }

    // State plus a timestamp, so the system can extrapolate the position between updates.
    var playbackSnapshot: MediaPlaybackSnapshot? {
        MediaPlaybackSnapshot(state: isPlaying ? .playing() : .paused,
                              elapsedTime: elapsedTime, timestamp: timestamp)
    }

    // The controls the system offers.
    var commands: [MediaCommand] {
        [
            .play { self.play() },
            .pause { self.pause() },
            .seekToPosition { position in self.seek(to: position) },
        ]
    }

    func activate() async throws {
        #if os(iOS) || os(watchOS) || os(visionOS)
        try AudioSessionConfigurator.activateForPlayback()   // macOS has no AVAudioSession
        #endif
        let session = MediaSession(self)
        self.session = session
        try await session.requestToBecomeSystemPrimary()   // must be called while in the foreground
        play()
    }

    func deactivate() {
        pause()
        session = nil   // removes it from the Lock Screen and Control Center
    }

    func play() { player.play(); isPlaying = true; markTime() }
    func pause() { player.pause(); isPlaying = false; markTime() }

    func seek(to position: TimeInterval) {
        player.seek(to: CMTime(seconds: position, preferredTimescale: 600))
        elapsedTime = position
        timestamp = .now
    }

    private func markTime() {
        elapsedTime = player.currentTime().seconds
        timestamp = .now
    }
}

// FieldNotes/Media/RecordingPlaybackController.swift
import AVFoundation
import MediaPlayer
import Observation
import FieldNotesModel

@Observable
@MainActor
final class RecordingPlaybackController {
    @ObservationIgnored private var nowPlayingPlayer: AnyObject?   // a FieldRecordingPlayer on 27
    @ObservationIgnored private var legacyPlayer: AVPlayer?

    func play(_ recording: URL, title: String, in note: Note, duration: TimeInterval) async {
        if #available(iOS 27, macOS 27, watchOS 27, visionOS 27, *) {
            let player = FieldRecordingPlayer(url: recording, recordingTitle: title,
                                              noteTitle: note.title, duration: duration)
            try? await player.activate()
            nowPlayingPlayer = player
        } else {
            let player = AVPlayer(url: recording)
            legacyPlayer = player
            MPNowPlayingInfoCenter.default().nowPlayingInfo = [
                MPMediaItemPropertyTitle: title,
                MPMediaItemPropertyArtist: note.title,
                MPMediaItemPropertyPlaybackDuration: duration,
                MPNowPlayingInfoPropertyElapsedPlaybackTime: 0.0,
                MPNowPlayingInfoPropertyPlaybackRate: 1.0,
            ]
            let commands = MPRemoteCommandCenter.shared()
            commands.playCommand.addTarget { _ in player.play(); return .success }
            commands.pauseCommand.addTarget { _ in player.pause(); return .success }
            player.play()
        }
    }
}

// FieldNotes/AR/ARCapabilityCheck.swift
#if os(iOS)
import SwiftUI
import ARKit
import RealityKit

struct ARPreviewLauncher: View {
    var body: some View {
        if ARWorldTrackingConfiguration.isSupported {
            RealityView { content in
                content.camera = .spatialTracking   // ARKit world tracking under the hood
                let marker = ModelEntity(mesh: .generateSphere(radius: 0.03),
                                         materials: [SimpleMaterial(color: .orange, isMetallic: false)])
                let anchor = AnchorEntity(.plane(.horizontal, classification: .any, minimumBounds: [0.2, 0.2]))
                anchor.addChild(marker)
                content.add(anchor)
            }
            .ignoresSafeArea()
        } else {
            ContentUnavailableView("AR Not Supported", systemImage: "arkit")
        }
    }
}
#endif