app.py

import os
import random
import sys
from pathlib import Path
import time
import webbrowser

from PySide6.QtWidgets import (
    QApplication,
    QMainWindow,
    QWidget,
    QVBoxLayout,
    QHBoxLayout,
    QFrame,
    QPushButton,
    QLabel,
    QFileDialog,
    QSizePolicy,
)
from PySide6.QtCore import Qt, QTimer, Signal, QSize
from PySide6.QtGui import QKeyEvent, QMouseEvent, QMoveEvent, QResizeEvent, QIcon, QShowEvent, QPalette

from app_types import DeleteSelectionAction, SeekAction, SegmentPlayMode, FilePlayMode, SelectionBeginAction, SelectionCompleteAction
from app_state import AppState
from buttons_dialog import ButtonsDialog, ButtonSpec
from clickable_label import ClickableLabel
from constants import *
from directory_operations_util import DirectoryOperationsUtil
from confirmable_dialog import ConfirmableDialog, ConfirmableButtonSpec
from silence_util import SilenceUtil
from sound_file_util import SoundFileUtil
from sound_files_util import SoundFilesUtil
from sound_loader import SoundLoader
from sound_util import SoundUtil
from timeline import Timeline, TimelineMouseAction
from settings import Settings
from segments import Segments
from stream import Stream
from sound import Sound
from sound_state import SoundState
from app_util import AppUtil
from util import *


class App(QMainWindow):
    """
    PySide6 main window and app logic
    """

    # Signal for cross-thread communication when sound loading completes
    _load_complete_signal = Signal(object, str)  # arguments: Sound | None, file path


    def __init__(self):
        super().__init__()

        # Connect cross-thread signal for sound loading
        self._load_complete_signal.connect(self._load_sound_continued)

        # Load settings and related
        self._settings = Settings.load()
        self._override_settings_using_argv() 
        self._startup_info: dict | None = {
            "last_position": self._settings.last_position,
            "play_mode": self._settings.play_mode
        }

        self._stream = Stream()
        self._stream.compressor_enabled = self._settings.compressor_enabled

        self._state = SoundState(file_path="", sound=None)
        self._loader = SoundLoader()
 
        self._mouse_pos = (0, 0)
        
        # Init UI
        self._init_ui()

        # Create AppState
        self._app_state = AppState(self._settings, self._stream, self._timeline)
        # Sync initial zoom
        self._app_state.set_timeline_zoom(self._settings.timeline_zoom)

        self._window_rect_timer = QTimer(self)
        self._window_rect_timer.setSingleShot(True)
        self._window_rect_timer.timeout.connect(self._on_window_rect_complete)
        
        self._interval_timer = QTimer(self)
        self._interval_timer.timeout.connect(self._on_interval)
        self._interval_timer.start(16) 
        
        # Load initial sound (rem, async)
        self._load_sound_using_current_state()

    def _override_settings_using_argv(self) -> None:
        
        if len(sys.argv) <= 1:
            return
        arg_path = sys.argv[1].strip()
        if not arg_path:
            return
        if not os.path.exists(arg_path):
            print(f"* Ignoring argument, path doesn't exist: [{arg_path}]")
            return
        
        if os.path.isdir(arg_path):
            # Argument is a directory
            if self._settings.dir_path == arg_path:
                ... # Do nothing
            else:
                self._settings.set_dir_and_print(arg_path)
            return
        
        # Is file - attempt to set its directory and file index
        dir_path = str(Path(arg_path).parent)
        temp_prefs = Settings()
        temp_prefs.dir_path = dir_path

        try:
            index = temp_prefs._file_paths.index(arg_path)
        except:
            index = -1
        if index == -1:
            print(f"* Ignoring argument, unsupported file type: [{arg_path}]")
            return
        is_already_at_file = (self._settings.dir_path == dir_path and self._settings.file_name == Path(arg_path).name)
        if is_already_at_file:
            # Continue silently
            return
        
        self._settings.set_dir_and_print(dir_path)
        self._settings.file_name = Path(arg_path).name

    def _init_ui(self) -> None:
        """Create all UI elements mirroring app.py layout"""
        
        self.setWindowTitle(WINDOW_TITLE)
        self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowMaximizeButtonHint)
        self.setMinimumWidth(500)
        self.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)

        # Central widget and main layout
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        main_layout = QVBoxLayout(central_widget)
        main_layout.setContentsMargins(10, 10, 10, 10)
        main_layout.setSpacing(10)
        
        # === Header Frame ===
        header_frame = QFrame()
        header_frame.setObjectName("headerFrame")
        header_layout = QHBoxLayout(header_frame)
        header_layout.setContentsMargins(0, 0, 0, 0)
        header_layout.setSpacing(5)
        
        # Select dir button
        self._dir_button = QPushButton("Select dir")
        self._dir_button.setStyleSheet(f"padding: 8px;")
        self._dir_button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
        self._dir_button.clicked.connect(self._select_and_set_directory)
        header_layout.addWidget(self._dir_button)
        
        # File info frame (contains dir and file labels)
        file_info_frame = QFrame()
        file_info_frame.setObjectName("fileInfoFrame")
        file_info_layout = QVBoxLayout(file_info_frame)
        file_info_layout.setContentsMargins(5, 0, 5, 0)
        file_info_layout.setSpacing(0)
        
        # Directory label
        self.dir_label = QLabel("")
        self.dir_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        file_info_layout.addWidget(self.dir_label)
        
        # File label
        self.file_label = QLabel("")
        self.file_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        file_info_layout.addWidget(self.file_label)
        
        header_layout.addWidget(file_info_frame, 1)  # Stretch factor 1
        
        # Right-side labels frame (contains fast mode and start-end auto labels)
        right_labels_frame = QFrame()
        right_labels_frame.setObjectName("rightLabelsFrame")
        right_labels_layout = QVBoxLayout(right_labels_frame)
        right_labels_layout.setContentsMargins(0, 0, 0, 0)
        right_labels_layout.setSpacing(0)
        
        # Fast mode label (top-right)
        self._fast_mode_label = ClickableLabel()
        self._fast_mode_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        self._fast_mode_label.clicked.connect(self._on_fast_mode_label_click)
        self._update_togglable_label(
            self._fast_mode_label, "Fast mode", self._settings.fast_mode
        )
        right_labels_layout.addWidget(self._fast_mode_label)
        
        # Auto-trim label (below fast mode label)
        self._start_end_auto_label = ClickableLabel()
        self._start_end_auto_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        self._start_end_auto_label.clicked.connect(self._on_start_end_auto_label_click)
        self._update_togglable_label(
            self._start_end_auto_label, "Start/end auto", self._settings.start_end_auto
        )
        right_labels_layout.addWidget(self._start_end_auto_label)
        
        header_layout.addWidget(right_labels_frame, 0)  # No stretch
        
        # Help button
        self._help_button = QPushButton("?")
        self._help_button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
        # self._help_button.setFixedWidth(25)
        self._help_button.setStyleSheet(f"padding: 8px;")
        self._help_button.clicked.connect(self._on_help_button)
        header_layout.addSpacing(5)
        header_layout.addWidget(self._help_button)

        # ...

        main_layout.addWidget(header_frame)
        
        # Timeline Widget
        self._timeline = Timeline(self)
        self._timeline.canvas_clicked.connect(self._on_timeline_click)
        main_layout.addWidget(self._timeline)
        
        # Play/pause button and sound info label container
        info_container = QWidget()
        info_layout = QHBoxLayout(info_container)
        info_layout.setContentsMargins(0, 0, 0, 0)
        info_layout.setSpacing(4)
        
        # Play/pause button
        self._play_pause_button = QPushButton()
        self._play_pause_button.setIcon(QIcon("assets/play_icon.svg"))
        self._play_pause_button.setIconSize(QSize(20, 20))
        self._play_pause_button.setFixedSize(28, 28)
        self._play_pause_button.clicked.connect(self._toggle_pause)
        self._play_pause_button.setFocusPolicy(Qt.FocusPolicy.NoFocus) 
        info_layout.addWidget(self._play_pause_button)
        
        # Sound info label
        self.sound_info_label = QLabel()
        self.sound_info_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
        info_layout.addWidget(self.sound_info_label)
        
        # Right-aligned labels container
        right_labels_container = QWidget()
        right_labels_layout = QVBoxLayout(right_labels_container)
        right_labels_layout.setContentsMargins(0, 0, 0, 0)
        right_labels_layout.setSpacing(0)
        
        self._mouse_prompt_label = QLabel("")
        self._mouse_prompt_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        palette = self._mouse_prompt_label.palette()
        palette.setColor(QPalette.ColorRole.WindowText, QCOLOR_MEDIUM_GRAY)
        self._mouse_prompt_label.setPalette(palette)
        self._mouse_prompt_label.setAutoFillBackground(True)
        right_labels_layout.addWidget(self._mouse_prompt_label)
        
        self._compressor_label = ClickableLabel("")
        self._compressor_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
        self._compressor_label.setContentsMargins(0, 3, 0, 0)
        right_labels_layout.addWidget(self._compressor_label)
        self._compressor_label.clicked.connect(self._on_compressor_label_click)
        self._update_togglable_label(
            self._compressor_label, "Compressor", self._settings.compressor_enabled
        )
        
        right_labels_container.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
        info_layout.addWidget(right_labels_container)
        
        main_layout.addWidget(info_container)
        
        self._update_header()
        self._restore_window_geometry()

    def _restore_window_geometry(self) -> None:
        """Restore window position and size from preferences"""
        w = self._settings.window_width
        h = self.sizeHint().height()
        x, y = self._settings.window_position
        
        # Compensate for window frame (titlebar) on Linux
        # frameGeometry() includes decorations, geometry() does not
        frame_height = self.frameGeometry().height() - self.geometry().height()
        y += frame_height  # Add titlebar height to saved position
        
        # Clamp position within screen
        screen = QApplication.primaryScreen()
        if screen:
            screen_geometry = screen.availableGeometry()
            x = max(0, min(x, screen_geometry.width() - w // 2))
            y = max(0, min(y, screen_geometry.height() - h // 2))
        
        self.setGeometry(x, y, w, h)

    def _select_and_set_directory(self) -> None:
        """ Show directory selection dialog """
        initial_dir = self._settings.dir_path if self._settings.dir_path and Path(self._settings.dir_path).exists() else ""        
        path = QFileDialog.getExistingDirectory(
            self,
            "Select directory containing sound files",
            initial_dir,
        )
        if not path:
            return
        self._settings.set_dir_and_print(path)
        self._load_sound_using_current_state()

    def _select_directory_and_file(self) -> None:
        """ 
        Show file selection dialog, etc
        """
        initial_dir = self._settings.dir_path if self._settings.dir_path and Path(self._settings.dir_path).exists() else ""
        filter_string = "Supported media (" + " ".join(f"*{s}" for s in SoundFileUtil.MEDIA_FILE_SUFFIXES) + ")"
        path, _ = QFileDialog.getOpenFileName(
            self,
            caption="Select sound file (and its parent directory)",
            dir=initial_dir,
            filter=filter_string
        )
        if not path:
            return

        dir_path = str(Path(path).parent)
        temp_prefs = Settings()
        temp_prefs.dir_path = dir_path
        try:
            index = temp_prefs._file_paths.index(path)
        except:
            index = -1
        if index == -1:
            print(f"Unsupported file type, ignoring: {path}")
            return
        is_already_at_file = (self._settings.dir_path == dir_path and self._settings.file_name == Path(path).name)
        if is_already_at_file:
            print(f"File already open, ignoring: {path}")
            return
        
        self._on_sound_blur()

        self._settings.set_dir_and_print(dir_path)
        self._settings.file_name = Path(path).name
        self._load_sound_using_current_state()

    def _toggle_pause(self) -> None:
        if self._state.has_sound:
            if self._stream.paused:
                self._stream.unpause()
            else:
                self._stream.pause()

    def _toggle_start_end_auto(self) -> None:
        self._settings.start_end_auto = not self._settings.start_end_auto
        self._update_togglable_label(
            self._start_end_auto_label, "Start/end auto", self._settings.start_end_auto
        )
        if self._settings.start_end_auto:
            self._set_start_end_using_silence()

    def _cycle_file_play_mode(self) -> None:
        # Cycles play mode between FilePlayMode types
        if isinstance(self.play_mode, SegmentPlayMode):
            self.play_mode = FilePlayMode.DEFAULT
        else:
            match self.play_mode:
                case FilePlayMode.DEFAULT:
                    self.play_mode = FilePlayMode.REPEAT_SINGLE
                case FilePlayMode.REPEAT_SINGLE:
                    self.play_mode = FilePlayMode.TO_END
                case FilePlayMode.TO_END:
                    self.play_mode = FilePlayMode.TO_END_REPEAT
                case FilePlayMode.TO_END_REPEAT:
                    self.play_mode = FilePlayMode.RANDOM_NEXT
                case FilePlayMode.RANDOM_NEXT:
                    self.play_mode = FilePlayMode.DEFAULT
                case _:
                    ... # shouldn't happen

    def _cycle_segment_play_mode(self) -> None:
        """ Cycles play mode between SegmentPlayMode types """
        
        if not self._state.has_sound and not self._state.has_segments:
            # Ignore because no segments
            return
        
        if isinstance(self.play_mode, FilePlayMode):
            # Transition from any FilePlayMode to first SegmentPlayMode
            self.play_mode = SegmentPlayMode.TO_END
        else:
            match self.play_mode:
                case SegmentPlayMode.TO_END:
                    self.play_mode = SegmentPlayMode.REPEAT_ALL
                case SegmentPlayMode.REPEAT_ALL:
                    self.play_mode = SegmentPlayMode.REPEAT_SINGLE
                case SegmentPlayMode.REPEAT_SINGLE:
                    # Transition from last SegmentPlayMode to default FilePlayMode
                    self.play_mode = FilePlayMode.DEFAULT

    def _get_subtitle(self) -> str:
        return self._state.get_subtitle_at(self._stream.position)
    
    def _update_togglable_label(
            self, label: QLabel, prefix: str, value: bool, true_string="On", false_string="Off"
    ) -> None:
        prefix = f'<span style="color: #888888">{prefix}: </span>'
        value_string = true_string if value else false_string
        value_color = "#ffffff" if value else "#888888"
        value_string = f'<span style="color: {value_color};">{value_string}</span>'
        label.setText(f'{prefix} {value_string}')

    def _save_sound(self) -> bool:
        """ Returns True on success """
        assert self._state.sound 
        err = SoundFileUtil.rewrite_flac(self._state.sound, self._state.file_path)
        if err:
            print(f"* {err}")
            return False
        self._state.sound_dirty = False
        print(f"Saved {self._state.file_path}")
        return True

    # ------------------------------------------
    # Event handlers and 'pseudo event' handlers 

    def _on_interval(self) -> None:
        """ Runs on an interval. Is UI thread. """

        # Check if stream is running
        if self._stream._stream and not self._stream._stream.active:
            print("* CRITICAL: sounddevice inactive")

        # Check for stream completion events from audio thread (non-blocking)
        if self._stream.get_completion_event():
            self._on_stream_complete()

        # Playhead
        # TODO: this should be done in a separate callback
        self._timeline.playhead_position = self._stream.position

        # Update play/pause button icon
        self._update_play_pause_button()

        # Play info text
        text, color = self._get_play_info_text()
        if text != self.sound_info_label.text():
            self.sound_info_label.setText(text)
            self.sound_info_label.setStyleSheet(f"color: {color};")

        # Subtitle text
        subtitle = self._get_subtitle()
        self._timeline.set_subtitle_text(subtitle)

        # Mouse prompt
        self._timeline.update_mouse_prompt()
        if self._timeline.mouse_prompt != self._mouse_prompt_label.text():
            self._mouse_prompt_label.setText(self._timeline.mouse_prompt)

        # Draw
        self._timeline.update()

    def _update_play_pause_button(self) -> None:
        """Update play/pause button icon based on stream state"""
        if self._stream.paused:
            self._play_pause_button.setIcon(QIcon("assets/play_icon.svg"))
        else:
            self._play_pause_button.setIcon(QIcon("assets/pause_icon.svg"))
    
        
    def keyPressEvent(self, event: QKeyEvent) -> None:
        """ Handles keyboard input """
        
        key = event.key()
        modifiers = event.modifiers()
        
        # Quit
        if key == Qt.Key.Key_C and modifiers == Qt.KeyboardModifier.ControlModifier:
            self._do_quit()
            return
        
        # Ignore input while loading
        if self.ignore_user_input:
            return
        
        # ---
        
        # Playback/seek related
        if key == Qt.Key.Key_Space:
            if self._state.sound and self._stream.is_at_end:
                # If at end of playable area, restart
                self._stream.position = 0.0
                self._stream.unpause()
            else:
                # Default behavior
                self._toggle_pause()
        elif key == Qt.Key.Key_P:
            if modifiers == Qt.KeyboardModifier.ShiftModifier:
                # Seek near end and play
                self._stream.position = self._timeline.max_position - 1.5
                self._stream.unpause()
            else:
                # Seek to start and play
                self._stream.position = 0.0
                self._stream.unpause()
        # Seek forward
        elif key == Qt.Key.Key_Greater:
            delta = 0.1
            self._stream.position += delta
        elif key == Qt.Key.Key_Period:
            if modifiers == Qt.KeyboardModifier.NoModifier:
                delta = 1
            elif modifiers == Qt.KeyboardModifier.AltModifier:
                delta = 10
            elif modifiers == Qt.KeyboardModifier.ControlModifier:
                delta = 60
            elif modifiers == (Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.AltModifier):
                delta = 60 * 15  # 15 minutes
            else:
                return
            self._stream.position += delta
        # Seek back
        elif key == Qt.Key.Key_Less:
            delta = 0.1
            self._stream.position -= delta
        elif key == Qt.Key.Key_Comma:
            if modifiers == Qt.KeyboardModifier.NoModifier:
                delta = 1
            elif modifiers == Qt.KeyboardModifier.AltModifier:
                delta = 10
            elif modifiers == Qt.KeyboardModifier.ControlModifier:
                delta = 60
            elif modifiers == (Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.AltModifier):
                delta = 60 * 15  # 15 minutes
            else:
                return
            self._stream.position -= delta
        # Seek start/end
        elif key == Qt.Key.Key_Home:
            self._stream.position = 0.0
        elif key == Qt.Key.Key_End:
            self._stream.position = (self._state.sound.duration if self._state.sound else 0)
        # Seek to next/previous segment
        elif key == Qt.Key.Key_Apostrophe:
            self._seek_next_segment(True)
        elif key == Qt.Key.Key_Semicolon:
            self._seek_next_segment(False)
        
        elif key == Qt.Key.Key_R:
            # Cycle file play mode
            if modifiers == Qt.KeyboardModifier.NoModifier:
                self._cycle_file_play_mode()
            # Reload (without saving)
            elif modifiers == Qt.KeyboardModifier.ControlModifier:
                self._load_sound_using_current_state()

        # Set start/end position
        elif key in [Qt.Key.Key_1, Qt.Key.Key_2]:
            self._set_start_end_position_using_mouse(is_start=(key == Qt.Key.Key_1))
        
        # Clear any segment start marker
        elif key == Qt.Key.Key_Escape and modifiers == Qt.KeyboardModifier.NoModifier:
            self._timeline.segment_start = -1

        elif key == Qt.Key.Key_M:
            # Turn off segment play mode
            if modifiers == Qt.KeyboardModifier.ShiftModifier:
                if isinstance(self.play_mode, SegmentPlayMode):
                    self.play_mode = FilePlayMode.DEFAULT 
            else:
                # Cycle segment play mode
                if (self._state.has_sound and self._state.has_segments):            
                    self._cycle_segment_play_mode()    
                else:
                    print("Can't set segment mode, no segments defined")
                
        # Invert segments
        elif key == Qt.Key.Key_I:
            did = self._state.invert_segments()
            if did:
                self._on_segments_changed()
            print("Inverted segments" if did else "No segments to invert")

        # Add silence segment at playhead
        elif key == Qt.Key.Key_9:
            if self._state.sound:
                silence_segment = SilenceUtil.detect_silence_boundaries_from(self._state.sound, self._stream.position)
                if silence_segment:
                    index = self._state.insert_segment(silence_segment[0], silence_segment[1], can_merge=False)
                    if index == -1:
                        print(f"Couldn't add segment {silence_segment}")
                        return
                    self._on_segments_changed()
                else:
                    print(f"No silence at {self._stream.position}")

        # Navigate between files
        elif key == Qt.Key.Key_BracketLeft:
            self._load_sound_by_increment(-1)        
        elif key == Qt.Key.Key_BracketRight:
            self._load_sound_by_increment(1)
        elif key == Qt.Key.Key_BraceLeft:
            self._load_sound_by_increment(-10)
        elif key == Qt.Key.Key_BraceRight:
            self._load_sound_by_increment(10)
        elif key == Qt.Key.Key_Home and Qt.KeyboardModifier.ControlModifier:
            self._load_sound_by_index(0)
        elif key == Qt.Key.Key_End and Qt.KeyboardModifier.ControlModifier:
            index = len(self._settings.file_paths) - 1
            self._load_sound_by_index(index)

        # Zoom level
        elif key == Qt.Key.Key_Equal or key == Qt.Key.Key_Plus:
            self._increment_zoom(+0.1)
        elif key == Qt.Key.Key_Minus:
            self._increment_zoom(-0.1)

        elif key == Qt.Key.Key_O:
            # Select directory
            if modifiers == Qt.KeyboardModifier.NoModifier:
                self._select_and_set_directory()
            # Select directory - next/previous 
            elif modifiers == Qt.KeyboardModifier.ShiftModifier:
                self._select_adjacent_directory(previous=False)
            elif modifiers == Qt.KeyboardModifier.AltModifier:
                self._select_adjacent_directory(previous=True)
            # Select directory and file
            elif modifiers == Qt.KeyboardModifier.ControlModifier:
                self._select_directory_and_file()

        elif key == Qt.Key.Key_T:
            if modifiers == Qt.KeyboardModifier.NoModifier:
                # Set start-end using silence
                self._set_start_end_using_silence()
            elif modifiers == Qt.KeyboardModifier.ShiftModifier:
                # Start-end auto toggle    
                self._toggle_start_end_auto()
            elif modifiers == Qt.KeyboardModifier.ControlModifier:
                # Trim sound using start/end
                self._edit_sound_using_start_end()
        
        elif key == Qt.Key.Key_X:
            if modifiers == Qt.KeyboardModifier.ControlModifier:
                # Cut segments
                self._edit_sound_using_segments(is_inverse=True) # nb, True
            elif modifiers == (Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier):
                # Cut segments inverse
                self._edit_sound_using_segments(is_inverse=False)

        elif key == Qt.Key.Key_N and modifiers == Qt.KeyboardModifier.ControlModifier:
            if self._state.sound:
                DB = -3.0
                new_sound = SoundUtil.normalize(self._state.sound, DB)
                self._update_state_using_sound(new_sound)
                print(f"Peak normalized {DB}db")

        # Compressor
        elif key == Qt.Key.Key_C:
            self._set_compressor_enabled(not self._settings.compressor_enabled)

        # Delete sound        
        elif key == Qt.Key.Key_Delete:
            self._do_delete_current_sound()

        elif key == Qt.Key.Key_S:
            if modifiers == Qt.KeyboardModifier.ControlModifier:
                # Manual save
                if self._state.sound and self._state.sound_dirty:
                    self._save_sound()
                    self._update_header()
                else:
                    print("Nothing to save")
            else:
                # Split files dialog
                self._split_dialog()

        # Directory-wide save operations dialog  
        elif key == Qt.Key.Key_D:
            self._dir_op_dialog()

        else:
            super().keyPressEvent(event)

    def wheelEvent(self, event):
        """Handle mouse wheel for zooming."""
        delta = event.angleDelta().y()
        increment = 0.02 if delta > 0 else -0.02
        self._increment_zoom(increment)
        event.accept()

    def mouseMoveEvent(self, event: QMouseEvent) -> None:
        """Track mouse position"""
        self._mouse_pos = (event.position().x(), event.position().y())
        super().mouseMoveEvent(event)

    def moveEvent(self, event: QMoveEvent) -> None:
        """ Handle window move """
        self._window_rect_timer.start(500)  # Debounce 500ms
        super().moveEvent(event)

    def resizeEvent(self, event: QResizeEvent) -> None:
        """ Handle window resize """
        self._window_rect_timer.start(500)  # Debounce 500ms
        super().resizeEvent(event)

    def showEvent(self, event: QShowEvent) -> None:
        """Lock window height after initial display"""
        super().showEvent(event)
        self.setFixedHeight(self.height())

    def closeEvent(self, event) -> None:
        """Handle window close, save some settings values"""
        self._interval_timer.stop()

        # Timeline zoom is already synced via AppState
        self._settings.set_window_geometry(self.x(), self.y(), self.width())

        event.accept()

    def _on_window_rect_complete(self) -> None:
        """Save window geometry after debounce"""
        self._settings.set_window_geometry(self.x(), self.y(), self.width())

    def _on_timeline_click(self, mouse_action: TimelineMouseAction) -> None:

        if self.ignore_user_input:
            return
        if not self._state.sound:
            return

        print(mouse_action)

        match mouse_action:

            case SeekAction(position):
                 self._stream.position = position

            case DeleteSelectionAction(index):
                assert self._state.segments
                segment = self._state.segments.segments[index]
                self._state.delete_segment_at(index)
                print(f"Deleted selection {segment}")
                self._on_segments_changed()

            case SelectionBeginAction(begin_position, _):
                # First click: set start point
                self._timeline.segment_start = begin_position

            case SelectionCompleteAction(complete_position, begin_position, _):
                # Second click: complete the selection
                # Normalize: ensure start < end
                start = min(begin_position, complete_position)
                end = max(begin_position, complete_position)

                # Insert segment
                index = self._state.insert_segment(start, end, can_merge=True)
                if index == -1:
                    print(f"Couldn't add selection {make_position_range_string(start, end)}")
                    return

                print(f"Added selection {make_position_range_string(start, end)}")
                self._timeline.segment_start = -1  # Reset start marker
                self._on_segments_changed()

            case _:
                ...
                # xxx assert_never(mouse_action)


        # typ = mouse_action.typ
        # value = mouse_action.value

        # match typ:

        #     case TimelineMouseActionType.SELECTION_BEGIN_START | \
        #         TimelineMouseActionType.SELECTION_BEGIN_START_SILENCE | \
        #         TimelineMouseActionType.SELECTION_BEGIN_END | \
        #         TimelineMouseActionType.SELECTION_END_SILENCE:

        #         segment = None

        #         if typ in [TimelineMouseActionType.SELECTION_BEGIN_START, TimelineMouseActionType.SELECTION_BEGIN_START_SILENCE]:

        #             end = self._timeline.segment_end

        #             if typ == TimelineMouseActionType.SELECTION_BEGIN_START_SILENCE:
        #                 silence_segment = SilenceUtil.detect_silence_boundaries_from(self._state.sound, value)
        #                 if not silence_segment:
        #                     print(f"Ignoring, no silence detected at {value:2f}")
        #                     return
        #                 else:
        #                     start = silence_segment[1] # TODO crossed boundary
        #             else:
        #                 start = value

        #             if end >= 0:
        #                 if start >= end:
        #                     # Overwrite end marker with start marker
        #                     self._timeline.segment_start = start
        #                     self._timeline.segment_end = -1
        #                 else:
        #                     segment = (start, end)
        #             else:
        #                 # Set start marker
        #                 self._timeline.segment_start = start

        #         else: # SELECTION_END or SELECTION_END_SILENCE_DETECT:

        #             start = self._timeline.segment_start
                    
        #             if typ == TimelineMouseActionType.SELECTION_END_SILENCE:
        #                 silence_segment = SilenceUtil.detect_silence_boundaries_from(self._state.sound, value)
        #                 if not silence_segment:
        #                     print(f"Ignoring, no silence detected at {value:2f}")
        #                     return
        #                 else:
        #                     end = silence_segment[0] # TODO crossed boundary
        #             else:
        #                 end = value

        #             if start >= 0:
        #                 if end <= start:
        #                     # Overwrite start marker with end marker
        #                     self._timeline.segment_end = end
        #                     self._timeline.segment_start = -1
        #                 else:
        #                     segment = (start, end)
        #             else:
        #                 # Set end marker
        #                 self._timeline.segment_end = end

        #         if segment:
        #             index = self._state.insert_segment(segment[0], segment[1], can_merge=True)
        #             if index == -1:
        #                 # Couldn't insert segment
        #                 print(f"Couldn't add selection {make_position_range_string(segment[0], segment[1])}")
        #                 return
        #             print(f"Added selection {make_position_range_string(segment[0], segment[1])}")
        #             self._timeline.segment_start = -1
        #             self._timeline.segment_end = -1
        #             self._on_segments_changed()

    def _on_fast_mode_label_click(self) -> None:
        self._settings.fast_mode = not self._settings.fast_mode
        self._update_togglable_label(
            self._fast_mode_label, "Fast mode", self._settings.fast_mode
        )

    def _on_start_end_auto_label_click(self) -> None:
        self._toggle_start_end_auto()

    def _on_compressor_label_click(self) -> None:
        self._set_compressor_enabled(not self._settings.compressor_enabled)

    def _on_help_button(self) -> None:
        webbrowser.open(HELP_URL)

    def _on_stream_complete(self) -> None:
        if self._loader.is_loading:
            return        
        match self.play_mode:
            case FilePlayMode.REPEAT_SINGLE:
                self._stream.clear_completion_event() # nb
                self._stream.position = self._stream.min_position

            case FilePlayMode.TO_END:
                if self._settings.index < len(self._settings.file_paths) - 1:
                    self._load_sound_by_increment(1)
            case FilePlayMode.TO_END_REPEAT:
                if self._settings.index < len(self._settings.file_paths) - 1:
                    self._load_sound_by_increment(1)
                else:
                    self._load_sound_by_index(0)
            case FilePlayMode.RANDOM_NEXT:
                i = random.randrange(0, len(self._settings.file_paths))
                self._load_sound_by_index(i)
            case _:
                ... # do nothing

    def _on_segments_changed(self) -> None:
        """
        Sets a copy of sound_state segments on the Stream instance.
        Should be called on any segment update.
        """
        assert self._state.segments is not None
        self._stream.segments = self._state.segments.segments.copy()

        if not self._state.segments.segments and isinstance(self.play_mode, SegmentPlayMode):
            self.play_mode = FilePlayMode.DEFAULT
            
    def _on_sound_blur(self) -> None:
        """ Should be called before current sound is navigated away from, on quit, etc """

        if not self._state.sound:
            return

        if self._state.sound_dirty:
            # Save sound 
            ok = self._save_sound()
            if not ok:
                return
            # Delete existing segments json 
            assert self._state.segments
            self._state.segments.segments.clear()
            self._state.segments.delete_json()
        else:
            # Sound is not dirty; save segments json if necessary
            assert self._state.segments
            self._state.segments.save_json()

    # === Internal methods ===

    @property
    def ignore_user_input(self) -> bool:
        return self._loader.is_loading
    
    @property
    def play_mode(self) -> SegmentPlayMode | FilePlayMode:
        """Delegates to AppState for coordinated state access."""
        return self._app_state.play_mode

    @play_mode.setter
    def play_mode(self, value: SegmentPlayMode | FilePlayMode) -> None:
        """Delegates to AppState for coordinated state update."""
        self._app_state.set_play_mode(value)

    def _get_play_info_text(self) -> tuple[str, str]:
        if not self._state.has_sound:
            string = "No sound"
            color = "#888888"
        else:
            
            index = self._stream.get_segment_index()
            if not self._state.has_segments:
                index_string = "None"
            else:
                index_string = str(index+1) if index > -1 else "-"
                index_string += f" / {self._state.num_segments}"

            string = "Play mode: "
            match self.play_mode:
                case FilePlayMode.DEFAULT:
                    string += "Normal" 
                    color = "#888888"
                case FilePlayMode.REPEAT_SINGLE:
                    string += "Repeat single" 
                    color = "#ffffff"
                case FilePlayMode.TO_END:
                    string += "Auto-advance" 
                    color = "#ffffff"
                case FilePlayMode.TO_END_REPEAT:
                    string += "Auto-advance and repeat" 
                    color = "#ffffff"
                case FilePlayMode.RANDOM_NEXT:
                    string += "Random next" 
                    color = "#ffffff"
                case SegmentPlayMode.TO_END:
                    string += "Segments"
                    color = "red"
                case SegmentPlayMode.REPEAT_ALL:
                    string += "Segments (repeat)"
                    color = "red"
                case SegmentPlayMode.REPEAT_SINGLE:
                    string += "Segments (repeat single)"
                    color = "red"
                case None: # shouldnt happen
                    color = "#888888"
            
        return string, color
    
    def _load_sound_using_current_state(self) -> None:
        self._load_sound(self._settings.current_file_path)

    def _load_sound(self, path: str) -> None:
        """
        Main initialization routine
        """
        def on_load_complete(result: Sound | str) -> None:
            # Rem, is not on UI thread

            if isinstance(result, str):
                # Error
                print("\n\n*", result[:100], "\n")
                sound = None
            else:
                # Loaded 
                ms = int((time.time() - start_time) * 1000)
                print(f"{ms}ms")

                num_channels = result.data.shape[0]
                if num_channels > 2:
                    print(f"* Sound file with more than two channels ({num_channels}) is unsupported")
                    sound = None
                else:
                    # Success
                    sound = result

            # Continue on UI thread using signal (thread-safe)
            self._load_complete_signal.emit(sound, path)

        if not path:
            self._load_sound_continued(None, "")
            return
        
        print(f"Loading {path}... ", end="", flush=True)
        start_time = time.time()
        id = self._loader.load_sound(path, on_load_complete)
        if not id:
            print("Load operation already in progress, ignoring")
            return
        self._update_header()
        
    def _load_sound_continued(self, sound: Sound | None, path: str) -> None:
        """
        Inits full program state using passed-in Sound.
        Is on UI thread.
        """

        self._state = SoundState(path, sound)

        self._update_header()

        # TODO: has some duplication of logic with update-sound()

        # Init stream
        if not self._state.sound:
            self._stream.clear()
        else:
            self._stream.init_sound(self._state.sound)
            assert self._state.segments
            self._stream.segments = self._state.segments.segments.copy()

        if not self._stream.segments and isinstance(self.play_mode, SegmentPlayMode):
            self.play_mode = FilePlayMode.DEFAULT

        # Init timeline widget
        self._timeline.init(sound, self._state.segments)

        # Set start/end position
        if self._state.sound:
            if self._settings.start_end_auto:
                self._set_start_end_using_silence()
            else:
                self._set_start_end_position( (0, self._state.sound.duration) )
        else:
            self._set_start_end_position((0,0))

        # Startup settings
        if self._startup_info is not None:
            # Restore last position
            if self._state.sound:
                position = self._startup_info.get("last_position", 0)
                distance_from_end = abs(self._state.sound.duration - position)
                if distance_from_end < 0.01: # (must not be close to end)
                    position = 0.0
                self._stream.position = position
            # Play mode
            self.play_mode = self._startup_info.get("play_mode", FilePlayMode.DEFAULT)
            self._startup_info = None
            # Always play on startup
            self._stream.unpause()
        
        # After startup, sync state with AppState
        if self._state.sound:
            self._app_state.set_sound_state(self._state, self._stream.position)

    def _update_header(self) -> None:
        """Update directory and file labels"""

        if self._settings.dir_path:
            dir_text = (
                '<span style="color: gray;">Directory: </span>'
                f'<span style="color: white;">{self._settings.dir_path}</span>'
            )
        else:
            dir_text = '<span style="color: gray;">Select directory to start</span>'
        self.dir_label.setText(dir_text)
        
        # File label
        if not self._settings.current_file_path:
            file_text = "0 sound files"
        else:
            if self._loader.is_loading:
                file_text = "<span style='color: #ff00ff'>Loading file </span> "
            else:
                file_text = '<span style="color: gray;">File </span>'
            file_text += f'<span style="color: gray;">{self._settings.index + 1} of {len(self._settings.file_paths)}:</span> '
            file_text += Path(self._settings.current_file_path).name
            file_text += '<span style="color: gray;">'
            if self._state.sound:
                n_channels = self._state.sound.data.shape[0]
                if n_channels == 1:
                    channels_text = "mono"
                elif n_channels == 2:
                    channels_text = "stereo"
                else:
                    channels_text = f"{n_channels} channels"
                file_text += f" ({make_duration_string(self._state.sound.duration)}s, {self._state.sound.sr}hz, {channels_text})"
                file_text += " *" if self._state.sound_dirty else ""
            file_text += '</span>'
        
        self.file_label.setText(file_text)

    def _seek_next_segment(self, is_next: bool) -> None:
        if not self._state.has_segments:
            return

        max_index = self._state.num_segments - 1

        target_index: int | None = None
        where_type, where_index = Segments.where(self._stream.position, self._stream.segments)
        match where_type:
            case "inside":
                assert isinstance(where_index, int)
                if is_next:
                    if where_index < max_index:
                        target_index = where_index + 1
                else:
                    if where_index > 0:
                        target_index = where_index - 1
            case "before":
                assert isinstance(where_index, int)
                if is_next:
                        target_index = where_index
                else:
                    if where_index > 0:
                        target_index = where_index - 1
            case "before_first":
                if is_next:
                    target_index = 0
            case "after_last":
                if not is_next:
                    target_index = max_index
        if target_index is not None:
            self._stream.set_position_by_segment_index(target_index)

    def _load_sound_by_increment(self, delta: int) -> None:
        """Navigate to next/previous file by delta"""
        if not self._settings.file_paths:
            return
        
        new_index = self._settings.index + delta
        length = len(self._settings.file_paths)
        
        if (self._settings.index == 0 and new_index < 0) or \
                (self._settings.index >= length - 1 and new_index >= length):
            return
        
        # Clamp
        new_index = clamp(new_index, 0, length -1)
        self._load_sound_by_index(new_index)

    def _load_sound_by_index(self, index: int) -> None:
        if not self._settings.file_paths:
            return        
        if index < 0 or index > len(self._settings.file_paths) - 1:
            return
        
        self._on_sound_blur()
        
        self._settings.index = index
        self._load_sound_using_current_state()

    def _update_state_using_sound(self, sound: Sound, position: float = -1) -> None:
        """
        Updates sound state and related objects (no file reload)
        
        position:
            If left at default, will use use stream's current position
        """
        # Update SoundState
        self._state.sound = sound
        
        # Business logic: silence detection
        if self._settings.start_end_auto:
            self._set_start_end_using_silence()
        
        # Delegate state coordination to AppState
        self._app_state.set_sound_state(self._state, position)
        
        # Business logic: UI update
        self._update_header()
        
        # Business logic: play mode fallback
        if not self._stream.segments and isinstance(self.play_mode, SegmentPlayMode):
            self.play_mode = FilePlayMode.DEFAULT

    def _select_dir_and_default_file(self, dir_path: str) -> bool:
        """ 
        Selects directory and first file in directory (if any)
        """
        if not os.path.exists(dir_path):
            print(f"* No such path {dir_path}")
            return False
        if not os.path.isdir(dir_path):
            print("* Not a directory {dir_path}")
            return False
        
        self._settings.set_dir_and_print(dir_path)
        self._load_sound_using_current_state()
        return True

    def _select_adjacent_directory(self, previous: bool = False) -> None:
        """
        Select next/previous sibling directory
        """        
        current_dir = self._settings.dir_path
        if not current_dir or not Path(current_dir).exists():
            print("Can't select next/previous directory, no current directory")
            return
        
        parent = Path(current_dir).parent
        if not parent:
            print("Can't select next/previous directory, no parent directory")
            return
        
        import natsort
        sibling_dirs = [str(x) for x in Path(parent).iterdir() if x.is_dir()]
        sibling_dirs = natsort.natsorted(sibling_dirs)
        
        try:
            current_index = sibling_dirs.index(current_dir)
        except ValueError:
            print("Can't find current directory in siblings")
            return
        
        inc = -1 if previous else +1
        new_index = current_index + inc
        if new_index >= len(sibling_dirs):
            new_index = 0 # Wrap-around
        elif new_index < 0:
            new_index = len(sibling_dirs) - 1 # Wrap-around
        new_dir = sibling_dirs[new_index]
        self._select_dir_and_default_file(new_dir)

    def _set_start_end_position_using_mouse(self, is_start: bool) -> None:
        if self._timeline.mouse_position is None:
            return
        position = self._timeline.local_x_to_position(self._timeline.mouse_position[0])
        start = position if is_start else self._state.min_max_position[0]
        end = position if not is_start else self._state.min_max_position[1]        
        self._set_start_end_position((start, end))

    def _set_start_end_position(self, value: tuple[float, float]) -> None:
        did = self._state.set_min_max_position(value)
        if not did:
            return
        start, end = self._state.min_max_position
        self._stream.set_min_max_position(self._state.min_max_position)
        self._timeline.min_position = start
        self._timeline.max_position = end

    def _set_start_end_using_silence(self) -> None:
        if not self._state.sound:
            return
        start, end = SilenceUtil.get_start_end_silence_advanced(self._state.sound) 
        start = start if start is not None else 0.0
        end = end if end is not None else self._state.sound.duration
        if (start, end) == self._state.min_max_position:
            return
        self._set_start_end_position((start, end))
        print(f"Set start/end position: {self._state.min_max_position}")

    def _set_compressor_enabled(self, value: bool) -> None:
        """Delegates to AppState for coordinated state update."""
        self._app_state.set_compressor_enabled(value)
        self._update_togglable_label(
            self._compressor_label, "Compressor", self._settings.compressor_enabled
        )

    def _increment_zoom(self, increment: float) -> None:
        """Calculates new zoom level and delegates to AppState."""
        # Round to nearest increment step
        inverse = 1 / increment
        z = round(self._timeline.zoom * inverse) / inverse
        # Increment
        z += increment
        # Delegate to AppState for coordinated state update
        self._app_state.set_timeline_zoom(z)

    def _do_quit(self) -> None:
        self._on_sound_blur()
        if not self._state.sound_dirty and self._state.sound and self._stream.position < self._state.sound.duration:
            self._settings.last_position = self._stream.position
        else:
            self._settings.last_position = 0.0
        self._settings.save()
        self.close()

    # ---------------------------
    # Destructive operations, etc 

    def _do_delete_current_sound(self) -> None:
        """ Deletes current sound, potentially with confirm dialog """
        path = self._settings.current_file_path
        if not path:
            return

        def go() -> None:
            try:
                os.unlink(path)
            except OSError as e:
                print(f"* Error deleting file: {e}")
                return
            print("Deleted file:", path)
            self._settings.refresh_paths()
            self._load_sound_using_current_state()

        self._stream.pause()
        if self._settings.fast_mode:
            go()
        else:
            dialog = ButtonsDialog(self, "Delete?", [ButtonSpec("OK", go)])
            dialog.show()

    def _edit_sound_using_start_end(self) -> None:
        
        sound = self._state.sound
        if not sound:
            return
        start, end = self._state.min_max_position
        if abs(start) < 0.01 and abs(sound.duration - end) < 0.01:
            print("Nothing to trim")
            return
        
        start, end = self._state.min_max_position
        trimmed_sound = SoundUtil.trim(sound, start, end)
        position = self._stream.position
        self._update_state_using_sound(trimmed_sound, position) 
        
        strings = ["Trimmed "]
        if not (abs(start) < 0.01):
            strings.append(f"start {start:.2f}")
        if not (abs(sound.duration - end) < 0.01):
            strings.append(f"end {end:.2f}")
        print(" ".join(strings))

    def _edit_sound_using_segments(self, is_inverse: bool) -> None:
        """ Edits current sound using only the data within the current segments """

        if not self._state.sound:
            return
        if not self._state.has_segments:
            print("No segments defined")
            return
        
        assert self._state.segments 
        segments_copy = self._state.segments.segments.copy()
        if is_inverse:
            segs = Segments.make_inverse(self._state.segments.segments, self._state.sound.duration)
            segments = Segments.make_tuple_twos(segs)
        else:
            segments = Segments.make_tuple_twos(self._state.segments.segments)

        sound, new_position = SoundUtil.trim_using_segments(self._state.sound, segments, self._stream.position)
        self._update_state_using_sound(sound, new_position)
        
        strings = ["Cut selection/s"]
        for item in segments_copy:
            strings.append(f"{item.start:.2f}-{item.end:.2f}")
        print(" ".join(strings))

    def _can_split_at_cursor(self) -> bool:
        sound = self._state.sound
        if not sound:
            return False
        return self._stream.position > 0.01 and self._stream.position < sound.duration - 0.1

    def _split_at_playhead(self) -> None:
        sound = self._state.sound
        if not sound:
            return
        if not self._can_split_at_cursor:
            print("Playhead is at or near start/end, ignoring")
            return        
        
        position = self._stream.position
        segments = [(0.0, position), (position, sound.duration)]
        AppUtil.save_sounds_using_segments(sound, segments, self._settings.current_file_path)

        self._settings.refresh_paths()
        self._load_sound_using_current_state() 

    def _save_separate_sounds_using_segments(self) -> None:
        """ Saves to separate sound files using current segments """

        if not self._state.sound or not self._state.has_segments:
            return

        # Save separate files and delete original
        assert self._state.segments
        AppUtil.save_sounds_using_segments(
            self._state.sound, 
            Segments.make_tuple_twos(self._state.segments.segments), 
            self._settings.current_file_path
        )

        # Delete original segments file 
        json_path = Segments.make_json_path_using(self._state.file_path)
        Segments.delete_json_at_path(json_path)
        
        # Refresh state
        self._settings.refresh_paths()
        self._load_sound_using_current_state()

    def _split_dialog(self) -> None:

        if not self._state.sound or not self._settings.current_file_path:
            return
        
        self._stream.pause()

        s = f"Split at playhead ({make_position_string(self._stream.position)})"
        split_at_playhead = ConfirmableButtonSpec(s, self._split_at_playhead, 
            enabled=self._can_split_at_cursor(), confirm=False
        )

        s = f"Split using segments ({self._state.num_segments} files)"
        split_at_segments = ConfirmableButtonSpec(s, self._save_separate_sounds_using_segments, 
                enabled=bool(self._state.segments), confirm=True)

        dialog = ConfirmableDialog(
            parent=self,
            window_title="Split sound into separate files",
            processing_message="",
            button_specs=[split_at_playhead, split_at_segments],
            on_complete=None
        )
        dialog.exec()

    def _dir_op_dialog(self) -> None:
        
        if not self._settings._dir_path:
            print("No directory path, ignoring")
            return
        
        def on_complete() -> None:
            self._settings.refresh_paths()
            self._load_sound_using_current_state()

        button_specs = [
            ConfirmableButtonSpec(
                "Print dir info",
                lambda: SoundFilesUtil.print_sound_file_info(self._settings),
                confirm=False
            ),
            ConfirmableButtonSpec("Auto-Trim", lambda: DirectoryOperationsUtil.do_directory_start_end_trim(self._settings.dir_path), confirm=True),
            ConfirmableButtonSpec("Peak Normalize", lambda: DirectoryOperationsUtil.do_directory_peak_normalize(self._settings.dir_path), confirm=True),
            ConfirmableButtonSpec("Resample 24k", lambda: DirectoryOperationsUtil.do_directory_resample_24k(self._settings.dir_path), confirm=True),
            ConfirmableButtonSpec("Transcode FLAC", lambda: DirectoryOperationsUtil.do_directory_transcode_flac(self._settings.dir_path), confirm=True),
            ConfirmableButtonSpec(f"Delete short ({DELETE_SHORT_MIN}s)", lambda: DirectoryOperationsUtil.do_directory_delete_short(self._settings.dir_path, DELETE_SHORT_MIN), confirm=True),
        ]
        dialog = ConfirmableDialog(
            parent=self,
            window_title="Directory Operations",
            processing_message="Processing directory...",
            button_specs=button_specs,
            on_complete=on_complete
        )
        dialog.exec()

# ---

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = App()
    window.show()
    sys.exit(app.exec())