feat: video support (#46)

Author: sozercan

App/VideoWindowController.swift

@@ -0,0 +1,250 @@
+import AppKit
+import SwiftUI
+
+// MARK: - VideoWindowController
+
+/// Manages the floating video window.
+@available(macOS 26.0, *)
+@MainActor
+final class VideoWindowController {
+    static let shared = VideoWindowController()
+
+    private var window: NSWindow?
+    private var hostingView: NSHostingView<AnyView>?
+    private let logger = DiagnosticsLogger.player
+
+    /// Reference to PlayerService to sync showVideo state
+    private weak var playerService: PlayerService?
+
+    /// Flag to prevent re-entrant close handling
+    private var isClosing = false
+
+    // Corner snapping
+    enum Corner: Int {
+        case topLeft, topRight, bottomLeft, bottomRight
+    }
+
+    private var currentCorner: Corner = .bottomRight
+
+    private init() {
+        self.loadCorner()
+    }
+
+    /// Shows the video window.
+    func show(
+        playerService: PlayerService,
+        webKitManager: WebKitManager
+    ) {
+        self.logger.debug("VideoWindowController.show() called")
+
+        // Store reference to sync state on close
+        self.playerService = playerService
+
+        // Start grace period to prevent race condition when video element is moved
+        playerService.videoWindowDidOpen()
+
+        if let existingWindow = self.window {
+            // Window exists - just bring it to front
+            self.logger.debug("Window already exists, bringing to front")
+            self.isClosing = false // Reset in case of interrupted close
+            existingWindow.makeKeyAndOrderFront(nil)
+            // Ensure video mode is active
+            SingletonPlayerWebView.shared.updateDisplayMode(.video)
+            return
+        }
+
+        self.logger.info("Creating new video window")
+
+        let contentView = VideoPlayerWindow()
+            .environment(playerService)
+            .environment(webKitManager)
+
+        let hostingView = NSHostingView(rootView: AnyView(contentView))
+        self.hostingView = hostingView
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 480, height: 270),
+            styleMask: [.titled, .closable, .resizable, .fullSizeContentView],
+            backing: .buffered,
+            defer: false
+        )
+
+        window.contentView = hostingView
+        window.isReleasedWhenClosed = false
+        window.title = "Video"
+        window.titlebarAppearsTransparent = true
+        window.titleVisibility = .hidden
+        window.isMovableByWindowBackground = true
+        // Normal window level (not always-on-top) for better UX
+        window.level = .normal
+        window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+        window.aspectRatio = NSSize(width: 16, height: 9)
+        window.minSize = NSSize(width: 320, height: 180)
+        window.backgroundColor = .black
+
+        // Set accessibility identifier for UI testing
+        window.identifier = NSUserInterfaceItemIdentifier(AccessibilityID.VideoWindow.container)
+
+        // Position at saved corner
+        self.positionAtCorner(window: window, corner: self.currentCorner)
+
+        window.makeKeyAndOrderFront(nil)
+        self.window = window
+        self.isClosing = false
+
+        // Observe window close (for red X button)
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.windowWillClose),
+            name: NSWindow.willCloseNotification,
+            object: window
+        )
+
+        // Update WebView display mode for video
+        self.logger.info("Calling updateDisplayMode(.video)")
+        SingletonPlayerWebView.shared.updateDisplayMode(.video)
+    }
+
+    /// Closes the video window programmatically (called when showVideo becomes false).
+    func close() {
+        self.logger.debug("VideoWindowController.close() called")
+
+        // Prevent re-entrant calls
+        guard !self.isClosing else {
+            self.logger.debug("Already closing, skipping")
+            return
+        }
+
+        guard let window = self.window else {
+            self.logger.debug("No window to close")
+            return
+        }
+
+        self.isClosing = true
+        self.logger.info("Closing video window")
+
+        // Remove observer before closing to prevent windowWillClose from firing
+        NotificationCenter.default.removeObserver(self, name: NSWindow.willCloseNotification, object: window)
+
+        // Save corner position
+        self.currentCorner = self.nearestCorner(for: window)
+        self.saveCorner()
+
+        // Clean up
+        self.performCleanup()
+
+        // Actually close the window
+        window.close()
+    }
+
+    /// Called when window is closed via the red X button.
+    @objc private func windowWillClose(_ notification: Notification) {
+        self.logger.info("windowWillClose notification received")
+
+        // Prevent re-entrant calls
+        guard !self.isClosing else {
+            self.logger.debug("Already closing, skipping windowWillClose")
+            return
+        }
+        self.isClosing = true
+
+        // Update corner based on final position
+        if let window = notification.object as? NSWindow {
+            self.currentCorner = self.nearestCorner(for: window)
+            self.saveCorner()
+        }
+
+        // Clean up
+        self.performCleanup()
+
+        // Sync PlayerService state - this handles close via red button
+        // This will trigger MainWindow.onChange which calls close(), but isClosing prevents re-entry
+        if self.playerService?.showVideo == true {
+            self.logger.debug("Syncing playerService.showVideo to false")
+            self.playerService?.showVideo = false
+        }
+    }
+
+    /// Shared cleanup logic for both close paths.
+    private func performCleanup() {
+        self.logger.debug("performCleanup called")
+
+        // Clear grace period
+        self.playerService?.videoWindowDidClose()
+
+        // Return WebView to hidden mode (removes video container CSS)
+        SingletonPlayerWebView.shared.updateDisplayMode(.hidden)
+
+        // Clear references
+        self.window = nil
+        self.hostingView = nil
+
+        // Reset close guard so future close operations can proceed
+        self.isClosing = false
+    }
+
+    private func positionAtCorner(window: NSWindow, corner: Corner) {
+        guard let screen = NSScreen.main else { return }
+        let screenFrame = screen.visibleFrame
+        let windowSize = window.frame.size
+        let padding: CGFloat = 20
+
+        let origin =
+            switch corner {
+            case .topLeft:
+                NSPoint(
+                    x: screenFrame.minX + padding,
+                    y: screenFrame.maxY - windowSize.height - padding
+                )
+            case .topRight:
+                NSPoint(
+                    x: screenFrame.maxX - windowSize.width - padding,
+                    y: screenFrame.maxY - windowSize.height - padding
+                )
+            case .bottomLeft:
+                NSPoint(
+                    x: screenFrame.minX + padding,
+                    y: screenFrame.minY + padding
+                )
+            case .bottomRight:
+                NSPoint(
+                    x: screenFrame.maxX - windowSize.width - padding,
+                    y: screenFrame.minY + padding
+                )
+            }
+
+        window.setFrameOrigin(origin)
+    }
+
+    private func nearestCorner(for window: NSWindow) -> Corner {
+        guard let screen = NSScreen.main else { return .bottomRight }
+        let screenFrame = screen.visibleFrame
+        let windowCenter = NSPoint(
+            x: window.frame.midX,
+            y: window.frame.midY
+        )
+        let screenCenter = NSPoint(
+            x: screenFrame.midX,
+            y: screenFrame.midY
+        )
+
+        let isLeft = windowCenter.x < screenCenter.x
+        let isTop = windowCenter.y > screenCenter.y
+
+        switch (isLeft, isTop) {
+        case (true, true): return .topLeft
+        case (false, true): return .topRight
+        case (true, false): return .bottomLeft
+        case (false, false): return .bottomRight
+        }
+    }
+
+    private func saveCorner() {
+        UserDefaults.standard.set(self.currentCorner.rawValue, forKey: "videoWindowCorner")
+    }
+
+    private func loadCorner() {
+        let raw = UserDefaults.standard.integer(forKey: "videoWindowCorner")
+        self.currentCorner = Corner(rawValue: raw) ?? .bottomRight
+    }
+}

Core/Models/MusicVideoType.swift

@@ -0,0 +1,43 @@
+import Foundation
+
+// MARK: - MusicVideoType
+
+/// Represents the type of music video content from YouTube Music.
+///
+/// This enum maps to the `musicVideoType` field in the YouTube Music API's
+/// `player` and `next` endpoint responses. It helps distinguish between
+/// actual music videos (with video content) and audio-only tracks.
+///
+/// - Note: Only `.omv` (Official Music Video) should display the video toggle
+///   button, as other types have either static images or no meaningful video.
+enum MusicVideoType: String, Codable, Sendable {
+    /// Official Music Video - Full video content from the artist/label.
+    /// These have actual video content and should show the video toggle.
+    case omv = "MUSIC_VIDEO_TYPE_OMV"
+
+    /// Audio Track Video - Static image or visualizer (audio only).
+    /// These do NOT have meaningful video content.
+    case atv = "MUSIC_VIDEO_TYPE_ATV"
+
+    /// User Generated Content - Fan-made or unofficial videos.
+    case ugc = "MUSIC_VIDEO_TYPE_UGC"
+
+    /// Podcast Episode - Audio podcast content.
+    case podcastEpisode = "MUSIC_VIDEO_TYPE_PODCAST_EPISODE"
+
+    /// Whether this video type has actual video content worth showing.
+    /// Only Official Music Videos have meaningful video.
+    var hasVideoContent: Bool {
+        self == .omv
+    }
+
+    /// Human-readable description of the video type.
+    var displayName: String {
+        switch self {
+        case .omv: "Official Music Video"
+        case .atv: "Audio Track"
+        case .ugc: "User Generated"
+        case .podcastEpisode: "Podcast Episode"
+        }
+    }
+}

Core/Models/Song.swift

@@ -12,6 +12,13 @@ struct Song: Identifiable, Codable, Hashable, Sendable {
     let thumbnailURL: URL?
     let videoId: String
 
+    /// Whether this track has a music video available.
+    var hasVideo: Bool?
+
+    /// The type of music video (OMV, ATV, UGC, etc.).
+    /// Use `musicVideoType?.hasVideoContent` to check if video is worth displaying.
+    var musicVideoType: MusicVideoType?
+
     /// Like/dislike status of the song (nil if unknown).
     var likeStatus: LikeStatus?
 
@@ -30,6 +37,8 @@ struct Song: Identifiable, Codable, Hashable, Sendable {
         duration: TimeInterval? = nil,
         thumbnailURL: URL? = nil,
         videoId: String,
+        hasVideo: Bool? = nil,
+        musicVideoType: MusicVideoType? = nil,
         likeStatus: LikeStatus? = nil,
         isInLibrary: Bool? = nil,
         feedbackTokens: FeedbackTokens? = nil
@@ -41,6 +50,8 @@ struct Song: Identifiable, Codable, Hashable, Sendable {
         self.duration = duration
         self.thumbnailURL = thumbnailURL
         self.videoId = videoId
+        self.hasVideo = hasVideo
+        self.musicVideoType = musicVideoType
         self.likeStatus = likeStatus
         self.isInLibrary = isInLibrary
         self.feedbackTokens = feedbackTokens

Core/Services/API/Parsers/SongMetadataParser.swift

@@ -23,6 +23,7 @@ enum SongMetadataParser {
         let thumbnailURL = self.parseThumbnail(from: panelVideoRenderer)
         let duration = self.parseDuration(from: panelVideoRenderer)
         let menuData = self.parseMenuData(from: panelVideoRenderer)
+        let musicVideoType = self.parseMusicVideoType(from: panelVideoRenderer)
 
         return Song(
             id: videoId,
@@ -32,6 +33,7 @@ enum SongMetadataParser {
             duration: duration,
             thumbnailURL: thumbnailURL,
             videoId: videoId,
+            musicVideoType: musicVideoType,
             likeStatus: menuData.likeStatus,
             isInLibrary: menuData.isInLibrary,
             feedbackTokens: menuData.feedbackTokens
@@ -133,6 +135,19 @@ enum SongMetadataParser {
         return ParsingHelpers.parseDuration(text)
     }
 
+    /// Parses the music video type from the panel video renderer's navigation endpoint.
+    /// Path: navigationEndpoint.watchEndpoint.watchEndpointMusicSupportedConfigs.watchEndpointMusicConfig.musicVideoType
+    static func parseMusicVideoType(from renderer: [String: Any]) -> MusicVideoType? {
+        guard let navEndpoint = renderer["navigationEndpoint"] as? [String: Any],
+              let watchEndpoint = navEndpoint["watchEndpoint"] as? [String: Any],
+              let configs = watchEndpoint["watchEndpointMusicSupportedConfigs"] as? [String: Any],
+              let musicConfig = configs["watchEndpointMusicConfig"] as? [String: Any],
+              let typeString = musicConfig["musicVideoType"] as? String
+        else { return nil }
+
+        return MusicVideoType(rawValue: typeString)
+    }
+
     /// Parses menu data (feedbackTokens, library status, like status) from the panel video renderer.
     static func parseMenuData(from renderer: [String: Any]) -> MenuParseResult {
         var result = MenuParseResult(feedbackTokens: nil, isInLibrary: false, likeStatus: .indifferent)