import AppKit
import SwiftUI

@MainActor
final class PlayerModel: ObservableObject {
    static let shared = PlayerModel()

    @Published private(set) var state = PlayerState()
    @Published private(set) var fileName: String?
    @Published private(set) var fileIcon: NSImage?
    @Published private(set) var commandError: String?
    @Published private(set) var pendingRevision: UInt64?
    @Published private(set) var resolvingYouTube = false
    @Published private(set) var isLiveStream = false
    @Published var seekPosition = 0.0
    @Published var isSeeking = false
    @Published private(set) var volume = 1.0
    @Published private(set) var controlsVisible = true
    @Published private(set) var isFullScreen = false
    @Published private(set) var isOnTop = false
    let compactWindow = CompactWindowController()
    var isCompact: Bool { compactWindow.isCompact }
    var canToggleCompact: Bool {
        isCompact || compactWindow.isTransitioning ||
            (canTogglePlayback && state.has_video && state.video_aspect_ratio.isFinite && state.video_aspect_ratio > 0)
    }
    var compactContentMinimumHeight: CGFloat {
        guard let window else { return 90 }
        // Hosting-view minimums include the native titlebar safe area, even with full-size content.
        return max(0, 90 - (window.frame.height - window.contentLayoutRect.height))
    }

    let videoView: NSView?
    private var handle: OpaquePointer?
    private var timer: Timer?
    private weak var window: NSWindow?
    private var hideDeadline: ContinuousClock.Instant?
    private var controlsHovered = false
    private var titleHovered = false
    private var controlsDragging = false
    private var windowActive = true
    private var lastAudibleVolume = 1.0
    private var needsVideoFit = false
    private var seekPending = false
    private var youtubeTask: Task<Void, Never>?
    private var youtubeRequest: UUID?
    private var playbackProgress: PlaybackProgress
    private var progressURL: URL?
    private var resumePosition: Double?
    private var lastSavedPosition: Double?

    init(defaults: UserDefaults = .standard) {
        playbackProgress = PlaybackProgress(defaults: defaults)
        let player = player_create()
        handle = player
        if let player, let view = player_macos_make_video_view(player) {
            videoView = Unmanaged<NSView>.fromOpaque(view).takeRetainedValue()
            state = player_get_state(player)
            volume = Double(player_get_volume(player))
        } else {
            videoView = nil
            commandError = "Could not create the media player."
        }
        compactWindow.onChange = { [weak self] in self?.objectWillChange.send() }
        timer = Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { [weak self] _ in
            MainActor.assumeIsolated { self?.poll() }
        }
    }

    var isBusy: Bool { resolvingYouTube || pendingRevision != nil || state.status == PLAYER_OPENING }
    var canTogglePlayback: Bool {
        handle != nil && !isBusy &&
            (state.status == PLAYER_PAUSED || state.status == PLAYER_PLAYING || state.status == PLAYER_ENDED)
    }
    var canSeek: Bool { canTogglePlayback && state.can_seek && state.duration.isFinite && state.duration > 0 }
    var canStepFrame: Bool { canTogglePlayback && state.has_video && state.can_seek && !isSeeking }
    var canOpen: Bool { handle != nil }
    var canClose: Bool { handle != nil && (isBusy || state.status != PLAYER_EMPTY || fileName != nil) }
    var canSetVolume: Bool { handle != nil && !isBusy && state.has_audio && state.status != PLAYER_ERROR }
    var duration: Double { state.duration.isFinite ? max(0, state.duration) : 0 }
    var errorText: String? {
        if let commandError { return commandError }
        guard !isBusy, state.status == PLAYER_ERROR else { return nil }
        var error = state.error
        return withUnsafeBytes(of: &error) { bytes in
            let message = String(decoding: bytes.prefix { $0 != 0 }, as: UTF8.self)
            return message.isEmpty ? "An unknown playback error occurred." : message
        }
    }

    func openPanel() {
        guard canOpen else { return }
        defer { window?.makeFirstResponder(nil) }
        revealControls()
        let panel = NSOpenPanel()
        panel.canChooseFiles = true
        panel.canChooseDirectories = false
        panel.allowsMultipleSelection = false
        panel.prompt = "Open"
        guard panel.runModal() == .OK, let url = panel.url else { return }
        open(url)
    }

    func openYouTubePanel() {
        guard canOpen else { return }
        defer { window?.makeFirstResponder(nil) }
        revealControls()
        let alert = NSAlert()
        alert.messageText = "Open YouTube Video"
        alert.informativeText = "Paste a YouTube video URL."
        alert.addButton(withTitle: "Open")
        alert.addButton(withTitle: "Cancel")
        let field = NSTextField(frame: NSRect(x: 0, y: 0, width: 360, height: 24))
        field.placeholderString = "https://www.youtube.com/watch?v=…"
        field.setAccessibilityLabel("YouTube video URL")
        alert.accessoryView = field
        alert.window.initialFirstResponder = field
        guard alert.runModal() == .alertFirstButtonReturn else { return }
        openYouTube(field.stringValue)
    }

    func openYouTube(_ text: String) {
        guard let handle else { return }
        cancelYouTubeResolution()
        let url: URL
        do {
            url = try YouTubeResolver.validateURL(text)
        } catch {
            commandError = error.localizedDescription
            revealControls()
            return
        }
        if !player_pause(handle) {
            commandError = "Could not pause the current media to open YouTube. Please try again."
            revealControls()
            return
        }
        let request = UUID()
        youtubeRequest = request
        resolvingYouTube = true
        commandError = nil
        revealControls()
        youtubeTask = Task { [weak self] in
            do {
                let video = try await YouTubeResolver.resolve(url)
                guard !Task.isCancelled, let self, self.youtubeRequest == request, self.handle != nil else { return }
                self.youtubeTask = nil
                self.youtubeRequest = nil
                self.resolvingYouTube = false
                self.openResolvedYouTube(video)
            } catch {
                guard !Task.isCancelled, let self, self.youtubeRequest == request else { return }
                self.youtubeTask = nil
                self.youtubeRequest = nil
                self.resolvingYouTube = false
                self.commandError = error.localizedDescription
                self.revealControls()
            }
        }
    }

    private func cancelYouTubeResolution() {
        youtubeRequest = nil
        youtubeTask?.cancel()
        youtubeTask = nil
        resolvingYouTube = false
    }

    private func openResolvedYouTube(_ video: YouTubeVideo) {
        guard let handle else { return }
        saveProgress()
        let revision = player_get_state(handle).revision
        let accepted = video.video.url.withCString { videoURL in
            video.video.headers.withCString { videoHeaders in
                func enqueue(audioURL: UnsafePointer<CChar>?, audioHeaders: UnsafePointer<CChar>?) -> Bool {
                    var source = PlayerNetworkSource(video_url: videoURL, audio_url: audioURL,
                                                     video_headers: videoHeaders, audio_headers: audioHeaders,
                                                     duration: video.duration, is_live: video.isLive)
                    return player_open_network(handle, &source)
                }
                if let audio = video.audio {
                    return audio.url.withCString { audioURL in
                        audio.headers.withCString { enqueue(audioURL: audioURL, audioHeaders: $0) }
                    }
                }
                return enqueue(audioURL: nil, audioHeaders: nil)
            }
        }
        guard accepted else {
            commandError = "Could not queue the YouTube video to open. Please try again."
            revealControls()
            return
        }
        didAcceptOpen(revision: revision, title: video.title, icon: nil, url: video.webpageURL, live: video.isLive)
    }

    private func didAcceptOpen(revision: UInt64, title: String, icon: NSImage?, url: URL, live: Bool = false) {
        guard let handle else { return }
        pendingRevision = revision
        fileName = title
        fileIcon = icon
        isLiveStream = live
        progressURL = url
        resumePosition = live ? nil : playbackProgress.position(for: url)
        lastSavedPosition = nil
        needsVideoFit = true
        commandError = resumePosition != nil || player_play(handle) ? nil :
            "Could not queue playback. Please try again."
        isSeeking = false
        seekPending = false
        seekPosition = 0
        window?.representedURL = url
        window?.title = title
        revealControls()
    }

    func open(_ url: URL) {
        guard canOpen, let handle else { return }
        guard url.isFileURL else {
            openYouTube(url.absoluteString)
            return
        }
        cancelYouTubeResolution()
        saveProgress()
        let revision = player_get_state(handle).revision
        let accepted = url.withUnsafeFileSystemRepresentation { path in
            guard let path else { return false }
            return player_open(handle, path)
        }
        guard accepted else {
            commandError = "Could not queue the file to open. Please try again."
            return
        }
        didAcceptOpen(revision: revision, title: url.lastPathComponent,
                      icon: NSWorkspace.shared.icon(forFile: url.path), url: url)
    }

    func togglePlayback() {
        guard let handle, canTogglePlayback else { return }
        let accepted = state.status == PLAYER_PLAYING ? player_pause(handle) : player_play(handle)
        commandError = accepted ? nil : "Could not queue playback. Please try again."
        revealControls()
    }

    func finishSeeking() {
        isSeeking = false
        guard let handle, canSeek else { return }
        let position = min(max(0, seekPosition), duration)
        let accepted = player_seek(handle, position)
        if accepted { seekPending = true }
        commandError = accepted ? nil : "Could not queue the seek. Please try again."
        revealControls()
    }

    func closeFile() {
        guard let handle, canClose else { return }
        saveProgress()
        cancelYouTubeResolution()
        guard player_close(handle) else {
            commandError = "Could not queue closing the file. Please try again."
            return
        }
        compactWindow.restore(resumeFullScreen: false)
        fileName = nil
        fileIcon = nil
        isLiveStream = false
        progressURL = nil
        resumePosition = nil
        lastSavedPosition = nil
        needsVideoFit = false
        window?.aspectRatio = .zero
        commandError = nil
        isSeeking = false
        seekPending = false
        window?.representedURL = nil
        window?.title = "terebi"
        revealControls()
    }

    func seekRelative(_ seconds: Double) {
        guard canSeek, let handle else { return }
        let target = min(max(0, (seekPending ? seekPosition : state.position) + seconds), duration)
        let accepted = player_seek(handle, target)
        if accepted {
            seekPosition = target
            seekPending = true
        }
        commandError = accepted ? nil : "Could not queue the seek. Please try again."
        revealControls()
    }

    func stepFrame(_ direction: Int32) {
        guard canStepFrame, let handle else { return }
        let accepted = player_step_frame(handle, direction)
        if accepted { seekPending = false }
        commandError = accepted ? nil : "Could not queue the frame step. Please try again."
        revealControls()
    }

    func setVolume(_ value: Double) {
        guard let handle else { return }
        if player_set_volume(handle, Float(value)) {
            volume = Double(player_get_volume(handle))
            if volume > 0 { lastAudibleVolume = volume }
        }
        revealControls()
    }

    func toggleMute() {
        guard canSetVolume else { return }
        setVolume(volume == 0 ? lastAudibleVolume : 0)
    }

    func attachWindow(_ window: NSWindow) {
        guard self.window !== window else { return }
        self.window = window
        window.title = fileName ?? "terebi"
        window.contentMinSize = NSSize(width: 400, height: 240)
        compactWindow.attach(window)
        updateWindowState()
        fitVideoWindow()
    }

    func updateWindowState() {
        guard let window else { return }
        isFullScreen = window.styleMask.contains(.fullScreen)
        windowActive = window.isKeyWindow
        if !compactWindow.isTransitioning {
            window.level = isCompact || (isOnTop && !isFullScreen) ? .floating : .normal
        }
        if !isFullScreen && !compactWindow.isTransitioning { fitVideoWindow() }
        revealControls()
    }

    func toggleFullScreen() {
        guard !compactWindow.isTransitioning else { return }
        if isCompact { compactWindow.restore(resumeFullScreen: false) }
        window?.toggleFullScreen(nil)
        revealControls()
    }

    func toggleCompact() {
        guard canToggleCompact else { return }
        compactWindow.toggle(aspect: state.video_aspect_ratio)
        controlsHovered = false
        titleHovered = false
        revealControls()
    }

    func toggleOnTop() {
        guard !isFullScreen, !isCompact, !compactWindow.isTransitioning else { return }
        isOnTop.toggle()
        window?.level = isOnTop ? .floating : .normal
        revealControls()
    }

    func setControlsHovered(_ hovered: Bool) {
        guard controlsHovered != hovered else { return }
        controlsHovered = hovered
        revealControls()
    }

    func setTitleHovered(_ hovered: Bool) {
        guard titleHovered != hovered else { return }
        titleHovered = hovered
        revealControls()
    }

    func setControlsDragging(_ dragging: Bool) {
        guard controlsDragging != dragging else { return }
        controlsDragging = dragging
        revealControls()
    }

    func hideControls(hideCursor: Bool = true) {
        guard shouldHideControls else { return }
        hideDeadline = nil
        withAnimation(NSWorkspace.shared.accessibilityDisplayShouldReduceMotion ? nil : .easeIn(duration: 0.25)) {
            controlsVisible = false
        }
        NSCursor.setHiddenUntilMouseMoves(hideCursor && windowActive && !isCompact)
    }

    func beginSeeking() {
        isSeeking = true
        revealControls()
    }

    func revealControls() {
        hideDeadline = nil
        NSCursor.setHiddenUntilMouseMoves(false)
        if !controlsVisible {
            withAnimation(NSWorkspace.shared.accessibilityDisplayShouldReduceMotion ? nil : .easeOut(duration: 0.25)) {
                controlsVisible = true
            }
        }
        guard shouldHideControls else { return }
        hideDeadline = ContinuousClock.now.advanced(by: .milliseconds(2500))
    }

    private var shouldHideControls: Bool {
        canTogglePlayback && state.has_video && fileName != nil &&
            !isSeeking && !seekPending && !controlsHovered && !titleHovered && !controlsDragging &&
            (windowActive || isCompact) && errorText == nil &&
            !NSWorkspace.shared.isVoiceOverEnabled
    }

    private func fitVideoWindow() {
        guard needsVideoFit, canTogglePlayback, let window, !isFullScreen,
              !compactWindow.isTransitioning else { return }
        let aspect = state.video_aspect_ratio
        if isCompact {
            compactWindow.updateAspect(state.video_aspect_ratio)
            return
        }
        needsVideoFit = false
        guard state.has_video, aspect.isFinite, aspect > 0 else {
            window.aspectRatio = .zero
            return
        }
        let screen = (window.screen ?? NSScreen.main)?.visibleFrame ?? window.frame
        let width = min(window.frame.width, screen.width, screen.height * aspect)
        let size = NSSize(width: width, height: width / aspect)
        // ponytail: extreme ratios retain letterboxing; compact controls if exact fitting is needed.
        guard size.width >= window.minSize.width, size.height >= window.minSize.height else {
            window.aspectRatio = .zero
            return
        }
        window.aspectRatio = NSSize(width: aspect, height: 1)
        let frame = NSRect(
            x: min(max(window.frame.midX - size.width / 2, screen.minX), screen.maxX - size.width),
            y: min(max(window.frame.midY - size.height / 2, screen.minY), screen.maxY - size.height),
            width: size.width, height: size.height)
        window.setFrame(frame, display: true)
    }

    private func saveProgress(_ snapshot: PlayerState? = nil, force: Bool = true) {
        guard let handle, let url = progressURL, pendingRevision == nil,
              resumePosition == nil, !isLiveStream else { return }
        let current = snapshot ?? player_get_state(handle)
        guard current.status == PLAYER_PAUSED || current.status == PLAYER_PLAYING || current.status == PLAYER_ENDED,
              current.has_video, current.can_seek, !current.seek_pending,
              current.duration.isFinite, current.duration > 0,
              current.position.isFinite, current.position >= 0 else { return }
        let position = current.status == PLAYER_ENDED ? 0 : min(current.position, current.duration)
        guard force || lastSavedPosition == nil || abs(position - lastSavedPosition!) >= 5 else { return }
        playbackProgress.save(position > 0 ? position : nil, for: url)
        lastSavedPosition = position
    }

    private func poll() {
        guard let handle else { return }
        applyState(player_get_state(handle))
    }

    func applyState(_ next: PlayerState) {
        if let revision = pendingRevision {
            guard next.revision != revision, next.status != PLAYER_OPENING else { return }
            pendingRevision = nil
        }
        let statusChanged = state.status != next.status
        state = next
        if next.status == PLAYER_EMPTY || next.status == PLAYER_ERROR ||
            (!isBusy && !next.has_video) {
            compactWindow.restore(resumeFullScreen: false)
        }
        if !next.seek_pending || next.status == PLAYER_ERROR { seekPending = false }
        if !isSeeking && !seekPending {
            seekPosition = min(max(0, next.position.isFinite ? next.position : 0), duration)
        }
        fitVideoWindow()
        if statusChanged { revealControls() }
        if let hideDeadline, ContinuousClock.now >= hideDeadline { hideControls() }
        saveProgress(next, force: statusChanged && (next.status == PLAYER_PAUSED || next.status == PLAYER_ENDED))
        if let saved = resumePosition {
            resumePosition = nil
            guard let handle, next.status == PLAYER_PAUSED || next.status == PLAYER_PLAYING else { return }
            if next.has_video && next.can_seek && next.duration.isFinite && next.duration > 0 {
                if saved < next.duration {
                    guard player_seek(handle, saved) else {
                        // Preserve the stored bookmark if restoration could not be queued.
                        progressURL = nil
                        commandError = "Could not resume saved progress. Please try opening the video again."
                        return
                    }
                    seekPosition = saved
                    seekPending = true
                } else if let url = progressURL {
                    playbackProgress.save(nil, for: url)
                }
            }
            commandError = player_play(handle) ? nil : "Could not queue playback. Please try again."
        }
    }

    func shutdown() {
        saveProgress()
        cancelYouTubeResolution()
        compactWindow.restore(resumeFullScreen: false)
        timer?.invalidate()
        timer = nil
        hideDeadline = nil
        NSCursor.setHiddenUntilMouseMoves(false)
        guard let player = handle else { return }
        handle = nil
        player_destroy(player)
    }
}

@MainActor
private struct PlayerGlass: NSViewRepresentable {
    var titlebar = false

    func makeNSView(context: Context) -> NSVisualEffectView {
        let view = NSVisualEffectView()
        view.blendingMode = .withinWindow
        view.state = .active
        view.appearance = NSAppearance(named: .vibrantDark)
        view.material = titlebar ? .titlebar : .hudWindow
        return view
    }

    func updateNSView(_ view: NSVisualEffectView, context: Context) {}
}

@MainActor
private struct PlaybackSlider: NSViewRepresentable {
    @Binding var value: Double
    let range: ClosedRange<Double>
    var volume = false
    var enabled = true
    var onEditingChanged: (Bool) -> Void = { _ in }

    func makeCoordinator() -> Coordinator { Coordinator(self) }

    func makeNSView(context: Context) -> Slider {
        let slider = Slider()
        let cell = Cell()
        cell.volume = volume
        slider.cell = cell
        slider.isContinuous = true
        slider.target = context.coordinator
        slider.action = #selector(Coordinator.changed(_:))
        return slider
    }

    func updateNSView(_ slider: Slider, context: Context) {
        context.coordinator.parent = self
        slider.minValue = range.lowerBound
        slider.maxValue = range.upperBound
        slider.doubleValue = value
        slider.isEnabled = enabled
        slider.editingChanged = onEditingChanged
        slider.setAccessibilityLabel(volume ? "Volume" : "Playback Position")
    }

    @MainActor
    final class Coordinator: NSObject {
        var parent: PlaybackSlider
        init(_ parent: PlaybackSlider) { self.parent = parent }
        @objc func changed(_ slider: Slider) {
            if !slider.tracking { parent.onEditingChanged(true) }
            parent.value = slider.doubleValue
            if !slider.tracking { parent.onEditingChanged(false) }
        }
    }

    final class Slider: NSSlider {
        var editingChanged: (Bool) -> Void = { _ in }
        private(set) var tracking = false
        override func mouseDown(with event: NSEvent) {
            guard isEnabled else { return }
            tracking = true
            editingChanged(true)
            super.mouseDown(with: event)
            tracking = false
            editingChanged(false)
        }
    }

    final class Cell: NSSliderCell {
        var volume = false
        override func drawBar(inside rect: NSRect, flipped: Bool) {
            let bar = NSRect(x: rect.minX + knobThickness / 2, y: rect.midY - 1.5,
                             width: max(0, rect.width - knobThickness), height: 3)
            NSColor.white.withAlphaComponent(0.12).setFill()
            NSBezierPath(roundedRect: bar, xRadius: 1.5, yRadius: 1.5).fill()
            if volume {
                let fraction = (doubleValue - minValue) / (maxValue - minValue)
                let fill = NSRect(x: bar.minX, y: bar.minY, width: bar.width * fraction, height: bar.height)
                NSColor.systemOrange.withAlphaComponent(0.85).setFill()
                NSBezierPath(roundedRect: fill, xRadius: 1.5, yRadius: 1.5).fill()
            }
        }
        override func drawKnob(_ rect: NSRect) {
            let width: CGFloat = volume ? 16 : 3
            let height: CGFloat = volume ? 12 : 15
            let knob = NSRect(x: rect.midX - width / 2, y: rect.midY - height / 2, width: width, height: height)
            let color = volume ? NSColor(white: isEnabled ? 0.85 : 0.45, alpha: 1)
                               : NSColor.white.withAlphaComponent(isEnabled ? 0.65 : 0.25)
            color.setFill()
            NSBezierPath(roundedRect: knob, xRadius: volume ? 6 : 1, yRadius: volume ? 6 : 1).fill()
        }
    }
}

@MainActor
private struct VideoSurface: NSViewRepresentable {
    let view: NSView

    func makeNSView(context: Context) -> NSView { view }
    func updateNSView(_ nsView: NSView, context: Context) {}
}

@MainActor
private struct CompactDragSurface: NSViewRepresentable {
    let model: PlayerModel

    func makeNSView(context: Context) -> DragView { DragView(model: model) }
    func updateNSView(_ view: DragView, context: Context) {}

    final class DragView: NSView {
        private let model: PlayerModel
        private var hoverTracking: NSTrackingArea?

        init(model: PlayerModel) {
            self.model = model
            super.init(frame: .zero)
        }
        required init?(coder: NSCoder) { nil }

        override func updateTrackingAreas() {
            super.updateTrackingAreas()
            if let hoverTracking { removeTrackingArea(hoverTracking) }
            let area = NSTrackingArea(rect: .zero,
                                      options: [.inVisibleRect, .activeAlways, .mouseEnteredAndExited, .mouseMoved],
                                      owner: self, userInfo: nil)
            hoverTracking = area
            addTrackingArea(area)
        }

        override func mouseEntered(with event: NSEvent) { model.revealControls() }
        override func mouseMoved(with event: NSEvent) { model.revealControls() }
        override func mouseExited(with event: NSEvent) { model.hideControls(hideCursor: false) }

        override func mouseDown(with event: NSEvent) {
            if event.clickCount == 2 {
                model.toggleCompact()
                return
            }
            model.setControlsDragging(true)
            window?.performDrag(with: event)
            model.compactWindow.snapAfterDrag()
            model.setControlsDragging(false)
        }
    }
}

@MainActor
private struct PlayerContent: View {
    @ObservedObject var model: PlayerModel
    @State private var showsRemainingTime = false
    @State private var dropTargeted = false
    @State private var controlSize = CGSize(width: 440, height: 68)
    // Relative offsets preserve the dragged position across resize/fullscreen.
    @State private var controlOffset = CGSize.zero
    @State private var dragOrigin = CGSize.zero

    private func time(_ seconds: Double) -> String {
        let value = Int(min(max(0, seconds.isFinite ? seconds : 0), Double(Int.max / 2)))
        let hours = value / 3600
        return hours > 0
            ? String(format: "%d:%02d:%02d", hours, value / 60 % 60, value % 60)
            : String(format: "%02d:%02d", value / 60, value % 60)
    }

    private func iconButton(_ symbol: String, _ label: String, action: @escaping () -> Void) -> some View {
        Button(action: action) {
            Image(systemName: symbol).font(.system(size: 17)).frame(width: 24, height: 24)
        }
        .buttonStyle(.plain)
        .help(label)
        .accessibilityLabel(label)
    }

    private var titlebar: some View {
        HStack(spacing: 4) {
            if let icon = model.fileIcon {
                Image(nsImage: icon).resizable().frame(width: 16, height: 16)
            } else {
                Image(systemName: "play.rectangle.fill").font(.system(size: 14))
            }
            Text(model.fileName ?? "terebi")
                .font(.system(size: 13, weight: .semibold))
                .lineLimit(1)
                .truncationMode(.middle)
                .help(model.fileName ?? "terebi")
            Spacer(minLength: 12)
            iconButton(model.isOnTop ? "pin.fill" : "pin",
                       model.isOnTop ? "Stop Keeping Window on Top" : "Keep Window on Top", action: model.toggleOnTop)
                .foregroundStyle(.white.opacity(model.isOnTop ? 1 : 0.6))
                .disabled(model.isFullScreen || model.compactWindow.isTransitioning)
        }
        .padding(.leading, model.isFullScreen ? 16 : 86)
        .padding(.trailing, 12)
        .frame(height: 32)
        .foregroundStyle(.white.opacity(0.6))
        .background(PlayerGlass(titlebar: true).allowsHitTesting(false))
        .onHover(perform: model.setTitleHovered)
        .opacity(model.controlsVisible ? 1 : 0)
        .allowsHitTesting(model.controlsVisible)
        .accessibilityHidden(!model.controlsVisible)
    }

    private var actionsMenu: some View {
        Menu {
            Button("Open File…", action: model.openPanel).disabled(!model.canOpen)
            Button("Open YouTube URL…", action: model.openYouTubePanel).disabled(!model.canOpen)
            Button("Close File", action: model.closeFile).disabled(!model.canClose)
            Divider()
            Button(model.isCompact ? "Exit Compact Mode" : "Enter Compact Mode", action: model.toggleCompact)
                .disabled(!model.canToggleCompact)
            Toggle("Snap to Screen Edges", isOn: Binding(
                get: { model.compactWindow.snappingEnabled },
                set: { model.compactWindow.snappingEnabled = $0 }))
            Divider()
            Button(model.isOnTop ? "Stop Keeping Window on Top" : "Keep Window on Top", action: model.toggleOnTop)
                .disabled(model.isFullScreen || model.isCompact || model.compactWindow.isTransitioning)
        } label: {
            Image(systemName: "gearshape").font(.system(size: 17)).frame(width: 24, height: 24)
        }
        .menuStyle(.borderlessButton)
        .menuIndicator(.hidden)
        .fixedSize()
        .accessibilityLabel("Playback Actions")
        .help("Playback Actions")
    }

    private var compactControls: some View {
        HStack(spacing: 16) {
            iconButton(model.state.status == PLAYER_PLAYING ? "pause.fill" : "play.fill",
                       model.state.status == PLAYER_PLAYING ? "Pause" : "Play", action: model.togglePlayback)
                .disabled(!model.canTogglePlayback)
            iconButton("pip.exit", "Exit Compact Mode", action: model.toggleCompact)
                .disabled(model.compactWindow.isTransitioning)
            actionsMenu
        }
        .padding(.horizontal, 12)
        .padding(.vertical, 8)
        .foregroundStyle(.white.opacity(0.85))
        .background(PlayerGlass().clipShape(RoundedRectangle(cornerRadius: 10)))
        .onHover(perform: model.setControlsHovered)
        .opacity(model.controlsVisible ? 1 : 0)
        .allowsHitTesting(model.controlsVisible)
        .accessibilityHidden(!model.controlsVisible)
    }

    private var playbackControls: some View {
        VStack(spacing: 8) {
            HStack(spacing: 0) {
                HStack(spacing: 4) {
                    iconButton(model.volume == 0 ? "speaker.slash.fill" : "speaker.wave.2.fill",
                               model.volume == 0 ? "Unmute" : "Mute", action: model.toggleMute)
                    PlaybackSlider(value: Binding(get: { model.volume }, set: model.setVolume),
                                   range: 0...1, volume: true, enabled: model.canSetVolume,
                                   onEditingChanged: model.setControlsDragging)
                        .frame(width: 70, height: 14)
                        .accessibilityLabel("Volume")
                        .accessibilityValue("\(Int((model.volume * 100).rounded())) percent")
                }
                .disabled(!model.canSetVolume)
                .frame(width: 106, alignment: .leading)
                Spacer(minLength: 8)
                HStack(spacing: 24) {
                    iconButton("backward.fill", "Seek Back 5 Seconds") { model.seekRelative(-5) }
                        .disabled(!model.canSeek)
                    Button(action: model.togglePlayback) {
                        Image(systemName: model.state.status == PLAYER_PLAYING ? "pause.fill" : "play.fill")
                            .font(.system(size: 24))
                            .frame(width: 24, height: 24)
                    }
                    .buttonStyle(.plain)
                    .accessibilityLabel(model.state.status == PLAYER_PLAYING ? "Pause" : "Play")
                    .help(model.state.status == PLAYER_PLAYING ? "Pause (K / Space)" : "Play (K / Space)")
                    .disabled(!model.canTogglePlayback)
                    iconButton("forward.fill", "Seek Forward 5 Seconds") { model.seekRelative(5) }
                        .disabled(!model.canSeek)
                }
                Spacer(minLength: 8)
                HStack(spacing: 12) {
                    iconButton("pip.enter", "Enter Compact Mode", action: model.toggleCompact)
                        .disabled(!model.canToggleCompact)
                    actionsMenu
                }
                .frame(width: 106, alignment: .trailing)
            }
            .padding(.horizontal, 16)

            HStack(spacing: 10) {
                Text(time(model.seekPosition)).frame(minWidth: 32, alignment: .trailing)
                PlaybackSlider(value: $model.seekPosition, range: 0...max(model.duration, 0.001),
                               enabled: model.canSeek, onEditingChanged: { editing in
                    if editing { model.beginSeeking() } else { model.finishSeeking() }
                })
                .frame(height: 14)
                .accessibilityLabel("Playback Position")
                .accessibilityValue(time(model.seekPosition))
                Button {
                    showsRemainingTime.toggle()
                    model.revealControls()
                } label: {
                    Text(model.isLiveStream ? "LIVE" :
                         (showsRemainingTime ? "−" + time(model.duration - model.seekPosition) : time(model.duration)))
                        .frame(minWidth: 32, alignment: .leading)
                }
                .buttonStyle(.plain)
                .disabled(model.isLiveStream)
                .help(model.isLiveStream ? "Live Stream" : (showsRemainingTime ? "Show Duration" : "Show Remaining Time"))
                .accessibilityLabel(model.isLiveStream ? "Live Stream" : (showsRemainingTime ? "Remaining Time" : "Duration"))
                .accessibilityValue(model.isLiveStream ? "Live" :
                                    time(showsRemainingTime ? model.duration - model.seekPosition : model.duration))
            }
            .font(.system(size: 11).monospacedDigit())
            .padding(.horizontal, 16)
        }
        .padding(.vertical, 11)
        // Optical centering accounts for symbol insets and the native seek thumb.
        .offset(y: -1.5)
        .foregroundStyle(.white.opacity(0.6))
        .onHover(perform: model.setControlsHovered)
    }

    private func controllerPosition(in size: CGSize) -> CGPoint {
        let x = size.width / 2 + controlOffset.width * size.width
        let y = size.height * 0.96 - controlSize.height / 2 + controlOffset.height * size.height
        return CGPoint(
            x: min(max(x, controlSize.width / 2 + 12), size.width - controlSize.width / 2 - 12),
            y: min(max(y, 32 + controlSize.height / 2 + 12), size.height - controlSize.height / 2 - 12)
        )
    }

    var body: some View {
        GeometryReader { geometry in
            ZStack(alignment: .top) {
                Color.black
                if let view = model.videoView {
                    VideoSurface(view: view)
                        .accessibilityLabel("Video")
                        .gesture(
                            TapGesture(count: 2).onEnded { model.toggleFullScreen() }
                                .exclusively(before: TapGesture().onEnded { model.hideControls() })
                        )
                }
                if model.isCompact {
                    CompactDragSurface(model: model).accessibilityHidden(true)
                }
                if let error = model.errorText {
                    VStack(spacing: 12) {
                        Image(systemName: "exclamationmark.triangle").font(.system(size: 32)).foregroundStyle(.yellow)
                        Text("Unable to Play").font(.headline)
                        Text(error).font(.callout).multilineTextAlignment(.center).textSelection(.enabled)
                        Button("Open Another File…", action: model.openPanel).disabled(!model.canOpen)
                    }
                    .padding(24)
                    .frame(maxWidth: 420)
                    .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 12))
                    .frame(maxWidth: .infinity, maxHeight: .infinity)
                } else if model.isBusy {
                    VStack(spacing: 12) {
                        ProgressView().controlSize(.large)
                        Text(model.resolvingYouTube ? "Resolving YouTube…" : "Opening…")
                            .font(.callout).foregroundStyle(.secondary)
                    }
                    .frame(maxWidth: .infinity, maxHeight: .infinity)
                } else if model.fileName == nil {
                    VStack(spacing: 14) {
                        Image(systemName: "play.rectangle").font(.system(size: 56, weight: .ultraLight))
                            .foregroundStyle(.white.opacity(0.65))
                        Text("terebi").font(.system(size: 22, weight: .medium))
                        Text("Drop a media file or YouTube link here").font(.callout).foregroundStyle(.secondary)
                        Button("Open File…", action: model.openPanel)
                            .buttonStyle(.bordered).controlSize(.large).disabled(!model.canOpen)
                        Button("Open YouTube URL…", action: model.openYouTubePanel)
                            .buttonStyle(.bordered).disabled(!model.canOpen)
                    }
                    .frame(maxWidth: .infinity, maxHeight: .infinity)
                } else if !model.state.has_video && model.state.has_audio {
                    VStack(spacing: 16) {
                        Image(systemName: "waveform").font(.system(size: 64, weight: .ultraLight))
                        Text(model.fileName ?? "").font(.headline).lineLimit(1)
                    }
                    .foregroundStyle(.secondary)
                    .padding(40)
                    .frame(maxWidth: .infinity, maxHeight: .infinity)
                }
                if model.state.buffering && !model.isBusy && model.errorText == nil {
                    ProgressView("Buffering…")
                        .padding(12)
                        .background(PlayerGlass().clipShape(RoundedRectangle(cornerRadius: 10)))
                        .position(x: geometry.size.width / 2, y: geometry.size.height / 2)
                        .allowsHitTesting(false)
                }

                if model.isCompact {
                    Text(model.fileName ?? "terebi")
                        .font(.system(size: 11, weight: .medium))
                        .lineLimit(1)
                        .padding(8)
                        .frame(maxWidth: .infinity)
                        .foregroundStyle(.white.opacity(0.75))
                        .background(PlayerGlass(titlebar: true))
                        .opacity(model.controlsVisible ? 1 : 0)
                        .allowsHitTesting(false)
                        .accessibilityHidden(!model.controlsVisible)
                    compactControls
                        .position(x: geometry.size.width / 2, y: geometry.size.height - 28)
                } else {
                    titlebar
                }

                if model.canTogglePlayback && !model.isCompact {
                    playbackControls
                        .frame(width: 440, height: 68)
                        .background {
                            PlayerGlass()
                                .clipShape(RoundedRectangle(cornerRadius: 12))
                                .gesture(DragGesture(minimumDistance: 4).onChanged { value in
                                    model.setControlsDragging(true)
                                    controlOffset = CGSize(width: dragOrigin.width + value.translation.width / geometry.size.width,
                                                           height: dragOrigin.height + value.translation.height / geometry.size.height)
                                }.onEnded { _ in
                                    let position = controllerPosition(in: geometry.size)
                                    controlOffset = CGSize(width: (position.x - geometry.size.width / 2) / geometry.size.width,
                                                           height: (position.y - (geometry.size.height * 0.96 - controlSize.height / 2)) / geometry.size.height)
                                    dragOrigin = controlOffset
                                    model.setControlsDragging(false)
                                })
                        }
                        .scaleEffect(min(1, (geometry.size.width - 32) / 440))
                        .frame(width: min(440, geometry.size.width - 32),
                               height: 68 * min(1, (geometry.size.width - 32) / 440))
                        .onGeometryChange(for: CGSize.self) { $0.size } action: { controlSize = $0 }
                        .position(controllerPosition(in: geometry.size))
                        .opacity(model.controlsVisible ? 1 : 0)
                        .allowsHitTesting(model.controlsVisible)
                        .accessibilityHidden(!model.controlsVisible)
                }
                if dropTargeted {
                    RoundedRectangle(cornerRadius: 10)
                        .strokeBorder(.white.opacity(0.75), lineWidth: 2)
                        .padding(8)
                        .allowsHitTesting(false)
                }
            }
            .dropDestination(for: URL.self) { urls, _ in
                guard model.canOpen, let url = urls.first else { return false }
                if !url.isFileURL && (try? YouTubeResolver.validateURL(url.absoluteString)) == nil { return false }
                model.open(url)
                return true
            } isTargeted: {
                dropTargeted = $0
                model.revealControls()
            }
            .onContinuousHover { phase in
                switch phase {
                case .active:
                    if model.isCompact { model.revealControls() }
                case .ended: model.hideControls(hideCursor: false)
                }
            }
        }
        .frame(minWidth: model.isCompact ? 160 : 400,
               minHeight: model.isCompact ? model.compactContentMinimumHeight : 240)
        .ignoresSafeArea()
        .preferredColorScheme(.dark)
        .background(WindowChrome(model: model))
    }
}

@MainActor
private struct WindowChrome: NSViewRepresentable {
    @ObservedObject var model: PlayerModel

    func makeNSView(context: Context) -> ChromeView { ChromeView(model: model) }
    func updateNSView(_ view: ChromeView, context: Context) { view.updateButtons() }
    static func dismantleNSView(_ view: ChromeView, coordinator: ()) { view.detach() }

    final class ChromeView: NSView {
        private let model: PlayerModel
        private weak var configuredWindow: NSWindow?
        private var monitor: Any?
        private var observers: [NSObjectProtocol] = []
        private var dragOrigin: NSPoint?

        init(model: PlayerModel) {
            self.model = model
            super.init(frame: .zero)
        }
        required init?(coder: NSCoder) { nil }

        func handleKeyEvent(_ event: NSEvent) -> Bool {
            guard event.type == .keyDown, let window = configuredWindow, event.window === window,
                  !(window.firstResponder is NSTextView),
                  event.modifierFlags.intersection([.command, .control, .option]).isEmpty else { return false }
            if event.keyCode == 53 && model.isFullScreen {
                if !event.isARepeat { model.toggleFullScreen() }
                return true
            }
            let key = event.charactersIgnoringModifiers?.lowercased()
            switch key {
            case "j": model.seekRelative(-10)
            case "l": model.seekRelative(10)
            case ",": model.stepFrame(-1)
            case ".": model.stepFrame(1)
            case "k", " ":
                if !event.isARepeat { model.togglePlayback() }
            case "m":
                if !event.isARepeat { model.toggleMute() }
            case "f":
                if !event.isARepeat { model.toggleFullScreen() }
            case "p":
                if !event.isARepeat { model.toggleOnTop() }
            case "o":
                if !event.isARepeat { model.openPanel() }
            case "q":
                if !event.isARepeat { NSApp.terminate(nil) }
            default: return false
            }
            return true
        }

        override func viewDidMoveToWindow() {
            super.viewDidMoveToWindow()
            guard let window else { detach(); return }
            guard window !== configuredWindow else { return }
            detach()
            configuredWindow = window
            window.styleMask.insert(.fullSizeContentView)
            window.titleVisibility = .hidden
            window.titlebarAppearsTransparent = true
            window.backgroundColor = .black
            window.acceptsMouseMovedEvents = true
            window.collectionBehavior.insert(.fullScreenPrimary)
            window.appearance = NSAppearance(named: .darkAqua)
            for name in [NSWindow.didBecomeKeyNotification, NSWindow.didResignKeyNotification,
                         NSWindow.didEnterFullScreenNotification, NSWindow.didExitFullScreenNotification] {
                observers.append(NotificationCenter.default.addObserver(forName: name, object: window, queue: .main) { [weak self] _ in
                    MainActor.assumeIsolated {
                        self?.model.updateWindowState()
                        self?.updateButtons()
                    }
                })
            }
            monitor = NSEvent.addLocalMonitorForEvents(matching: [.mouseMoved, .leftMouseDown, .leftMouseUp, .keyDown]) { [weak self] event in
                let consumed = MainActor.assumeIsolated {
                    guard let self, let window = self.configuredWindow else { return false }
                    if event.type == .leftMouseUp {
                        let origin = self.dragOrigin
                        self.dragOrigin = nil
                        if let origin {
                            Task { @MainActor [weak self, weak window] in
                                guard let self, let window, self.configuredWindow === window,
                                      self.model.isCompact, window.frame.origin != origin else { return }
                                self.model.compactWindow.snapAfterDrag()
                            }
                        }
                        return false
                    }
                    guard event.window === window else { return false }
                    if event.type == .leftMouseDown { self.dragOrigin = window.frame.origin }
                    if event.type == .keyDown && event.keyCode == 48 { self.model.revealControls() }
                    if event.type == .mouseMoved || event.type == .leftMouseDown {
                        self.model.revealControls()
                    } else if event.type == .keyDown {
                        return self.handleKeyEvent(event)
                    }
                    return false
                }
                return consumed ? nil : event
            }
            Task { @MainActor [weak self, weak window] in
                guard let self, let window else { return }
                self.model.attachWindow(window)
                self.updateButtons()
                window.makeFirstResponder(nil)
            }
        }

        func updateButtons() {
            let hidden = !model.controlsVisible || model.isFullScreen || model.isCompact
            for button in [NSWindow.ButtonType.closeButton, .miniaturizeButton, .zoomButton] {
                if let view = configuredWindow?.standardWindowButton(button), view.isHidden != hidden {
                    view.isHidden = hidden
                }
            }
        }

        override func mouseDown(with event: NSEvent) {
            model.setControlsDragging(true)
            window?.performDrag(with: event)
            model.compactWindow.snapAfterDrag()
            model.setControlsDragging(false)
        }

        func detach() {
            if let monitor { NSEvent.removeMonitor(monitor) }
            monitor = nil
            dragOrigin = nil
            observers.forEach(NotificationCenter.default.removeObserver)
            observers.removeAll()
            configuredWindow = nil
        }
    }
}

@MainActor
final class AppDelegate: NSObject, NSApplicationDelegate {
    func applicationWillFinishLaunching(_ notification: Notification) {
        // Own external opens: SwiftUI's document routing can close the singleton Window.
        let events = NSAppleEventManager.shared()
        events.setEventHandler(self, andSelector: #selector(openInternetURL(_:withReplyEvent:)),
            forEventClass: AEEventClass(kInternetEventClass), andEventID: AEEventID(kAEGetURL))
    }

    @objc private func openInternetURL(_ event: NSAppleEventDescriptor, withReplyEvent reply: NSAppleEventDescriptor) {
        guard let text = event.paramDescriptor(forKeyword: keyDirectObject)?.stringValue else { return }
        PlayerModel.shared.openYouTube(text)
    }

    @objc private func openDocuments(_ event: NSAppleEventDescriptor, withReplyEvent reply: NSAppleEventDescriptor) {
        guard let url = event.paramDescriptor(forKeyword: keyDirectObject)?.atIndex(1)?.fileURLValue else { return }
        PlayerModel.shared.open(url)
    }

    func applicationDidFinishLaunching(_ notification: Notification) {
        NSApp.setActivationPolicy(.regular)
        NSApp.activate(ignoringOtherApps: true)
        NSAppleEventManager.shared().setEventHandler(self, andSelector: #selector(openDocuments(_:withReplyEvent:)),
            forEventClass: AEEventClass(kCoreEventClass), andEventID: AEEventID(kAEOpenDocuments))
    }

    // Let SwiftUI create the initial window for a Finder/document launch.
    func application(_ application: NSApplication, open urls: [URL]) {
        if let url = urls.first { PlayerModel.shared.open(url) }
    }

    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { true }

    func applicationWillTerminate(_ notification: Notification) {
        PlayerModel.shared.shutdown()
    }
}

@main
@MainActor
struct TerebiApp: App {
    @NSApplicationDelegateAdaptor(AppDelegate.self) private var delegate
    @StateObject private var model = PlayerModel.shared

    var body: some Scene {
        Window("\(model.fileName ?? "terebi")", id: "terebi") {
            PlayerContent(model: model)
        }
        .defaultSize(width: 900, height: 560)
        .windowStyle(.hiddenTitleBar)
        .commands {
            CommandGroup(replacing: .newItem) {
                Button("Open File…", action: model.openPanel).keyboardShortcut("o")
                    .disabled(!model.canOpen)
                Button("Open YouTube URL…", action: model.openYouTubePanel)
                    .keyboardShortcut("o", modifiers: [.command, .shift])
                    .disabled(!model.canOpen)
                Button("Close File", action: model.closeFile)
                    .keyboardShortcut("w", modifiers: [.command, .shift])
                    .disabled(!model.canClose)
            }
            CommandMenu("Playback") {
                Button(model.state.status == PLAYER_PLAYING ? "Pause" : "Play", action: model.togglePlayback)
                    .disabled(!model.canTogglePlayback)
                Button("Seek Back 5 Seconds") { model.seekRelative(-5) }
                    .keyboardShortcut(.leftArrow, modifiers: []).disabled(!model.canSeek)
                Button("Seek Forward 5 Seconds") { model.seekRelative(5) }
                    .keyboardShortcut(.rightArrow, modifiers: []).disabled(!model.canSeek)
                Button("Seek Back 10 Seconds") { model.seekRelative(-10) }.disabled(!model.canSeek)
                Button("Seek Forward 10 Seconds") { model.seekRelative(10) }.disabled(!model.canSeek)
                Divider()
                Button("Previous Frame") { model.stepFrame(-1) }.disabled(!model.canStepFrame)
                Button("Next Frame") { model.stepFrame(1) }.disabled(!model.canStepFrame)
                Divider()
                Button("Volume Up") { model.setVolume(min(1, model.volume + 0.05)) }
                    .keyboardShortcut(.upArrow, modifiers: []).disabled(!model.canSetVolume)
                Button("Volume Down") { model.setVolume(max(0, model.volume - 0.05)) }
                    .keyboardShortcut(.downArrow, modifiers: []).disabled(!model.canSetVolume)
                Button(model.volume == 0 ? "Unmute" : "Mute", action: model.toggleMute)
                    .disabled(!model.canSetVolume)
            }
            CommandGroup(after: .windowArrangement) {
                Button(model.isFullScreen ? "Exit Full Screen" : "Enter Full Screen", action: model.toggleFullScreen)
                    .keyboardShortcut("f", modifiers: [.control, .command])
                    .disabled(model.compactWindow.isTransitioning)
                Button(model.isCompact ? "Exit Compact Mode" : "Enter Compact Mode", action: model.toggleCompact)
                    .keyboardShortcut("p", modifiers: [.control, .command])
                    .disabled(!model.canToggleCompact)
                Toggle("Snap to Screen Edges", isOn: Binding(
                    get: { model.compactWindow.snappingEnabled },
                    set: { model.compactWindow.snappingEnabled = $0 }))
                Button(model.isOnTop ? "Stop Keeping Window on Top" : "Keep Window on Top", action: model.toggleOnTop)
                    .disabled(model.isFullScreen || model.isCompact || model.compactWindow.isTransitioning)
            }
        }
    }
}