//
//  PlayerControlsSettingsViewModel.swift
//  Yattee
//
//  ViewModel for the player controls customization settings UI.
//

import Foundation
import SwiftUI

/// ViewModel for the player controls settings view.
/// Manages preset selection, layout editing, and auto-save.
@MainActor
@Observable
final class PlayerControlsSettingsViewModel {
    // MARK: - Dependencies

    private let layoutService: PlayerControlsLayoutService
    let settingsManager: SettingsManager

    /// Observer for preset changes from CloudKit sync.
    @ObservationIgnored private var presetsChangedObserver: NSObjectProtocol?

    // MARK: - State

    /// All available presets for the current device.
    private(set) var presets: [LayoutPreset] = []

    /// The currently active/selected preset.
    private(set) var activePreset: LayoutPreset?

    /// Whether currently loading presets.
    private(set) var isLoading = false

    /// Error message to display, if any.
    private(set) var error: String?

    /// Whether the preview is showing landscape mode.
    var isPreviewingLandscape = false

    /// The section currently selected for editing.
    var selectedSection: LayoutSectionType?

    /// Whether a save operation is in progress.
    private(set) var isSaving = false

    /// Debounced save task for coalescing rapid updates.
    private var saveTask: Task<Void, Never>?

    // MARK: - Computed Properties

    /// ID of the active preset.
    var activePresetID: UUID? {
        activePreset?.id
    }

    /// Whether the active preset can be deleted (not built-in and not active).
    var canDeleteActivePreset: Bool {
        guard let activePreset else { return false }
        return !activePreset.isBuiltIn
    }

    /// Whether the active preset can be edited (not built-in).
    var canEditActivePreset: Bool {
        guard let activePreset else { return false }
        return !activePreset.isBuiltIn
    }

    /// Current layout from active preset, or default.
    var currentLayout: PlayerControlsLayout {
        activePreset?.layout ?? .default
    }

    /// Current center section settings for observation.
    var centerSettings: CenterSectionSettings {
        activePreset?.layout.centerSettings ?? .default
    }

    /// Seek backward seconds - exposed for direct observation.
    var seekBackwardSeconds: Int {
        activePreset?.layout.centerSettings.seekBackwardSeconds ?? 10
    }

    /// Seek forward seconds - exposed for direct observation.
    var seekForwardSeconds: Int {
        activePreset?.layout.centerSettings.seekForwardSeconds ?? 10
    }

    /// Current progress bar settings.
    var progressBarSettings: ProgressBarSettings {
        activePreset?.layout.progressBarSettings ?? .default
    }

    /// Built-in presets sorted by name.
    var builtInPresets: [LayoutPreset] {
        presets.filter(\.isBuiltIn).sorted { $0.name < $1.name }
    }

    /// Custom (user-created) presets sorted by name.
    var customPresets: [LayoutPreset] {
        presets.filter { !$0.isBuiltIn }.sorted { $0.name < $1.name }
    }

    /// Button types that are new since last seen.
    var newButtonTypes: [ControlButtonType] {
        Task.detached { [layoutService] in
            await layoutService.newButtonTypes()
        }
        // Return empty for now; actual implementation will load async
        return []
    }

    // MARK: - Initialization

    init(
        layoutService: PlayerControlsLayoutService,
        settingsManager: SettingsManager
    ) {
        self.layoutService = layoutService
        self.settingsManager = settingsManager

        // Observe preset changes from CloudKit sync
        presetsChangedObserver = NotificationCenter.default.addObserver(
            forName: .playerControlsPresetsDidChange,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor [weak self] in
                await self?.handlePresetsChanged()
            }
        }
    }

    /// Handles preset changes from CloudKit sync.
    private func handlePresetsChanged() async {
        do {
            let loadedPresets = try await layoutService.loadPresets()
            presets = loadedPresets.filter { $0.deviceClass == .current }

            // Refresh active preset if it was updated
            // Use in-memory activePreset?.id to avoid race condition with setActivePresetID
            if let activeID = activePreset?.id,
               let updatedPreset = presets.first(where: { $0.id == activeID }) {
                activePreset = updatedPreset
            }

            LoggingService.shared.debug("Reloaded presets after CloudKit sync", category: .general)
        } catch {
            LoggingService.shared.error("Failed to reload presets after CloudKit sync: \(error.localizedDescription)")
        }
    }

    deinit {
        if let observer = presetsChangedObserver {
            NotificationCenter.default.removeObserver(observer)
        }
    }

    // MARK: - Loading

    /// Loads all presets and sets the active preset.
    func loadPresets() async {
        isLoading = true
        error = nil

        do {
            let loadedPresets = try await layoutService.loadPresets()
            presets = loadedPresets.filter { $0.deviceClass == .current }
            activePreset = await layoutService.activePreset()
            LoggingService.shared.info("Loaded \(presets.count) presets, active: \(activePreset?.name ?? "none")")
        } catch {
            self.error = error.localizedDescription
            LoggingService.shared.error("Failed to load presets: \(error.localizedDescription)")
        }

        isLoading = false
    }

    /// Refreshes presets from storage.
    func refreshPresets() async {
        do {
            let loadedPresets = try await layoutService.loadPresets()
            presets = loadedPresets.filter { $0.deviceClass == .current }
            
            // Update active preset if it changed
            if let activeID = activePresetID,
               let updatedPreset = presets.first(where: { $0.id == activeID }) {
                activePreset = updatedPreset
            }
        } catch {
            LoggingService.shared.error("Failed to refresh presets: \(error.localizedDescription)")
        }
    }

    // MARK: - Preset Selection

    /// Selects a preset as the active preset.
    /// - Parameter preset: The preset to activate.
    func selectPreset(_ preset: LayoutPreset) {
        activePreset = preset
        Task {
            await layoutService.setActivePresetID(preset.id)
        }
        LoggingService.shared.info("Selected preset: \(preset.name)")
    }

    /// Selects a preset by ID.
    /// - Parameter id: The ID of the preset to activate.
    func selectPreset(id: UUID) {
        guard let preset = presets.first(where: { $0.id == id }) else { return }
        selectPreset(preset)
    }

    // MARK: - Preset Management

    /// Creates a new custom preset with the given name.
    /// - Parameters:
    ///   - name: Name for the new preset.
    ///   - basePreset: Optional preset to copy layout from. Uses default layout if nil.
    func createPreset(name: String, basedOn basePreset: LayoutPreset? = nil) async {
        let layout = basePreset?.layout ?? .default
        let newPreset = LayoutPreset(
            name: name,
            isBuiltIn: false,
            deviceClass: .current,
            layout: layout
        )

        do {
            try await layoutService.savePreset(newPreset)
            await refreshPresets()
            // Select the newly created preset from the refreshed list for consistency
            if let savedPreset = presets.first(where: { $0.id == newPreset.id }) {
                selectPreset(savedPreset)
            } else {
                selectPreset(newPreset)
            }
            LoggingService.shared.info("Created preset: \(name) based on: \(basePreset?.name ?? "default")")
        } catch {
            self.error = error.localizedDescription
            LoggingService.shared.error("Failed to create preset: \(error.localizedDescription)")
        }
    }

    /// Deletes a preset.
    /// - Parameter preset: The preset to delete.
    func deletePreset(_ preset: LayoutPreset) async {
        guard !preset.isBuiltIn else {
            error = "Cannot delete built-in presets"
            return
        }

        // If deleting active preset, switch to default first
        let wasActive = preset.id == activePresetID
        if wasActive {
            if let defaultPreset = builtInPresets.first(where: { $0.name == "Default" }) ?? builtInPresets.first {
                selectPreset(defaultPreset)
            }
        }

        do {
            try await layoutService.deletePreset(id: preset.id)
            await refreshPresets()
            LoggingService.shared.info("Deleted preset: \(preset.name)")
        } catch {
            self.error = error.localizedDescription
            LoggingService.shared.error("Failed to delete preset: \(error.localizedDescription)")
        }
    }

    /// Renames a preset.
    /// - Parameters:
    ///   - preset: The preset to rename.
    ///   - newName: The new name.
    func renamePreset(_ preset: LayoutPreset, to newName: String) async {
        guard !preset.isBuiltIn else {
            error = "Cannot rename built-in presets"
            return
        }

        do {
            try await layoutService.renamePreset(preset.id, to: newName)
            await refreshPresets()
            LoggingService.shared.info("Renamed preset to: \(newName)")
        } catch {
            self.error = error.localizedDescription
            LoggingService.shared.error("Failed to rename preset: \(error.localizedDescription)")
        }
    }

    // MARK: - Layout Editing

    /// Updates the top section of the current layout.
    /// - Parameter section: The new top section configuration.
    func updateTopSection(_ section: LayoutSection) async {
        await updateLayout { layout in
            layout.topSection = section
        }
    }

    /// Updates the bottom section of the current layout.
    /// - Parameter section: The new bottom section configuration.
    func updateBottomSection(_ section: LayoutSection) async {
        await updateLayout { layout in
            layout.bottomSection = section
        }
    }

    /// Updates the center settings of the current layout.
    /// - Parameter settings: The new center section settings.
    func updateCenterSettings(_ settings: CenterSectionSettings) async {
        await updateLayout { layout in
            layout.centerSettings = settings
        }
    }

    /// Synchronously updates center settings with immediate UI feedback.
    /// Saves are debounced to avoid rapid disk writes.
    /// - Parameter mutation: A closure that mutates the center settings.
    func updateCenterSettingsSync(_ mutation: (inout CenterSectionSettings) -> Void) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        let oldSettings = layout.centerSettings
        mutation(&layout.centerSettings)
        let newSettings = layout.centerSettings
        LoggingService.shared.debug(
            "updateCenterSettingsSync: seekBackward \(oldSettings.seekBackwardSeconds) -> \(newSettings.seekBackwardSeconds), seekForward \(oldSettings.seekForwardSeconds) -> \(newSettings.seekForwardSeconds)",
            category: .general
        )
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        // Queue debounced save
        queueDebouncedSave(preset: preset)
    }

    /// Updates the global settings of the current layout.
    /// - Parameter settings: The new global settings.
    func updateGlobalSettings(_ settings: GlobalLayoutSettings) async {
        await updateLayout { layout in
            layout.globalSettings = settings
        }
    }

    /// Synchronously updates global settings with immediate UI feedback.
    /// Saves are debounced to avoid rapid disk writes.
    /// - Parameter mutation: A closure that mutates the global settings.
    func updateGlobalSettingsSync(_ mutation: (inout GlobalLayoutSettings) -> Void) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        mutation(&layout.globalSettings)
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        // Queue debounced save
        queueDebouncedSave(preset: preset)
    }

    /// Synchronously updates progress bar settings with immediate UI feedback.
    /// Saves are debounced to avoid rapid disk writes.
    /// - Parameter mutation: A closure that mutates the progress bar settings.
    func updateProgressBarSettingsSync(_ mutation: (inout ProgressBarSettings) -> Void) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        mutation(&layout.progressBarSettings)
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        // Queue debounced save
        queueDebouncedSave(preset: preset)
    }

    /// Updates a button configuration in the specified section.
    /// - Parameters:
    ///   - config: The updated button configuration.
    ///   - section: The section containing the button.
    func updateButtonConfiguration(_ config: ControlButtonConfiguration, in section: LayoutSectionType) async {
        await updateLayout { layout in
            switch section {
            case .top:
                layout.topSection.update(button: config)
            case .bottom:
                layout.bottomSection.update(button: config)
            }
        }
    }

    /// Synchronously updates a button configuration with immediate UI feedback.
    /// Saves are debounced to avoid rapid disk writes.
    /// - Parameters:
    ///   - config: The updated button configuration.
    ///   - section: The section containing the button.
    func updateButtonConfigurationSync(_ config: ControlButtonConfiguration, in section: LayoutSectionType) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        switch section {
        case .top:
            layout.topSection.update(button: config)
        case .bottom:
            layout.bottomSection.update(button: config)
        }
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        // Queue debounced save
        queueDebouncedSave(preset: preset)
    }

    /// Adds a button to the specified section.
    /// - Parameters:
    ///   - buttonType: The type of button to add.
    ///   - section: The section to add the button to.
    func addButton(_ buttonType: ControlButtonType, to section: LayoutSectionType) async {
        await updateLayout { layout in
            let config = ControlButtonConfiguration.defaultConfiguration(for: buttonType)
            switch section {
            case .top:
                layout.topSection.add(button: config)
            case .bottom:
                layout.bottomSection.add(button: config)
            }
        }
    }

    /// Synchronously adds a button with immediate UI feedback.
    /// - Parameters:
    ///   - buttonType: The type of button to add.
    ///   - section: The section to add the button to.
    func addButtonSync(_ buttonType: ControlButtonType, to section: LayoutSectionType) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        let config = ControlButtonConfiguration.defaultConfiguration(for: buttonType)
        switch section {
        case .top:
            layout.topSection.add(button: config)
        case .bottom:
            layout.bottomSection.add(button: config)
        }
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        queueDebouncedSave(preset: preset)
    }

    /// Removes a button from the specified section.
    /// - Parameters:
    ///   - buttonID: The ID of the button to remove.
    ///   - section: The section containing the button.
    func removeButton(_ buttonID: UUID, from section: LayoutSectionType) async {
        await updateLayout { layout in
            switch section {
            case .top:
                layout.topSection.remove(id: buttonID)
            case .bottom:
                layout.bottomSection.remove(id: buttonID)
            }
        }
    }

    /// Synchronously removes a button with immediate UI feedback.
    /// - Parameters:
    ///   - buttonID: The ID of the button to remove.
    ///   - section: The section containing the button.
    func removeButtonSync(_ buttonID: UUID, from section: LayoutSectionType) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        switch section {
        case .top:
            layout.topSection.remove(id: buttonID)
        case .bottom:
            layout.bottomSection.remove(id: buttonID)
        }
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        queueDebouncedSave(preset: preset)
    }

    /// Moves a button within a section.
    /// - Parameters:
    ///   - source: Source indices.
    ///   - destination: Destination index.
    ///   - section: The section containing the buttons.
    func moveButton(fromOffsets source: IndexSet, toOffset destination: Int, in section: LayoutSectionType) async {
        await updateLayout { layout in
            switch section {
            case .top:
                layout.topSection.move(fromOffsets: source, toOffset: destination)
            case .bottom:
                layout.bottomSection.move(fromOffsets: source, toOffset: destination)
            }
        }
    }

    /// Synchronously moves a button with immediate UI feedback.
    /// - Parameters:
    ///   - source: Source indices.
    ///   - destination: Destination index.
    ///   - section: The section containing the buttons.
    func moveButtonSync(fromOffsets source: IndexSet, toOffset destination: Int, in section: LayoutSectionType) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        switch section {
        case .top:
            layout.topSection.move(fromOffsets: source, toOffset: destination)
        case .bottom:
            layout.bottomSection.move(fromOffsets: source, toOffset: destination)
        }
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        queueDebouncedSave(preset: preset)
    }

    // MARK: - Gesture Settings

    /// Current gestures settings from active preset, or default.
    var gesturesSettings: GesturesSettings {
        activePreset?.layout.effectiveGesturesSettings ?? .default
    }

    /// Synchronously updates gestures settings with immediate UI feedback.
    /// Saves are debounced to avoid rapid disk writes.
    /// - Parameter mutation: A closure that mutates the gestures settings.
    func updateGesturesSettingsSync(_ mutation: (inout GesturesSettings) -> Void) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        var settings = layout.effectiveGesturesSettings
        mutation(&settings)
        layout.gesturesSettings = settings
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        queueDebouncedSave(preset: preset)
    }

    /// Synchronously updates tap gestures settings with immediate UI feedback.
    /// - Parameter mutation: A closure that mutates the tap gestures settings.
    func updateTapGesturesSettingsSync(_ mutation: (inout TapGesturesSettings) -> Void) {
        updateGesturesSettingsSync { settings in
            mutation(&settings.tapGestures)
        }
    }

    /// Updates a tap zone configuration.
    /// - Parameter config: The updated configuration.
    func updateTapZoneConfigurationSync(_ config: TapZoneConfiguration) {
        updateTapGesturesSettingsSync { settings in
            settings = settings.withUpdatedConfiguration(config)
        }
    }

    /// Current seek gesture settings from active preset, or default.
    var seekGestureSettings: SeekGestureSettings {
        activePreset?.layout.effectiveGesturesSettings.seekGesture ?? .default
    }

    /// Synchronously updates seek gesture settings with immediate UI feedback.
    /// - Parameter mutation: A closure that mutates the seek gesture settings.
    func updateSeekGestureSettingsSync(_ mutation: (inout SeekGestureSettings) -> Void) {
        updateGesturesSettingsSync { settings in
            mutation(&settings.seekGesture)
        }
    }

    /// Current panscan gesture settings from active preset, or default.
    var panscanGestureSettings: PanscanGestureSettings {
        activePreset?.layout.effectiveGesturesSettings.panscanGesture ?? .default
    }

    /// Synchronously updates panscan gesture settings with immediate UI feedback.
    /// - Parameter mutation: A closure that mutates the panscan gesture settings.
    func updatePanscanGestureSettingsSync(_ mutation: (inout PanscanGestureSettings) -> Void) {
        updateGesturesSettingsSync { settings in
            mutation(&settings.panscanGesture)
        }
    }

    // MARK: - Player Pill Settings

    /// Current player pill settings from active preset, or default.
    var playerPillSettings: PlayerPillSettings {
        activePreset?.layout.effectivePlayerPillSettings ?? .default
    }

    /// Current pill visibility mode.
    var pillVisibility: PillVisibility {
        playerPillSettings.visibility
    }

    /// Current pill buttons configuration.
    var pillButtons: [ControlButtonConfiguration] {
        playerPillSettings.buttons
    }

    /// Current comments pill mode.
    var commentsPillMode: CommentsPillMode {
        playerPillSettings.effectiveCommentsPillMode
    }

    /// Synchronously updates the comments pill mode with immediate UI feedback.
    /// - Parameter mode: The new comments pill mode.
    func syncCommentsPillMode(_ mode: CommentsPillMode) {
        updatePlayerPillSettingsSync { settings in
            settings.commentsPillMode = mode
        }
    }

    // MARK: - Wide Layout Panel Settings

    /// Current wide layout panel alignment from active preset, or default.
    var wideLayoutPanelAlignment: FloatingPanelSide {
        activePreset?.layout.effectiveWideLayoutPanelAlignment ?? .right
    }

    /// Synchronously updates the wide layout panel alignment with immediate UI feedback.
    /// - Parameter alignment: The new panel alignment.
    func syncWideLayoutPanelAlignment(_ alignment: FloatingPanelSide) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        layout.wideLayoutPanelAlignment = alignment
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        queueDebouncedSave(preset: preset)
    }

    /// Synchronously updates the pill visibility with immediate UI feedback.
    /// - Parameter visibility: The new visibility mode.
    func syncPillVisibility(_ visibility: PillVisibility) {
        updatePlayerPillSettingsSync { settings in
            settings.visibility = visibility
        }
    }

    /// Adds a button to the pill.
    /// - Parameter buttonType: The type of button to add.
    func addPillButton(_ buttonType: ControlButtonType) {
        updatePlayerPillSettingsSync { settings in
            settings.add(buttonType: buttonType)
        }
    }

    /// Removes a button from the pill at the given index.
    /// - Parameter index: The index of the button to remove.
    func removePillButton(at index: Int) {
        updatePlayerPillSettingsSync { settings in
            settings.remove(at: index)
        }
    }

    /// Moves buttons within the pill.
    /// - Parameters:
    ///   - source: Source indices to move from.
    ///   - destination: Destination index to move to.
    func movePillButtons(fromOffsets source: IndexSet, toOffset destination: Int) {
        updatePlayerPillSettingsSync { settings in
            settings.move(fromOffsets: source, toOffset: destination)
        }
    }

    /// Updates a specific button configuration in the pill.
    /// - Parameter configuration: The updated button configuration with matching ID.
    func updatePillButtonConfiguration(_ configuration: ControlButtonConfiguration) {
        updatePlayerPillSettingsSync { settings in
            settings.update(configuration)
        }
    }

    /// Synchronously updates player pill settings with immediate UI feedback.
    /// Saves are debounced to avoid rapid disk writes.
    /// - Parameter mutation: A closure that mutates the pill settings.
    func updatePlayerPillSettingsSync(_ mutation: (inout PlayerPillSettings) -> Void) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        var settings = layout.effectivePlayerPillSettings
        mutation(&settings)
        layout.playerPillSettings = settings
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        queueDebouncedSave(preset: preset)
    }

    // MARK: - Mini Player Settings

    /// Current mini player settings from active preset, or default.
    var miniPlayerSettings: MiniPlayerSettings {
        activePreset?.layout.effectiveMiniPlayerSettings ?? .default
    }

    /// Whether to show video in mini player.
    var miniPlayerShowVideo: Bool {
        miniPlayerSettings.showVideo
    }

    /// Action when tapping video in mini player.
    var miniPlayerVideoTapAction: MiniPlayerVideoTapAction {
        miniPlayerSettings.videoTapAction
    }

    /// Current mini player buttons configuration.
    var miniPlayerButtons: [ControlButtonConfiguration] {
        miniPlayerSettings.buttons
    }

    /// Synchronously updates the mini player show video setting.
    /// - Parameter showVideo: Whether to show video in mini player.
    func syncMiniPlayerShowVideo(_ showVideo: Bool) {
        updateMiniPlayerSettingsSync { settings in
            settings.showVideo = showVideo
        }
    }

    /// Synchronously updates the mini player video tap action.
    /// - Parameter action: The new tap action.
    func syncMiniPlayerVideoTapAction(_ action: MiniPlayerVideoTapAction) {
        updateMiniPlayerSettingsSync { settings in
            settings.videoTapAction = action
        }
    }

    /// Adds a button to the mini player.
    /// - Parameter buttonType: The type of button to add.
    func addMiniPlayerButton(_ buttonType: ControlButtonType) {
        updateMiniPlayerSettingsSync { settings in
            settings.add(buttonType: buttonType)
        }
    }

    /// Removes a button from the mini player at the given index.
    /// - Parameter index: The index of the button to remove.
    func removeMiniPlayerButton(at index: Int) {
        updateMiniPlayerSettingsSync { settings in
            settings.remove(at: index)
        }
    }

    /// Moves buttons within the mini player.
    /// - Parameters:
    ///   - source: Source indices to move from.
    ///   - destination: Destination index to move to.
    func moveMiniPlayerButtons(fromOffsets source: IndexSet, toOffset destination: Int) {
        updateMiniPlayerSettingsSync { settings in
            settings.move(fromOffsets: source, toOffset: destination)
        }
    }

    /// Updates a specific button configuration in the mini player.
    /// - Parameter configuration: The updated button configuration with matching ID.
    func updateMiniPlayerButtonConfiguration(_ configuration: ControlButtonConfiguration) {
        updateMiniPlayerSettingsSync { settings in
            settings.update(configuration)
        }
    }

    /// Synchronously updates mini player settings with immediate UI feedback.
    /// Saves are debounced to avoid rapid disk writes.
    /// - Parameter mutation: A closure that mutates the mini player settings.
    func updateMiniPlayerSettingsSync(_ mutation: (inout MiniPlayerSettings) -> Void) {
        guard var preset = activePreset, !preset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = preset.layout
        var settings = layout.effectiveMiniPlayerSettings
        mutation(&settings)
        layout.miniPlayerSettings = settings
        preset = preset.withUpdatedLayout(layout)
        self.activePreset = preset

        queueDebouncedSave(preset: preset)
    }

    // MARK: - System Controls & Volume

    /// Current system controls mode from active preset, or default.
    var systemControlsMode: SystemControlsMode {
        activePreset?.layout.globalSettings.systemControlsMode ?? .seek
    }

    /// Current system controls seek duration from active preset, or default.
    var systemControlsSeekDuration: SystemControlsSeekDuration {
        activePreset?.layout.globalSettings.systemControlsSeekDuration ?? .tenSeconds
    }

    /// Current volume mode from active preset, or default.
    var volumeMode: VolumeMode {
        activePreset?.layout.globalSettings.volumeMode ?? .mpv
    }

    /// Synchronously updates the system controls mode with immediate UI feedback.
    func updateSystemControlsModeSync(_ mode: SystemControlsMode) {
        updateGlobalSettingsSync { settings in
            settings.systemControlsMode = mode
        }
    }

    /// Synchronously updates the system controls seek duration with immediate UI feedback.
    func updateSystemControlsSeekDurationSync(_ duration: SystemControlsSeekDuration) {
        updateGlobalSettingsSync { settings in
            settings.systemControlsSeekDuration = duration
        }
    }

    /// Synchronously updates the volume mode with immediate UI feedback.
    func updateVolumeModeSync(_ mode: VolumeMode) {
        updateGlobalSettingsSync { settings in
            settings.volumeMode = mode
        }
    }

    // MARK: - Private Helpers

    /// Updates the layout and saves to storage.
    /// - Parameter mutation: A closure that mutates the layout.
    private func updateLayout(_ mutation: (inout PlayerControlsLayout) -> Void) async {
        guard let activePreset, !activePreset.isBuiltIn else {
            error = "Cannot edit built-in presets. Duplicate it first."
            return
        }

        var layout = activePreset.layout
        mutation(&layout)

        // Update local state immediately for responsive UI
        self.activePreset = activePreset.withUpdatedLayout(layout)

        // Save to storage
        isSaving = true
        do {
            try await layoutService.updatePresetLayout(activePreset.id, layout: layout)
            await refreshPresets()
        } catch {
            self.error = error.localizedDescription
            LoggingService.shared.error("Failed to save layout: \(error.localizedDescription)")
        }
        isSaving = false
    }

    /// Queues a debounced save operation.
    /// Cancels any pending save and waits before persisting to avoid rapid disk writes.
    /// - Parameter preset: The preset to save.
    private func queueDebouncedSave(preset: LayoutPreset) {
        saveTask?.cancel()
        saveTask = Task {
            // Wait for 300ms to coalesce rapid changes (e.g., slider dragging)
            try? await Task.sleep(for: .milliseconds(300))
            guard !Task.isCancelled else { return }

            isSaving = true
            do {
                try await layoutService.updatePresetLayout(preset.id, layout: preset.layout)
                // Don't call refreshPresets() here - we already have the updated state locally
            } catch {
                self.error = error.localizedDescription
                LoggingService.shared.error("Failed to save layout: \(error.localizedDescription)")
            }
            isSaving = false
        }
    }

    // MARK: - NEW Badge Support

    /// Marks all button types as seen, hiding NEW badges.
    func markAllButtonsAsSeen() async {
        await layoutService.markAllButtonsAsSeen()
    }

    /// Returns whether a button type should show the NEW badge.
    /// - Parameter type: The button type to check.
    /// - Returns: True if the button was added after the last seen version.
    func isNewButton(_ type: ControlButtonType) async -> Bool {
        let newTypes = await layoutService.newButtonTypes()
        return newTypes.contains(type)
    }

    // MARK: - Error Handling

    /// Clears the current error.
    func clearError() {
        error = nil
    }

    // MARK: - Export/Import

    /// Exports a preset to a temporary JSON file.
    /// - Parameter preset: The preset to export.
    /// - Returns: URL of the temporary file, or nil if export failed.
    func exportPreset(_ preset: LayoutPreset) -> URL? {
        guard !preset.isBuiltIn else {
            error = "Cannot export built-in presets"
            return nil
        }

        guard let data = PlayerControlsPresetExportImport.exportToJSON(preset) else {
            error = "Failed to export preset"
            return nil
        }

        let filename = PlayerControlsPresetExportImport.generateExportFilename(for: preset)
        let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent(filename)

        do {
            try data.write(to: tempURL)
            LoggingService.shared.info("Exported preset '\(preset.name)' to \(tempURL.path)")
            return tempURL
        } catch {
            self.error = "Failed to write export file: \(error.localizedDescription)"
            LoggingService.shared.error("Failed to write export file: \(error.localizedDescription)")
            return nil
        }
    }

    /// Imports a preset from a file URL.
    /// - Parameter url: URL of the JSON file to import.
    /// - Returns: The imported preset name on success.
    /// - Throws: `LayoutPresetImportError` if import fails.
    @discardableResult
    func importPreset(from url: URL) async throws -> String {
        // Read file data with security-scoped resource access
        let data: Data
        let didStartAccessing = url.startAccessingSecurityScopedResource()
        defer {
            if didStartAccessing {
                url.stopAccessingSecurityScopedResource()
            }
        }

        do {
            data = try Data(contentsOf: url)
        } catch {
            LoggingService.shared.error("Failed to read import file: \(error.localizedDescription)")
            throw LayoutPresetImportError.invalidData
        }

        // Parse and validate the preset
        let importedPreset = try PlayerControlsPresetExportImport.importFromJSON(data)

        // Save the preset
        do {
            try await layoutService.savePreset(importedPreset)
            await refreshPresets()
            LoggingService.shared.info("Imported preset: \(importedPreset.name)")
            return importedPreset.name
        } catch {
            self.error = error.localizedDescription
            LoggingService.shared.error("Failed to save imported preset: \(error.localizedDescription)")
            throw LayoutPresetImportError.invalidData
        }
    }
}