toby-doom-launcher/Toby Doom Launcher.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright (c) 2024 Stormux
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 3 of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the
# Free Software Foundation, Inc., Franklin Street, Fifth Floor,
# Boston MA  02110-1301 USA.


# ======= Version Configuration =======
# Update version number here for new releases of Toby Doom Accessibility Mod
# Example: 8.0 for version 8.0, 8.5 for version 8.5, etc

TOBY_VERSION_NUMBER = 8.0

# DO NOT EDIT ANYTHING BELOW THIS LINE!
# ===================================


import configparser
import json
import sys
import os
import re
import subprocess
import time
import platform
import shutil
import glob
import threading
from pathlib import Path
from typing import Final, List, Dict, Optional, Tuple
from setproctitle import setproctitle
from PySide6.QtWidgets import (QApplication, QMainWindow, QWidget, QHBoxLayout, QVBoxLayout, 
    QComboBox, QPushButton, QLabel, QSpinBox, QMessageBox, QLineEdit, QDialog,
    QDialogButtonBox, QRadioButton)
from PySide6.QtCore import Qt, QTimer
import webbrowser

# Initialize speech provider based on platform
if platform.system() == "Windows":
    # Set up DLL paths for Windows
    if getattr(sys, 'frozen', False):
        # If running as compiled executable
        dllPath = os.path.join(sys._MEIPASS, 'lib')
        if os.path.exists(dllPath):
            os.add_dll_directory(dllPath)
        # Also add the executable's directory
        os.add_dll_directory(os.path.dirname(sys.executable))

    # Sound playback for audio manual on Windows
    # Initialize Windows speech provider
    try:
        import accessible_output2.outputs.auto
        s = accessible_output2.outputs.auto.Auto()
        speechProvider = "accessible_output2"
    except ImportError as e:
        print(f"Failed to initialize accessible_output2: {e}")
        sys.exit()
else:
    # Linux/Mac path
    try:
        output = subprocess.check_output(["pgrep", "cthulhu"])
        speechProvider = "cthulhu"
    except (subprocess.CalledProcessError, FileNotFoundError):
        try:
            import accessible_output2.outputs.auto
            s = accessible_output2.outputs.auto.Auto()
            speechProvider = "accessible_output2"
        except ImportError as e:
            try:
                import speechd
                spd = speechd.Client()
                speechProvider = "speechd"
            except ImportError:
                print("No speech providers found.")
                sys.exit()


class AccessibleComboBox(QComboBox):
    """ComboBox with enhanced keyboard navigation"""
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setEditable(True)
        self.lineEdit().setReadOnly(True)
        self.pageStep = 5  # Number of items to jump for page up/down

    def keyPressEvent(self, event):
        currentIndex = self.currentIndex()
        itemCount = self.count()

        if event.key() == Qt.Key_PageUp:
            newIndex = max(0, currentIndex - self.pageStep)
            self.setCurrentIndex(newIndex)
        elif event.key() == Qt.Key_PageDown:
            newIndex = min(itemCount - 1, currentIndex + self.pageStep)
            self.setCurrentIndex(newIndex)
        elif event.key() == Qt.Key_Home:
            self.setCurrentIndex(0)
            # Force update and focus events
            self.setFocus()
            self.currentIndexChanged.emit(0)
            self.activated.emit(0)
        elif event.key() == Qt.Key_End:
            lastIndex = itemCount - 1
            self.setCurrentIndex(lastIndex)
            # Force update and focus events
            self.setFocus()
            self.currentIndexChanged.emit(lastIndex)
            self.activated.emit(lastIndex)
        else:
            super().keyPressEvent(event)


class SpeechHandler:
    """Handles text-to-speech processing for game output"""

    # Class-level constants for patterns
    FILTER_PATTERNS = [
        r'^----+$',
        r'^$',
        r'^[0-9]',
        r'^P_StartScript:',
        r'^(ALSA|Cannot|Facing |fluidsynth|INTRO|MAP[0-9]+|Music "|Unknown)',
        r'^(\[Toby Accessibility Mod\] )?READ.*',
        r'^ *TITLEMAP',
        r'^\[Toby Accessibility Mod\] (INTRO|READMe)([0-9]+).*',
        r'key card',
        r'^New PDA Entry:',
        r"^(As |Computer Voice:|Holy|I |I've|Monorail|Sector |Ugh|What|Where)",
        r'Script warning, "',
        r'Tried to define'
    ]

    TEXT_REPLACEMENTS = [
        (r'^\[Toby Accessibility Mod\] M_', r'[Toby Accessibility Mod] '),
        (r'^\[Toby Accessibility Mod\] ', r''),
        (r'^MessageBoxMenu$', r'Confirmation menu: Press Y for yes or N for no'),
        (r'^Mainmenu$', r'Main menu'),
        (r'^Skillmenu$', r'Difficulty menu'),
        (r'^Episodemenu$', r'Episode menu'),
        (r'^Playerclassmenu$', r'Player class menu'),
        (r'^Loadmenu$', r'Load menu'),
        (r'^Savemenu$', r'Save menu'),
        (r'^Optionsmenu$', r'Options menu'),
        (r'([A-Z][a-z0-9]+)menu$', r'\1 menu'),
        (r'^NGAME$', r'New game'),
        (r'^(LOAD|SAVE|QUIT)G$', r'\1 game'),
        (r'"cl_run" = "true"', r'run'),
        (r'"cl_run" = "false"', r'walk'),
        (r'UAC', r'U A C'),
        (r'^JKILL', r"I'm too young to die"),
        (r'^ROUGH', r'Hey, not too rough'),
        (r'^HURT', r'Hurt me plenty'),
        (r'^ULTRA', r'Ultra-Violence'),
        (r'^\+', r''),
        (r' ?\*+ ?', r'')
    ]

    def __init__(self, config_file: Path):
        """Initialize the speech handler"""
        self.platform = platform.system()
        self.use_tts = self._check_narration_type(config_file)

        # Compile all regex patterns once at initialization
        self.filterPatterns = [re.compile(pattern) for pattern in self.FILTER_PATTERNS]
        self.textReplacements = [(re.compile(pattern), repl) 
                            for pattern, repl in self.TEXT_REPLACEMENTS]

    def set_tts_state(self, enabled: bool) -> None:
        """Update voicing style"""
        self.use_tts = enabled

    def _check_narration_type(self, config_file: Path) -> bool:
        """Check if TTS should be used, returns False for self-voiced"""
        try:
            if not config_file.exists():
                return False

            with open(config_file, 'r') as f:
                for line in f:
                    line = line.strip()
                    if line.startswith('Toby_NarrationOutputType='):
                        value = int(line.split('=')[1].strip())
                        return value == 2
            return False
        except Exception as e:
            print(f"Error reading config: {e}", file=sys.stderr)
            return False

    def speak(self, text: str) -> None:
        """Speak text using available speech method"""
        if not text or not self.use_tts:
            return

        if speechProvider == "speechd":
            spd.cancel()
            spd.speak(text)
        elif speechProvider == "accessible_output2":
            s.speak(text, interrupt=True)
        else:  # Cthulhu
            try:
                process = subprocess.Popen(
                    ["socat", "-", "UNIX-CLIENT:/tmp/cthulhu.sock"],
                    stdin=subprocess.PIPE,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
                    text=True
                )
                process.communicate(input=text)
            except Exception as e:
                print(f"Cthulhu error: {e}", file=sys.stderr)

    def process_line(self, line: str) -> Optional[str]:
        """Process a line of game output for speech"""
        # Skip empty lines
        if not line.strip():
            return None

        # Check if line should be filtered out
        for pattern in self.filterPatterns:
            if pattern.search(line):
                return None

        # Apply replacements
        processedLine = line
        for pattern, repl in self.textReplacements:
            processedLine = pattern.sub(repl, processedLine)

        return processedLine.strip() if processedLine.strip() else None

    def speak_thread(self, process: subprocess.Popen):
        """Thread to handle speech processing"""
        startSpeech = False  # Don't start speaking until after initial output

        while True:
            try:
                line = process.stdout.readline()
                if not isinstance(line, str):
                    line = line.decode('utf-8', errors='replace')

                if not line:
                    break

                # Keep gzdoom's existing functionality of lines being printed to the console
                print(line, end='', flush=True)

                lineStr = line.strip()
                if not lineStr:
                    continue

                # Wait for the initial separator before starting speech
                if not startSpeech:
                    if all(c == '-' for c in lineStr):
                        startSpeech = True
                        continue

                if startSpeech:
                    processedLine = self.process_line(lineStr)
                    if processedLine:
                        self.speak(processedLine)

            except Exception as e:
                print(f"Error processing game output: {e}", file=sys.stderr)
                continue


class MenuDialog(QDialog):
    """Dialog for game configuration options"""

    def __init__(self, title: str, options: Dict[str, dict], parent=None):
        super().__init__(parent)
        self.setWindowTitle(title)
        self.dialogOptions = options
        self.generateScript = False  # Flag to indicate script generation
        self.init_dialog_ui()

    def init_dialog_ui(self):
        """Initialize the dialog UI components"""
        dialogLayout = QVBoxLayout(self)

        for key, opt in self.dialogOptions.items():
            if opt['type'] == 'radio':
                dialogWidget = QRadioButton(opt['label'])
            elif opt['type'] == 'spinbox':
                # Create label first
                label = QLabel(opt['label'])
                dialogWidget = QSpinBox()
                dialogWidget.setRange(opt['min'], opt['max'])
                dialogWidget.setValue(opt.get('default', opt['min']))
                # Set accessibility label
                dialogWidget.setAccessibleName(opt['label'])
                # Add label to layout first
                dialogLayout.addWidget(label)
            elif opt['type'] == 'text':
                dialogWidget = QLineEdit()
                dialogWidget.setPlaceholderText(opt['placeholder'])
            elif opt['type'] == 'combobox':
                dialogWidget = AccessibleComboBox()
                dialogWidget.addItems(opt['items'])
                dialogLayout.addWidget(QLabel(opt['label']))
            else:
                continue

            setattr(self, f"{key}_widget", dialogWidget)
            dialogLayout.addWidget(dialogWidget)

        # Custom button box with both Launch and Generate Script options
        buttonBox = QDialogButtonBox()
        self.launchButton = buttonBox.addButton("Launch Game", QDialogButtonBox.AcceptRole)
        self.scriptButton = buttonBox.addButton("Generate Script", QDialogButtonBox.ActionRole)
        buttonBox.addButton(QDialogButtonBox.Cancel)

        # Connect buttons
        self.launchButton.clicked.connect(self.acceptLaunch)
        self.scriptButton.clicked.connect(self.acceptGenerateScript)
        buttonBox.rejected.connect(self.reject)

        dialogLayout.addWidget(buttonBox)

    def acceptLaunch(self):
        """Accept dialog with launch flag"""
        self.generateScript = False
        self.accept()

    def acceptGenerateScript(self):
        """Accept dialog with script generation flag"""
        self.generateScript = True
        self.accept()

    def get_dialog_values(self) -> dict:
        """Get the current values from all dialog widgets"""
        values = {}
        for key in self.dialogOptions.keys():
            widget = getattr(self, f"{key}_widget")
            if isinstance(widget, QSpinBox):
                values[key] = widget.value()
            elif isinstance(widget, QComboBox):
                values[key] = widget.currentText()
            elif isinstance(widget, QRadioButton):
                values[key] = widget.isChecked()
            else:
                values[key] = widget.text()
        return values


class AudioPlayer:
    """Handles cross-platform audio playback using VLC if available"""

    def __init__(self):
        self.currentTrack = None
        self.currentIndex = -1
        self.isPlaying = False
        self.playAllMode = False
        self.tracks = []
        self.vlcAvailable = False

        # State monitoring timer
        self.stateTimer = QTimer()
        self.stateTimer.setInterval(500)  # Check every 500ms
        self.stateTimer.timeout.connect(self.checkPlayerState)

        try:
            import vlc
            self.instance = vlc.Instance()
            self.player = self.instance.media_player_new()
            # Store VLC states we care about
            self.State_Ended = vlc.State.Ended
            self.State_Error = vlc.State.Error
            self.State_Playing = vlc.State.Playing
            self.vlcAvailable = True
        except Exception as e:
            print(f"VLC not available: {e}", file=sys.stderr)
            self.instance = None
            self.player = None

    def checkPlayerState(self):
        """Monitor VLC player state"""
        if not self.vlcAvailable or not self.player or not self.isPlaying:
            return

        try:
            state = self.player.get_state()

            # Check for end states
            if state in (self.State_Ended, self.State_Error):
                print(f"Track ended (state: {state})")
                self.isPlaying = False
                self.stateTimer.stop()

                if self.playAllMode and self.currentIndex < len(self.tracks) - 1:
                    self.currentIndex += 1
                    self.play()

        except Exception as e:
            print(f"Error checking player state: {e}", file=sys.stderr)

    def loadTracks(self, files):
        """Load list of tracks to play"""
        if not self.vlcAvailable:
            return
        self.tracks = [str(f) for f in files]
        self.currentIndex = 0 if self.tracks else -1
        print(f"Loaded tracks: {self.tracks}")

    def play(self):
        """Play current track"""
        if not self.vlcAvailable:
            return False

        if self.currentIndex >= 0 and self.currentIndex < len(self.tracks):
            self.stop() # Stop any current playback first
            self.currentTrack = self.tracks[self.currentIndex]
            try:
                print(f"Attempting to play: {self.currentTrack}")
                media = self.instance.media_new(self.currentTrack)
                self.player.set_media(media)
                result = self.player.play()
                if result == 0: # VLC returns 0 on success
                    self.isPlaying = True
                    self.stateTimer.start()  # Start state monitoring
                    return True
                else:
                    print(f"VLC play() returned error: {result}", file=sys.stderr)
                    return False
            except Exception as e:
                print(f"Playback error: {e}", file=sys.stderr)
                self.isPlaying = False
                return False
        return False

    def stop(self):
        """Stop playback"""
        if not self.vlcAvailable:
            return

        if self.player and self.isPlaying:
            try:
                self.stateTimer.stop() # Stop state monitoring
                self.player.stop()
                self.isPlaying = False
                print("Playback stopped")
            except Exception as e:
                print(f"Stop error: {e}", file=sys.stderr)

    def nextTrack(self):
        """Move to next track"""
        if not self.vlcAvailable:
            return False

        if self.currentIndex < len(self.tracks) - 1:
            self.stop()
            self.currentIndex += 1
            return True
        return False

    def previousTrack(self):
        """Move to previous track"""
        if not self.vlcAvailable:
            return False

        if self.currentIndex > 0:
            self.stop()
            self.currentIndex -= 1
            return True
        return False

    def getCurrentTrackName(self):
        """Get current track name"""
        if not self.vlcAvailable:
            return ""

        if self.currentTrack:
            return Path(self.currentTrack).stem
        return ""


class AudioManualDialog(QDialog):
    """Dialog for audio manual playback"""
    def __init__(self, manualPath, parent=None):
        super().__init__(parent)
        self.manualPath = manualPath
        self.audioPlayer = AudioPlayer()

        # Show warning if VLC not available
        if not self.audioPlayer.vlcAvailable:
            QMessageBox.warning(self, "VLC Not Found", 
                "VLC is required for Audio Manual playback. Please install VLC media player. If running from source, also install python-vlc.")
            self.close()
            return

        # Create update timer for checking playback state
        self.stateTimer = QTimer(self)
        self.stateTimer.timeout.connect(self.checkPlaybackState)
        self.stateTimer.start(500)  # Check every 500ms

        self.initUI()


class AudioManualDialog(QDialog):
    """Dialog for audio manual playback"""
    def __init__(self, manualPath, parent=None):
        super().__init__(parent)
        self.manualPath = manualPath
        self.audioPlayer = AudioPlayer()

        # Create update timer for checking playback state
        self.stateTimer = QTimer(self)
        self.stateTimer.timeout.connect(self.checkPlaybackState)
        self.stateTimer.start(500)  # Check every 500ms

        self.initUI()

    def checkPlaybackState(self):
        """Periodically check playback state and update UI"""
        if not self.audioPlayer.isPlaying and self.stopButton.isEnabled():
            self.updateButtonStates()

    def initUI(self):
        """Initialize the dialog UI"""
        self.setWindowTitle("Audio Manual")
        layout = QVBoxLayout(self)

        # Manual selection
        manualLabel = QLabel("Select Manual:")
        self.manualCombo = AccessibleComboBox()
        self.manualCombo.setAccessibleName("Manual Selection")
        self.populateManuals()
        layout.addWidget(manualLabel)
        layout.addWidget(self.manualCombo)

        # Track selection
        trackLabel = QLabel("Select Track:")
        self.trackCombo = AccessibleComboBox()
        self.trackCombo.setAccessibleName("Track Selection")
        layout.addWidget(trackLabel)
        layout.addWidget(self.trackCombo)

        # Create buttons
        buttonLayout = QHBoxLayout()
        self.prevButton = QPushButton("Previous")
        self.playButton = QPushButton("Play")
        self.stopButton = QPushButton("Stop")
        self.nextButton = QPushButton("Next")

        # Setup focus and keyboard interaction
        self.manualCombo.setFocusPolicy(Qt.StrongFocus)
        self.trackCombo.setFocusPolicy(Qt.StrongFocus)
        # Allow Enter key to play selected track
        self.trackCombo.lineEdit().returnPressed.connect(self.playAudio)

        # Set keyboard shortcuts and accessibility for buttons
        self.prevButton.setShortcut("Left")
        self.playButton.setShortcut("Space")
        self.stopButton.setShortcut("S")
        self.nextButton.setShortcut("Right")

        # Set accessible names for buttons
        self.prevButton.setAccessibleName("Previous Track")
        self.playButton.setAccessibleName("Play Track")
        self.stopButton.setAccessibleName("Stop Playback")
        self.nextButton.setAccessibleName("Next Track")

        # Connect button signals
        self.prevButton.clicked.connect(self.previousTrack)
        self.playButton.clicked.connect(self.playAudio)
        self.stopButton.clicked.connect(self.stopAudio)
        self.nextButton.clicked.connect(self.nextTrack)

        # Add buttons to layout
        buttonLayout.addWidget(self.prevButton)
        buttonLayout.addWidget(self.playButton)
        buttonLayout.addWidget(self.stopButton)
        buttonLayout.addWidget(self.nextButton)
        layout.addLayout(buttonLayout)

        # Status label
        self.statusLabel = QLabel("")
        self.statusLabel.setAccessibleName("Playback Status")
        layout.addWidget(self.statusLabel)

        # Update tracks when manual changes
        self.manualCombo.currentTextChanged.connect(self.populateTracks)

        # Close button
        closeButton = QPushButton("Close")
        closeButton.setAccessibleName("Close Dialog")
        closeButton.setShortcut("Escape")
        closeButton.clicked.connect(self.close)
        layout.addWidget(closeButton)

        # Initial setup
        self.populateTracks()
        self.updateButtonStates()

    def closeEvent(self, event):
        """Handle dialog close event"""
        self.stateTimer.stop()
        self.audioPlayer.stop()
        super().closeEvent(event)

    def populateManuals(self):
        """Populate manual selection combo box"""
        manualDirs = sorted([d for d in self.manualPath.iterdir() if d.is_dir()])
        self.manualCombo.addItems([m.name for m in manualDirs])

    def populateTracks(self):
        """Populate track selection combo box"""
        self.trackCombo.clear()
        selectedManual = self.manualPath / self.manualCombo.currentText()
        if selectedManual.exists():
            tracks = sorted(selectedManual.glob('*.mp3'))
            self.trackCombo.addItem("Play All")
            self.trackCombo.addItems([t.stem for t in tracks])
            # Update button states after populating tracks
            self.updateButtonStates()

    def playAudio(self):
        """Start audio playback"""
        if not self.manualCombo.currentText() or not self.trackCombo.currentText():
            return

        selectedManual = self.manualPath / self.manualCombo.currentText()
        selectedTrack = self.trackCombo.currentText()

        # Stop any current playback
        self.audioPlayer.stop()
        self.audioPlayer.playAllMode = selectedTrack == "Play All"

        if selectedTrack == "Play All":
            # Get sorted list of MP3 files
            tracks = sorted(selectedManual.glob('*.mp3'))
            print(f"Loading {len(tracks)} tracks for Play All")
            self.audioPlayer.loadTracks([str(t) for t in tracks])
        else:
            print("Loading single track")
            tracks = [selectedManual / f"{selectedTrack}.mp3"]
            self.audioPlayer.loadTracks([str(t) for t in tracks])

        # Start playback
        if self.audioPlayer.play():
            self.statusLabel.setText(f"Playing: {self.audioPlayer.getCurrentTrackName()}")
        else:
            self.statusLabel.setText("Playback error")
        self.updateButtonStates()

    def stopAudio(self):
        """Stop audio playback"""
        self.audioPlayer.playAllMode = False  # Reset play all flag
        self.audioPlayer.stop()
        self.statusLabel.setText("Playback stopped")
        self.updateButtonStates()

    def nextTrack(self):
        """Play next track"""
        if self.audioPlayer.nextTrack():
            if self.audioPlayer.play():
                self.statusLabel.setText(f"Playing: {self.audioPlayer.getCurrentTrackName()}")
            else:
                self.statusLabel.setText("Playback error")
        self.updateButtonStates()

    def previousTrack(self):
        """Play previous track"""
        if self.audioPlayer.previousTrack():
            if self.audioPlayer.play():
                self.statusLabel.setText(f"Playing: {self.audioPlayer.getCurrentTrackName()}")
            else:
                self.statusLabel.setText("Playback error")
        self.updateButtonStates()

    def updateButtonStates(self):
        """Update button enabled states"""
        trackCount = len(self.audioPlayer.tracks)
        hasMultipleTracks = trackCount > 1
        isFirst = self.audioPlayer.currentIndex <= 0
        isLast = self.audioPlayer.currentIndex >= trackCount - 1

        # Enable play button if we have any tracks selected or available
        hasTrackSelected = (self.trackCombo.count() > 0 and self.trackCombo.currentText()) or trackCount > 0

        # Allow navigation during playback for Play All mode
        self.prevButton.setEnabled(hasMultipleTracks and not isFirst)
        self.nextButton.setEnabled(hasMultipleTracks and not isLast)
        self.playButton.setEnabled(hasTrackSelected and not self.audioPlayer.isPlaying)
        self.stopButton.setEnabled(self.audioPlayer.isPlaying)


class IWADSelector:
    """Handles IWAD file detection and selection"""

    def __init__(self):
        if platform.system() == "Windows":
            self.configFile = Path.cwd() / 'TobyConfig.ini'
        else:
            self.configFile = Path(os.getenv('XDG_CONFIG_HOME', Path.home() / '.config')) / 'gzdoom/gzdoom.ini'
        self.wadPaths = self._get_wad_paths()

    def _get_wad_paths(self) -> List[str]:
        """Extract IWAD search paths from GZDoom config"""
        if not self.configFile.exists():
            print("Config file not found")
            return []

        try:
            # Read the file directly to handle duplicate keys
            paths = []
            currentSection = None
            with open(self.configFile, 'r') as f:
                for line in f:
                    line = line.strip()
                    if line.startswith('['):
                        currentSection = line[1:-1]
                    elif currentSection == 'IWADSearch.Directories' and '=' in line:
                        key, value = line.split('=', 1)
                        if key.strip().lower().startswith('path'):
                            value = value.strip()
                            # Handle special paths
                            if value == '$DOOMWADDIR' or value == '$PROGDIR':
                                continue  # Skip these as they're GZDoom internal
                            elif value == '$HOME':
                                value = str(Path.home())
                            paths.append(value)

        except Exception as e:
            print(f"Error reading config: {e}", file=sys.stderr)

        # Additional paths to check
        if platform.system() == "Windows":
            paths.append(str(Path.cwd()))
        else:
                paths.append(str(Path("/usr/share/doom")))
                paths.append(str(Path("/usr/share/games/doom")))
                paths.append(str(Path.home() / ".local/games/doom"))
                paths.append(str(Path.home() / ".local/share/doom"))
        return paths

    def is_iwad(self, file_path: str) -> bool:
        """Check if a file is an IWAD or IPK3"""
        path = Path(file_path)
        if path.suffix.lower() == '.ipk3':
            return True

        try:
            with open(file_path, 'rb') as f:
                header = f.read(4)
                return header == b'IWAD'
        except Exception:
            return False

    def find_iwads(self) -> Dict[str, str]:
        """Find all available IWADs in configured paths"""
        uniqueWads = {}

        for path in self.wadPaths:
            wadDir = Path(path)
            if not wadDir.is_dir():
                continue

            # Only look at files directly in the directory, not subdirectories
            for wadFile in wadDir.iterdir():
                if wadFile.is_file():
                    # Check if it's a WAD or IPK3 file
                    if wadFile.suffix.lower() in ['.wad', '.iwad']:
                        if self.is_iwad(str(wadFile)):
                            wadName = wadFile.stem.lower()
                            uniqueWads[wadName] = str(wadFile)
                    elif wadFile.suffix.lower() == '.ipk3':
                        if self.is_iwad(str(wadFile)):
                            wadName = wadFile.stem.lower()
                            uniqueWads[wadName] = str(wadFile)

        return uniqueWads


class CustomGameDialog(QDialog):
    """Dialog for selecting and configuring custom games"""
    def __init__(self, customGames: Dict[str, dict], parent=None):
        super().__init__(parent)
        self.setWindowTitle("Custom Game Selection")
        self.customGames = customGames

        # Create layout
        layout = QVBoxLayout(self)

        # Game selection combobox
        label = QLabel("Select Custom Game:")
        self.gameCombo = AccessibleComboBox()
        self.gameCombo.setAccessibleName("Custom Game Selection")
        self.gameCombo.addItems(sorted(customGames.keys()))
        # Connect enter key to accept
        self.gameCombo.lineEdit().returnPressed.connect(self.accept)

        layout.addWidget(label)
        layout.addWidget(self.gameCombo)

        # Dialog buttons
        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)
        layout.addWidget(buttons)

    def keyPressEvent(self, event):
        """Handle key press events"""
        if event.key() in (Qt.Key_Return, Qt.Key_Enter):
            self.accept()
        else:
            super().keyPressEvent(event)

    def get_selected_game(self) -> Optional[str]:
        """Get the selected game name"""
        if self.result() == QDialog.Accepted:
            return self.gameCombo.currentText()
        return None


class DoomLauncher(QMainWindow):
    """Main launcher window for Toby Doom"""

    deathmatchMaps = [
        "Com Station (2-4 players)",
        "Warehouse (2-4 players)",
        "Sector 3 (2-4 players)",
        "Dungeon of Doom (2-4 players)",
        "Ocean Fortress (2-4 players)",
        "Water Treatment Facility (2-4 players)",
        "Phobos Base Site 4 (2-4 players)",
        "Hangar Bay 18 (2-4 players)",
        "Garden of Demon (2-4 players)",
        "Outpost 69 (2-4 players)"
    ]

    def __init__(self):
        super().__init__()
        self.setWindowTitle("Toby Doom Launcher")

        if platform.system() == "Windows":
            self.configFile = Path.cwd() / 'TobyConfig.ini'
            self.gamePath = Path.cwd()
        else:
            self.gamePath = Path.home() / ".local/games/doom"
            self.configFile = Path(os.getenv('XDG_CONFIG_HOME', Path.home() / '.config')) / 'gzdoom/gzdoom.ini'

        # Make sure controls are set
        self.check_and_fix_controls()

        self.tobyVersion = TOBY_VERSION
        self.speechHandler = SpeechHandler(self.configFile)
        self.iwadSelector = IWADSelector()  # Add IWAD selector
        self.init_launcher_ui()

    def check_and_fix_controls(self):
        """Check and fix control bindings in GZDoom configuration for all game types."""
        if not self.configFile.exists():
            print("Config file not found")
            return False

        try:
            # Read config file
            with open(self.configFile, 'r') as f:
                configLines = f.readlines()

            changesNeeded = False

            # Standard controls that should be consistent
            standardControls = {
                'attack': '+attack',
                'altattack': '+altattack',
                'use': '+use',
                'crouch': '+crouch',
                'turn180': 'turn180',
                'jump': '+jump'
            }

            # Standard key bindings
            standardKeys = {
                'Ctrl': '+attack',
                'Alt': '+altattack',
                'Space': '+use',
                'C': '+crouch',
                'X': 'turn180',
                'J': '+jump'
            }

            # Arrow key setup for aiming
            arrowControls = {
                'UpArrow': '+forward',
                'DownArrow': '+back',
                'LeftArrow': '+left',
                'RightArrow': '+right'
            }

            # Accessibility controls that need to be in special sections
            tobyAccessibilityControls = {
                'E': 'pukename TurnCompass 1',
                'R': 'pukename TurnCompass 0',
                'Q': 'pukename CompassScript',
                ';': 'netevent Toby_CheckLevelStats',
                "'": 'toby_proximity_toggle_keybind',
                'Z': '+toby_snap_to_target_keybind'
            }

            # Map section prefixes to their control sections
            controlSections = {}

            currentSection = None
            for i, line in enumerate(configLines):
                line = line.strip()

                # Detect section headers
                if line.startswith('[') and line.endswith(']'):
                    currentSection = line[1:-1]

                    # If this is a bindings section, extract the game prefix
                    if '.Bindings' in currentSection:
                        prefix = currentSection.split('.')[0]  # e.g., 'Doom', 'Heretic'
                        controlSections[prefix] = controlSections.get(prefix, []) + [currentSection]

                    continue

                # Fix main bindings in each game's Bindings section
                if currentSection and currentSection.endswith('.Bindings') and not any(x in currentSection for x in ['Double', 'Automap', 'CompassMod', 'TargetSnap', 'CheckMod', 'ProximityDetector']) and '=' in line:
                    key, binding = line.split('=', 1)
                    key = key.strip()
                    binding = binding.strip()

                    # Fix the turn180 command specifically (should not have + prefix)
                    if binding == '+turn180':
                        configLines[i] = f"{key}=turn180\n"
                        changesNeeded = True

                    # Check if standard keys have correct bindings
                    if key in standardKeys and binding != standardKeys[key]:
                        configLines[i] = f"{key}={standardKeys[key]}\n"
                        changesNeeded = True
                        print(f"Fixed {key} binding to {standardKeys[key]} in {currentSection}")

                    # Remove E=+use binding (this should be in CompassMod section)
                    if key == "E" and binding == "+use":
                        configLines[i] = f"# {line} # Removed by Toby Launcher\n"
                        changesNeeded = True
                        print(f"Removed E=+use binding in {currentSection}")

                    # Fix arrow key controls
                    for arrowKey, arrowBinding in arrowControls.items():
                        if key == arrowKey and binding != arrowBinding:
                            configLines[i] = f"{arrowKey}={arrowBinding}\n"
                            changesNeeded = True
                            print(f"Fixed {arrowKey} in {currentSection} to {arrowBinding}")

            # Make sure all arrow key controls exist in main binding sections
            for prefix, sections in controlSections.items():
                mainBindingSection = f"{prefix}.Bindings"

                # Find the index of the main binding section
                mainSectionIndex = -1
                for i, line in enumerate(configLines):
                    if line.strip() == f"[{mainBindingSection}]":
                        mainSectionIndex = i
                        break

                if mainSectionIndex == -1:
                    continue  # Skip if section not found

                # Find the end of the section
                nextSectionIdx = next((j for j in range(mainSectionIndex+1, len(configLines)) if configLines[j].strip().startswith('[')), len(configLines))

                # Check existing bindings in this section
                existingBindings = {}
                existingKeys = {}
                for i in range(mainSectionIndex+1, nextSectionIdx):
                    line = configLines[i].strip()
                    if '=' in line and not line.startswith('#'):
                        key, binding = line.split('=', 1)
                        key = key.strip()
                        binding = binding.strip()
                        existingBindings[binding] = key
                        existingKeys[key] = binding

                # Add missing standard key bindings
                missingKeys = []
                for key, binding in standardKeys.items():
                    if key not in existingKeys:
                        missingKeys.append(f"{key}={binding}\n")

                # Add missing arrow controls
                for arrowKey, arrowBinding in arrowControls.items():
                    if arrowKey not in existingKeys:
                        missingKeys.append(f"{arrowKey}={arrowBinding}\n")

                # Insert missing controls at the end of the section
                if missingKeys:
                    configLines[nextSectionIdx:nextSectionIdx] = missingKeys
                    changesNeeded = True
                    print(f"Added missing standard controls to {mainBindingSection}")

            # Now check for the Toby accessibility controls across all game types
            for prefix, sections in controlSections.items():
                mainBindingSection = f"{prefix}.Bindings"
                compassModSection = f"{prefix}.CompassMod.Bindings"
                proximitySection = f"{prefix}.ProximityDetector.Bindings"
                checkModSection = f"{prefix}.CheckMod.Bindings"
                targetSnapSection = f"{prefix}.TargetSnap.Bindings"

                # Check if the accessibility sections exist, create them if not
                if compassModSection not in sections:
                    # Add this section after the main Bindings section
                    for i, line in enumerate(configLines):
                        if line.strip() == f"[{mainBindingSection}]":
                            # Find the next section
                            nextSectionIdx = next((j for j in range(i+1, len(configLines)) if configLines[j].strip().startswith('[')), len(configLines))
                            # Insert the new section
                            configLines.insert(nextSectionIdx, f"\n[{compassModSection}]\n")
                            configLines.insert(nextSectionIdx+1, "Q=pukename CompassScript\n")
                            configLines.insert(nextSectionIdx+2, "F=pukename FaceNorth\n")
                            configLines.insert(nextSectionIdx+3, "E=pukename TurnCompass 1\n")
                            configLines.insert(nextSectionIdx+4, "R=pukename TurnCompass 0\n\n")
                            changesNeeded = True
                            print(f"Added {compassModSection} section")
                            break

                # Check if ProximityDetector section needs the apostrophe key binding
                proximityFound = False
                for i, line in enumerate(configLines):
                    if line.strip() == f"[{proximitySection}]":
                        proximityFound = True

                        # Find the start and end of this section
                        sectionStart = i
                        sectionEnd = next((j for j in range(i+1, len(configLines)) if configLines[j].strip().startswith('[')), len(configLines))

                        # Check if the section has the apostrophe binding
                        hasApostrophe = False
                        for j in range(sectionStart+1, sectionEnd):
                            if configLines[j].strip().startswith("'="):
                                hasApostrophe = True
                                break

                        if not hasApostrophe:
                            # Add the apostrophe binding right after the section header
                            configLines.insert(sectionStart+1, "'=toby_proximity_toggle_keybind\n")
                            changesNeeded = True
                            print(f"Added apostrophe key binding to {proximitySection}")

                        break

                # If ProximityDetector section doesn't exist, create it
                if not proximityFound:
                    for i, line in enumerate(configLines):
                        if line.strip() == f"[{mainBindingSection}]":
                            # Find the next section
                            nextSectionIdx = next((j for j in range(i+1, len(configLines)) if configLines[j].strip().startswith('[')), len(configLines))
                            # Insert the new section
                            configLines.insert(nextSectionIdx, f"\n[{proximitySection}]\n")
                            configLines.insert(nextSectionIdx+1, "'=toby_proximity_toggle_keybind\n\n")
                            changesNeeded = True
                            print(f"Added {proximitySection} section with apostrophe key binding")
                            break

                # Check if TargetSnap section needs the Z key binding
                targetSnapFound = False
                for i, line in enumerate(configLines):
                    if line.strip() == f"[{targetSnapSection}]":
                        targetSnapFound = True

                        # Find the start and end of this section
                        sectionStart = i
                        sectionEnd = next((j for j in range(i+1, len(configLines)) if configLines[j].strip().startswith('[')), len(configLines))

                        # Check if the section has the Z binding
                        hasZKey = False
                        for j in range(sectionStart+1, sectionEnd):
                            if configLines[j].strip().startswith("Z="):
                                hasZKey = True
                                break

                        if not hasZKey:
                            # Add the Z binding right after the section header
                            configLines.insert(sectionStart+1, "Z=+toby_snap_to_target_keybind\n")
                            changesNeeded = True
                            print(f"Added Z key binding to {targetSnapSection}")

                        break

                # If TargetSnap section doesn't exist, create it
                if not targetSnapFound:
                    for i, line in enumerate(configLines):
                        if line.strip() == f"[{mainBindingSection}]":
                            # Find the next section
                            nextSectionIdx = next((j for j in range(i+1, len(configLines)) if configLines[j].strip().startswith('[')), len(configLines))
                            # Insert the new section
                            configLines.insert(nextSectionIdx, f"\n[{targetSnapSection}]\n")
                            configLines.insert(nextSectionIdx+1, "Z=+toby_snap_to_target_keybind\n\n")
                            changesNeeded = True
                            print(f"Added {targetSnapSection} section with Z key binding")
                            break

                # Check for missing bindings in sections that do exist
                if checkModSection in sections:
                    # Extract all keys in the CheckMod section
                    checkModStart = -1
                    checkModEnd = -1

                    for i, line in enumerate(configLines):
                        if line.strip() == f"[{checkModSection}]":
                            checkModStart = i
                            checkModEnd = next((j for j in range(i+1, len(configLines)) if configLines[j].strip().startswith('[')), len(configLines))
                            break

                    if checkModStart != -1:
                        # Check for semicolon and N keys
                        hasNKey = False
                        hasSemicolonKey = False

                        for i in range(checkModStart+1, checkModEnd):
                            line = configLines[i].strip()
                            if line.startswith("N="):
                                hasNKey = True
                            elif line.startswith(";="):
                                hasSemicolonKey = True

                        # Add missing keys
                        if not hasNKey:
                            configLines.insert(checkModEnd-1, "N=netevent Toby_CheckArmor\n")
                            changesNeeded = True
                            print(f"Added N key binding to {checkModSection}")

                        if not hasSemicolonKey:
                            configLines.insert(checkModEnd-1, ";=netevent Toby_CheckLevelStats\n")
                            changesNeeded = True
                            print(f"Added semicolon key binding to {checkModSection}")

            # Write the config if needed
            if changesNeeded:
                with open(self.configFile, 'w') as f:
                    f.writelines(configLines)
                print("Updated GZDoom configuration with standard key bindings")

            return changesNeeded

        except Exception as e:
            print(f"Error checking/fixing controls: {e}", file=sys.stderr)
            return False

    def generate_single_player_script(self):
        """Generate script for single player game"""
        selectedGame = self.gameCombo.currentText()
        if selectedGame == "Custom Game":
            self.generate_custom_game_script()
        elif selectedGame == "Audio Manual":
            QMessageBox.information(
                self,
                "Not Applicable",
                "Scripts cannot be generated for Audio Manual"
            )
        else:
            gameFiles = self.get_selected_game_files()
            if gameFiles:
                self.generate_launcher_script(gameFiles)

    def generate_deathmatch_script(self):
        """Open deathmatch dialog and generate script from settings"""
        # First show map selection
        mapOptions = {
            'map': {
                'type': 'combobox',
                'label': 'Select Map',
                'items': self.deathmatchMaps
            }
        }

        mapDialog = MenuDialog("Select Map", mapOptions, self)
        if not mapDialog.exec():
            return

        selectedMap = mapDialog.get_dialog_values()['map']
        mapIndex = mapOptions['map']['items'].index(selectedMap) + 1  # 1-based index

        # Show game options dialog
        options = {
            'mode': {
                'type': 'combobox',
                'label': 'Game Mode',
                'items': [
                    "Host Game",
                    "Join Game",
                    "Bots Only"
                ]
            },
            'ip': {
                'type': 'text',
                'placeholder': 'Enter IP address to join (required for joining)'
            },
            'fraglimit': {
                'type': 'spinbox',
                'label': 'Frag Limit',
                'min': 1,
                'max': 500,
                'default': 20
            },
            'players': {
                'type': 'spinbox',
                'label': 'Number of Players',
                'min': 2,
                'max': 4,
                'default': 2
            },
            'skill': {
                'type': 'spinbox',
                'label': 'Skill Level',
                'min': 1,
                'max': 5,
                'default': 3
            }
        }

        dialog = MenuDialog("Deathmatch Options", options, self)
        if dialog.exec():
            values = dialog.get_dialog_values()
            gameFiles = self.get_selected_game_files()

            # Add deathmatch map
            deathMatchMap = str(self.gamePath / "Addons/MAPS/TobyDeathArena_V1-5.wad")
            if Path(deathMatchMap).exists():
                gameFiles.append(deathMatchMap)

            gameFlags = self.get_deathmatch_flags(values)

            # Add map selection flag
            gameFlags.extend(["-warp", str(mapIndex)])

            # Check/set freedm.wad as IWAD
            freedmPath = self.find_freedm()
            if not freedmPath:
                QMessageBox.critical(self, "Error", "Could not find freedm.wad")
                return

            # Force freedm.wad selection
            for i in range(self.iwadCombo.count()):
                if "freedm" in self.iwadCombo.itemText(i).lower():
                    self.iwadCombo.setCurrentIndex(i)
                    break

            self.generate_launcher_script(gameFiles, gameFlags)

    def generate_custom_deathmatch_script(self):
        """Generate script for custom deathmatch"""
        # First find available PK3s for customization
        pk3List = []
        for item in self.gamePath.glob('*.pk3'):
            if item.stat().st_size > 10 * 1024 * 1024:  # >10MB
                pk3List.append(str(item))

        # Add Army of Darkness if available
        aodWad = self.gamePath / "aoddoom1.wad"
        if aodWad.exists():
            pk3List.append(str(aodWad))

        if not pk3List:
            QMessageBox.warning(self, "Error", "No custom mods found")
            return

        # Create mod selection dialog
        modDialog = QDialog(self)
        modDialog.setWindowTitle("Select Customization")
        dialogLayout = QVBoxLayout(modDialog)

        modLabel = QLabel("Select Mod:")
        modCombo = AccessibleComboBox(modDialog)
        modCombo.setAccessibleName("Mod Selection")
        for pk3 in pk3List:
            modCombo.addItem(Path(pk3).stem, userData=pk3)

        dialogLayout.addWidget(modLabel)
        dialogLayout.addWidget(modCombo)

        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(modDialog.accept)
        buttons.rejected.connect(modDialog.reject)
        dialogLayout.addWidget(buttons)

        if not modDialog.exec():
            return

        selectedMod = modCombo.currentData()

        # Show map selection dialog (same as regular deathmatch)
        mapOptions = {
            'map': {
                'type': 'combobox',
                'label': 'Select Map',
                'items': self.deathmatchMaps
            }
        }

        mapDialog = MenuDialog("Select Map", mapOptions, self)
        if not mapDialog.exec():
            return

        selectedMap = mapDialog.get_dialog_values()['map']
        mapIndex = mapOptions['map']['items'].index(selectedMap) + 1  # 1-based index

        # Show game options dialog
        options = {
            'mode': {
                'type': 'combobox',
                'label': 'Game Mode',
                'items': [
                    "Host Game",
                    "Join Game",
                    "Bots Only"
                ]
            },
            'ip': {
                'type': 'text',
                'placeholder': 'Enter IP address to join (required for joining)'
            },
            'fraglimit': {
                'type': 'spinbox',
                'label': 'Frag Limit',
                'min': 1,
                'max': 500,
                'default': 20
            },
            'players': {
                'type': 'spinbox',
                'label': 'Number of Players',
                'min': 2,
                'max': 4,
                'default': 2
            },
            'skill': {
                'type': 'spinbox',
                'label': 'Skill Level',
                'min': 1,
                'max': 5,
                'default': 3
            }
        }

        dialog = MenuDialog("Deathmatch Options", options, self)
        if dialog.exec():
            values = dialog.get_dialog_values()

            # Set up game files
            gameFiles = [
                str(self.gamePath / f"TobyAccMod_V{self.tobyVersion}.pk3")
            ]

            # Add menu addons
            menuPath = self.gamePath / "Addons/MENU"
            if menuPath.exists():
                gameFiles.extend(str(p) for p in menuPath.glob("Toby*.pk3"))

            # Add selected mod
            gameFiles.append(selectedMod)

            # Add deathmatch map
            deathMatchMap = str(self.gamePath / "Addons/MAPS/TobyDeathArena_V1-5.wad")
            if Path(deathMatchMap).exists():
                gameFiles.append(deathMatchMap)

            # Get deathmatch flags and add map selection
            gameFlags = self.get_deathmatch_flags(values)
            gameFlags.extend(["-warp", str(mapIndex)])

            # Check/set freedm.wad as IWAD
            freedmPath = self.find_freedm()
            if not freedmPath:
                QMessageBox.critical(self, "Error", "Could not find freedm.wad")
                return

            # Force freedm.wad selection
            for i in range(self.iwadCombo.count()):
                if "freedm" in self.iwadCombo.itemText(i).lower():
                    self.iwadCombo.setCurrentIndex(i)
                    break

            self.generate_launcher_script(gameFiles, gameFlags)

    def generate_coop_script(self):
        """Generate script for co-op mode"""
        options = {
            'host': {
                'type': 'radio',
                'label': 'Host Game'
            },
            'ip': {
                'type': 'text',
                'placeholder': 'Enter IP address to join'
            },
            'players': {
                'type': 'spinbox',
                'label': 'Number of Players',
                'min': 2,
                'max': 10,
                'default': 2
            },
            'skill': {
                'type': 'spinbox',
                'label': 'Skill Level',
                'min': 1,
                'max': 5,
                'default': 3
            }
        }

        dialog = MenuDialog("Co-op Options", options, self)
        if dialog.exec():
            values = dialog.get_dialog_values()
            gameFiles = self.get_selected_game_files()
            # Add keyshare for co-op
            keyshareFile = str(self.gamePath / "keyshare-universal.pk3")
            if Path(keyshareFile).exists():
                gameFiles.append(keyshareFile)
            gameFlags = self.get_coop_flags(values)
            self.generate_launcher_script(gameFiles, gameFlags)

    def generate_custom_game_script(self):
        """Generate script for custom game"""
        customGames = self.load_custom_games()
        if not customGames:
            QMessageBox.warning(
                self,
                "No Custom Games",
                "No custom game configurations found in TobyCustom directory."
            )
            return

        dialog = CustomGameDialog(customGames, self)
        if not dialog.exec():
            return

        selectedGame = dialog.get_selected_game()
        if selectedGame and selectedGame in customGames:
            config = customGames[selectedGame]

            # Check dependencies before launching
            if not self.check_dependencies(config.get('dependencies', [])):
                return

            gameFiles = []  # We'll build this up as we go

            # Always start with TobyAccMod
            tobyMod = self.gamePath / f"TobyAccMod_V{self.tobyVersion}.pk3"
            if not tobyMod.exists():
                QMessageBox.critical(self, "Error", f"Could not find {tobyMod}")
                return
            gameFiles.append(str(tobyMod))

            # Handle map selection right after TobyAccMod if specified
            if config.get('use_map_menu', False) and 'submenu' not in config:
                mapFiles = ["None"]  # Start with None option
                mapsDir = self.gamePath / "Addons/MAPS"
                if mapsDir.exists():
                    mapFiles.extend([p.name for p in mapsDir.glob("*.wad") 
                                if p.name != "TobyDeathArena_V1-5.wad"])

                # Add Operation MDK as special case
                opMDK = self.gamePath / "OpMDK.wad"
                if opMDK.exists():
                    mapFiles.append("OpMDK.wad")

                mapDialog = QDialog(self)
                mapDialog.setWindowTitle("Select Map")
                dialogLayout = QVBoxLayout(mapDialog)

                mapLabel = QLabel("Select Map:")
                mapCombo = AccessibleComboBox(mapDialog)
                mapCombo.setAccessibleName("Map Selection")
                mapCombo.addItems(mapFiles)

                dialogLayout.addWidget(mapLabel)
                dialogLayout.addWidget(mapCombo)

                buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
                buttons.accepted.connect(mapDialog.accept)
                buttons.rejected.connect(mapDialog.reject)
                dialogLayout.addWidget(buttons)

                if not mapDialog.exec():
                    return

                selectedMap = mapCombo.currentText()
                if selectedMap != "None":
                    if selectedMap == "OpMDK.wad":
                        mapPath = str(self.gamePath / selectedMap)
                    else:
                        mapPath = str(self.gamePath / "Addons/MAPS" / selectedMap)
                    if Path(mapPath).exists():
                        gameFiles.append(mapPath)

                    if selectedMap == "TobyDoomLevels.wad":
                        musicRenamer = self.gamePath / "Toby-Doom-Level-Music-Renamer.pk3"
                        if musicRenamer.exists():
                            gameFiles.append(str(musicRenamer))

            # Handle submenu if present
            if 'submenu' in config:
                selectedFile = self.show_submenu_dialog(config['submenu'])
                if not selectedFile:
                    return
                gameFiles.append(selectedFile)

            # Add remaining files
            tobyBaseVersion = self.tobyVersion.split('-')[0]
            for filePath in config.get('files', []):
                filePath = filePath.format(toby_base_version=tobyBaseVersion)
                # Handle glob patterns
                if '*' in filePath:
                    pathObj = self.gamePath / filePath.split('*')[0]
                    pattern = filePath.split('/')[-1]
                    if pathObj.parent.exists():
                        matches = list(pathObj.parent.glob(pattern))
                        gameFiles.extend(str(p) for p in matches)
                else:
                    fullPath = self.gamePath / filePath
                    if fullPath.exists():
                        gameFiles.append(str(fullPath))

            # Add optional files last
            for optFile in config.get('optional_files', []):
                optPath = self.gamePath / optFile
                if optPath.exists():
                    gameFiles.append(str(optPath))

            # Get any custom flags
            gameFlags = config.get('flags', [])

            # Generate the script if we have files
            if gameFiles:
                iwadIndex = self.iwadCombo.currentIndex()
                if iwadIndex < 0:
                    QMessageBox.critical(self, "Error", "Please select an IWAD first")
                    return

                self.generate_launcher_script(gameFiles, gameFlags)

    def generate_launcher_script(self, gameFiles, gameFlags=None):
        """Generate a batch or bash script for launching the game"""
        if not gameFiles:
            return

        gzdoomPath = self.find_gzdoom()
        if not gzdoomPath:
            QMessageBox.critical(self, "Error", "GZDoom executable not found")
            return

        # Get selected IWAD
        iwadIndex = self.iwadCombo.currentIndex()
        if iwadIndex < 0:
            QMessageBox.critical(self, "Error", "Please select an IWAD first")
            return

        iwadPath = self.iwadCombo.itemData(iwadIndex)
        iwadName = self.iwadCombo.currentText().lower()

        # Get selected game type
        selectedGame = self.gameCombo.currentText().replace(" ", "_").lower()

        # Initialize gameFlags if None
        if gameFlags is None:
            gameFlags = []

        # Get additional flags from doom_flags.txt
        additionalFlags = self.get_flags_from_file()
        if additionalFlags:
            gameFlags.extend(additionalFlags)

        # Determine file format based on OS
        extension = ".bat" if platform.system() == "Windows" else ".sh"
        baseFileName = f"{iwadName}_{selectedGame}{extension}"

        # Handle special case for custom games or different dialogs
        if selectedGame == "custom_game":
            baseFileName = f"{iwadName}_custom_game{extension}"
        elif "-deathmatch" in gameFlags or any("deathmatch" in flag.lower() for flag in gameFlags):
            baseFileName = f"{iwadName}_deathmatch{extension}"
        elif "-join" in gameFlags or "-host" in gameFlags:
            baseFileName = f"{iwadName}_coop{extension}"

        # Clean up the filename (remove any unsafe characters)
        baseFileName = re.sub(r'[^\w\-\.]', '_', baseFileName)

        if platform.system() == "Windows":
            # Windows: save in current directory
            baseDir = Path.cwd()

            # Build Windows batch file content
            content = ["@echo off"]

            # Use gzdoom.exe with line continuation character
            content.append("gzdoom.exe ^")
            content.append("  -stdout ^")

            # Add config file 
            configFile = Path.cwd() / 'TobyConfig.ini'
            if configFile.exists():
                content.append(f"  -config TobyConfig.ini ^")

            # Add narration type
            narrationType = self.get_narration_type()
            content.append(f"  +Toby_NarrationOutputType {narrationType} ^")

            # Add IWAD
            content.append(f"  -iwad \"{iwadPath}\" ^")

            # Add game files
            for file in gameFiles:
                # Use relative paths with ./ prefix for better readability if possible
                if str(file).startswith(str(self.gamePath)):
                    relPath = Path(file).relative_to(self.gamePath)
                    content.append(f"  -file \"./{relPath}\" ^")
                else:
                    content.append(f"  -file \"{file}\" ^")

            # Add game flags
            for flag in gameFlags:
                content.append(f"  {flag} ^")

            # Remove the trailing ^ from the last line
            if content[-1].endswith(" ^"):
                content[-1] = content[-1][:-2]

            # Add TTS powershell script
            content.append("  | powershell -ExecutionPolicy Bypass -File DoomTTS.ps1")

        else:
            # Linux/Mac: save in ~/.local/games/doom
            baseDir = Path.home() / ".local/games/doom"
            baseDir.mkdir(parents=True, exist_ok=True)  # Create directory if it doesn't exist

            # Build bash script content
            content = ["#!/usr/bin/env bash"]

            # Use 'exec' with stdbuf
            try:
                gzdoom_path = subprocess.check_output(["which", "gzdoom"], 
                                                    text=True, 
                                                    stderr=subprocess.PIPE).strip()
                content.append(f"exec stdbuf -oL {gzdoom_path} \\")
            except subprocess.CalledProcessError:
                # Couldn't get the path, just use the command and hope for the best
                content.append("exec stdbuf -oL gzdoom \\")

            # Add IWAD
            content.append(f"  -iwad \"{iwadPath}\" \\")

            # Add -file flag before listing the files
            content.append("  -file \\")

            # Add each game file on its own line
            for i, file in enumerate(gameFiles):
                if i < len(gameFiles) - 1:
                    content.append(f"    \"{file}\" \\")
                else:
                    # Last file doesn't need continuation
                    content.append(f"    \"{file}\"")

            # Add game flags if present
            if gameFlags:
                content.append("  \\")  # Add continuation
                for i, flag in enumerate(gameFlags):
                    if i < len(gameFlags) - 1:
                        content.append(f"  {flag} \\")
                    else:
                        # Last flag doesn't need continuation
                        content.append(f"  {flag}")

            # This waits for a line of dashes, then starts piping to speech-dispatcher
            content[-1] = content[-1] + " |"
            content.append("grep --line-buffered -A 1000000 '^-\\+-*$' |")
            content.append("grep --line-buffered -v -e '^Unknown' -e '^fluidsynth:'|")
            content.append("sed -u -e 's/^\\[Toby Accessibility Mod\\] //' -e 's/^M_//' -e 's/\\([a-z]\\)\\([A-Z]\\)/\\1 \\2/g' -e 's/\\([A-Za-z]\\+\\)menu\\>/\\1 menu/g' -e 's/^\\([A-Z][A-Z]*\\)G$/\\L\\1\\E game/g' |")
            content.append("spd-say --wait -e")

        # Generate a unique filename
        fileName = baseFileName
        filePath = baseDir / fileName
        counter = 1

        # Check if file exists and generate new name if needed
        while filePath.exists():
            nameBase, extension = baseFileName.rsplit('.', 1)
            fileName = f"{nameBase}_{counter}.{extension}"
            filePath = baseDir / fileName
            counter += 1

        try:
            with open(filePath, 'w') as f:
                f.write('\n'.join(content))

            # Make the file executable on Linux/Mac
            if platform.system() != "Windows":
                os.chmod(filePath, 0o755)

            QMessageBox.information(
                self,
                "Success",
                f"Launcher script saved to {filePath}"
            )
        except Exception as e:
            QMessageBox.critical(
                self,
                "Error",
                f"Failed to save launcher script: {e}"
            )

    def keyPressEvent(self, event):
        """Handle key press events"""
        if event.key() == Qt.Key_Escape:
            self.close()

    def handle_button_keypress(self, event, button):
        """Handle key press events for buttons"""
        if event.key() in (Qt.Key_Return, Qt.Key_Enter):
            button.click()
        # Make sure to call the parent class's key press event
        QPushButton.keyPressEvent(button, event)

    def populate_iwad_list(self):
        """Populate the IWAD selection combo box"""
        iwads = self.iwadSelector.find_iwads()
        for name, path in iwads.items():
            self.iwadCombo.addItem(name, userData=path)

    def init_launcher_ui(self):
        """Initialize the main launcher UI"""
        centralWidget = QWidget()
        self.setCentralWidget(centralWidget)
        mainLayout = QVBoxLayout(centralWidget)

        # IWAD Selection
        iwadLabel = QLabel("Select IWAD:")
        self.iwadCombo = AccessibleComboBox(self)
        self.iwadCombo.setAccessibleName("IWAD Selection")
        self.populate_iwad_list()
        mainLayout.addWidget(iwadLabel)
        mainLayout.addWidget(self.iwadCombo)

        # Game Selection
        self.gameCombo = AccessibleComboBox(self)
        self.gameCombo.setAccessibleName("Game Selection")
        self.populate_game_list()
        self.gameCombo.lineEdit().returnPressed.connect(self.launch_single_player)
        mainLayout.addWidget(QLabel("Select Game:"))
        mainLayout.addWidget(self.gameCombo)

        # Narration style selection
        self.narrationCombo = AccessibleComboBox(self)
        self.narrationCombo.setAccessibleName("Narration Style")
        self.narrationCombo.addItems(["Self-voiced", "Text to Speech"])
        # Set current value based on config
        current = self.get_narration_type()
        self.narrationCombo.setCurrentText(
            "Self-voiced" if current == 0 else "Text to Speech"
        )
        self.narrationCombo.currentTextChanged.connect(self.narration_type_changed)

        mainLayout.addWidget(QLabel("Narration Style:"))
        mainLayout.addWidget(self.narrationCombo)

        # Create button layouts with pairs of launch and generate buttons
        # Single Player
        singlePlayerLayout = QHBoxLayout()
        self.singlePlayerBtn = QPushButton("&Single Player")
        self.singlePlayerGenBtn = QPushButton("Generate Single Player Script")
        self.singlePlayerBtn.clicked.connect(self.launch_single_player)
        self.singlePlayerGenBtn.clicked.connect(self.generate_single_player_script)
        singlePlayerLayout.addWidget(self.singlePlayerBtn)
        singlePlayerLayout.addWidget(self.singlePlayerGenBtn)
        mainLayout.addLayout(singlePlayerLayout)

        # Deathmatch
        deathMatchLayout = QHBoxLayout()
        self.deathMatchBtn = QPushButton("&Deathmatch")
        self.deathMatchGenBtn = QPushButton("Generate Deathmatch Script")
        self.deathMatchBtn.clicked.connect(self.show_deathmatch_dialog)
        self.deathMatchGenBtn.clicked.connect(self.generate_deathmatch_script)
        deathMatchLayout.addWidget(self.deathMatchBtn)
        deathMatchLayout.addWidget(self.deathMatchGenBtn)
        mainLayout.addLayout(deathMatchLayout)

        # Custom Deathmatch
        customDeathMatchLayout = QHBoxLayout()
        self.customDeathMatchBtn = QPushButton("C&ustom Deathmatch")  # Alt+U
        self.customDeathMatchGenBtn = QPushButton("Generate Custom Deathmatch Script")
        self.customDeathMatchBtn.clicked.connect(self.show_custom_deathmatch_dialog)
        self.customDeathMatchGenBtn.clicked.connect(self.generate_custom_deathmatch_script)
        customDeathMatchLayout.addWidget(self.customDeathMatchBtn)
        customDeathMatchLayout.addWidget(self.customDeathMatchGenBtn)
        mainLayout.addLayout(customDeathMatchLayout)

        # Co-op
        coopLayout = QHBoxLayout()
        self.coopBtn = QPushButton("&Co-op")
        self.coopGenBtn = QPushButton("Generate Co-op Script")
        self.coopBtn.clicked.connect(self.show_coop_dialog)
        self.coopGenBtn.clicked.connect(self.generate_coop_script)
        coopLayout.addWidget(self.coopBtn)
        coopLayout.addWidget(self.coopGenBtn)
        mainLayout.addLayout(coopLayout)

        # Audio Manual (no script generation for this)
        self.audioManualBtn = QPushButton("&Audio Manual")  # Alt+A
        self.audioManualBtn.clicked.connect(self.show_audio_manual)
        mainLayout.addWidget(self.audioManualBtn)

        # Set key press event handlers
        self.singlePlayerBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.singlePlayerBtn)
        self.deathMatchBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.deathMatchBtn)
        self.customDeathMatchBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.customDeathMatchBtn)
        self.coopBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.coopBtn)
        self.audioManualBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.audioManualBtn)
        self.singlePlayerGenBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.singlePlayerGenBtn)
        self.deathMatchGenBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.deathMatchGenBtn)
        self.customDeathMatchGenBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.customDeathMatchGenBtn)
        self.coopGenBtn.keyPressEvent = lambda e: self.handle_button_keypress(e, self.coopGenBtn)

    def get_narration_type(self) -> int:
        """Get the current narration type from config file"""
        try:
            if not self.configFile.exists():
                return 0  # Default if file doesn't exist

            with open(self.configFile, 'r') as f:
                for line in f:
                    line = line.strip()
                    if line.startswith('Toby_NarrationOutputType='):
                        value = line.split('=')[1].strip()
                        return int(value)
            return 0  # Default to self-voiced if not found
        except Exception as e:
            print(f"Error reading config: {e}", file=sys.stderr)
            return 0

    def set_narration_type(self, value: int) -> bool:
        """Set the narration type in config file

        Args:
            value (int): Narration type (0 for self-voiced, 2 for TTS)

        Returns:
            bool: True if successful, False otherwise
        """
        try:
            if not self.configFile.exists():
                # Create new config with default section
                with open(self.configFile, 'w') as f:
                    f.write('[GlobalSettings]\n')
                    f.write(f'Toby_NarrationOutputType={value}\n')
                return True

            # Read all lines
            with open(self.configFile, 'r') as f:
                lines = f.readlines()

            # Try to find and replace existing setting
            found = False
            for i, line in enumerate(lines):
                if line.strip().startswith('Toby_NarrationOutputType='):
                    lines[i] = f'Toby_NarrationOutputType={value}\n'
                    found = True
                    break

            # If not found, add to end or after [GlobalSettings]
            if not found:
                globalSettingsIndex = -1
                for i, line in enumerate(lines):
                    if line.strip() == '[GlobalSettings]':
                        globalSettingsIndex = i
                        break

                if globalSettingsIndex >= 0:
                    # Insert after [GlobalSettings]
                    lines.insert(globalSettingsIndex + 1, f'Toby_NarrationOutputType={value}\n')
                else:
                    # Add [GlobalSettings] section if it doesn't exist
                    lines.append('\n[GlobalSettings]\n')
                    lines.append(f'Toby_NarrationOutputType={value}\n')

            # Write back the modified content
            with open(self.configFile, 'w') as f:
                f.writelines(lines)
            return True

        except Exception as e:
            print(f"Error writing config: {e}", file=sys.stderr)
            return False

    def narration_type_changed(self, text: str):
        """Handle narration type combobox changes"""
        value = 0 if text == "Self-voiced" else 2
        if not self.set_narration_type(value):
            QMessageBox.warning(
                self,
                "Error",
                "Failed to update narration setting. Check file permissions."
            )
            # Reset combobox to current value
            current = self.get_narration_type()
            self.narrationCombo.setCurrentText(
                "Self-voiced" if current == 0 else "Text to Speech"
            )
        else:
            # Update speech handler state directly
            self.speechHandler.set_tts_state(value == 2)

    def populate_game_list(self):
        """Populate the game selection combo box"""
        gameList = [
            "Toby Demo Map",
            "Classic Doom",
            "Toby Doom",
            "OperationMDK",
            "Classic Heretic",
            "Toby Heretic",
            "Classic Hexen",
            "Toby Hexen",
            "Custom Game"
        ]

        for gameName in gameList:
            self.gameCombo.addItem(gameName)

    def find_freedm(self) -> Optional[str]:
        """Find freedm.wad in standard locations"""
        # Check common locations
        locations = [
            self.gamePath / "freedm.wad",
            Path("/usr/share/games/doom/freedm.wad"),
            Path("/usr/share/doom/freedm.wad")
        ]

        for loc in locations:
            if loc.exists():
                return str(loc)

        return None

    def find_gzdoom(self) -> Optional[str]:
        """Find the GZDoom executable"""
        if platform.system() == "Windows":
            gzdoomPath = Path.cwd() / "gzdoom.exe"
            return str(gzdoomPath) if gzdoomPath.exists() else None

        return shutil.which("gzdoom")

    def get_addon_files(self, game_type: str = "DOOM") -> List[str]:
        """Get all addon PK3 files for specified game type"""
        addonFiles = []
        # MENU addons are common to all games
        menuPath = self.gamePath / "Addons" / "MENU"
        if menuPath.exists():
            addonFiles.extend(str(p) for p in menuPath.glob("Toby*.pk3"))

        # Game specific addons
        gamePath = self.gamePath / "Addons" / game_type
        if gamePath.exists():
            if game_type == "HERETIC":
                pattern = "TobyHeretic*.pk3"
            elif game_type == "HEXEN":
                pattern = "TobyHexen*.pk3"
            else:  # DOOM
                pattern = "Toby*.pk3"
            addonFiles.extend(str(p) for p in gamePath.glob(pattern))

        return addonFiles

    def get_selected_game_files(self) -> List[str]:
        tobyMod = self.gamePath / f"TobyAccMod_V{self.tobyVersion}.pk3"
        if not tobyMod.exists():
            QMessageBox.critical(self, "Error", f"Could not find {tobyMod}")
            return []

        baseFiles = [str(tobyMod)]
        selectedGame = self.gameCombo.currentText()

        # Determine game type and get corresponding addons
        if "Heretic" in selectedGame:
            gameType = "HERETIC"
            if "Toby Heretic" in selectedGame:
                baseFiles.append(str(self.gamePath / "Addons/MAPS/TobyHereticLevels.wad"))
        elif "Hexen" in selectedGame:
            gameType = "HEXEN"
            if "Toby Hexen" in selectedGame:
                baseFiles.append(str(self.gamePath / "Addons/MAPS/TobyHexen.pk3"))
        else:  # Doom games
            gameType = "DOOM"
            if "Demo Map" in selectedGame:
                baseFiles.append(str(self.gamePath / "Addons/MAPS/Toby-Demo-Level.wad"))
            elif "Toby Doom" in selectedGame:
                baseFiles.append(str(self.gamePath / "Addons/MAPS/TobyDoomLevels.wad"))
                musicRenamer = self.gamePath / "Toby-Doom-Level-Music-Renamer.pk3"
                if musicRenamer.exists():
                    baseFiles.append(str(musicRenamer))
            elif "OperationMDK" in selectedGame:
                baseFiles.append(str(self.gamePath / "OpMDK.wad"))

            # Add metal music mod if available (Doom only)
            metalV7 = self.gamePath / "DoomMetalVol7.wad"
            metalV6 = self.gamePath / "DoomMetalVol6.wad"
            if metalV7.exists():
                baseFiles.append(str(metalV7))
            elif metalV6.exists():
                baseFiles.append(str(metalV6))

        # Add game-specific addons
        baseFiles.extend(self.get_addon_files(gameType))
        return baseFiles

    def show_custom_deathmatch_dialog(self):
        """Show custom deathmatch configuration dialog"""
        # First find available PK3s for customization
        pk3List = []
        for item in self.gamePath.glob('*.pk3'):
            if item.stat().st_size > 10 * 1024 * 1024:  # >10MB
                pk3List.append(str(item))

        # Add Army of Darkness if available
        aodWad = self.gamePath / "aoddoom1.wad"
        if aodWad.exists():
            pk3List.append(str(aodWad))

        if not pk3List:
            QMessageBox.warning(self, "Error", "No custom mods found")
            return

        # Create mod selection dialog
        modDialog = QDialog(self)
        modDialog.setWindowTitle("Select Customization")
        dialogLayout = QVBoxLayout(modDialog)

        modLabel = QLabel("Select Mod:")
        modCombo = AccessibleComboBox(modDialog)
        modCombo.setAccessibleName("Mod Selection")
        for pk3 in pk3List:
            modCombo.addItem(Path(pk3).stem, userData=pk3)

        dialogLayout.addWidget(modLabel)
        dialogLayout.addWidget(modCombo)

        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(modDialog.accept)
        buttons.rejected.connect(modDialog.reject)
        dialogLayout.addWidget(buttons)

        if not modDialog.exec():
            return

        selectedMod = modCombo.currentData()

        # Show map selection dialog (same as regular deathmatch)
        mapOptions = {
            'map': {
                'type': 'combobox',
                'label': 'Select Map',
                'items': self.deathmatchMaps
            }
        }

        mapDialog = MenuDialog("Select Map", mapOptions, self)
        if not mapDialog.exec():
            return

        selectedMap = mapDialog.get_dialog_values()['map']
        mapIndex = mapOptions['map']['items'].index(selectedMap) + 1  # 1-based index

        # Show game options dialog
        options = {
            'mode': {
                'type': 'combobox',
                'label': 'Game Mode',
                'items': [
                    "Host Game",
                    "Join Game",
                    "Bots Only"
                ]
            },
            'ip': {
                'type': 'text',
                'placeholder': 'Enter IP address to join (required for joining)'
            },
            'fraglimit': {
                'type': 'spinbox',
                'label': 'Frag Limit',
                'min': 1,
                'max': 500,
                'default': 20
            },
            'players': {
                'type': 'spinbox',
                'label': 'Number of Players',
                'min': 2,
                'max': 4,
                'default': 2
            },
            'skill': {
                'type': 'spinbox',
                'label': 'Skill Level',
                'min': 1,
                'max': 5,
                'default': 3
            }
        }

        dialog = MenuDialog("Deathmatch Options", options, self)
        if dialog.exec():
            values = dialog.get_dialog_values()

            # Set up game files
            gameFiles = [
                str(self.gamePath / f"TobyAccMod_V{self.tobyVersion}.pk3")
            ]

            # Add menu addons
            menuPath = self.gamePath / "Addons/MENU"
            if menuPath.exists():
                gameFiles.extend(str(p) for p in menuPath.glob("Toby*.pk3"))

            # Add selected mod
            gameFiles.append(selectedMod)

            # Add deathmatch map
            deathMatchMap = str(self.gamePath / "Addons/MAPS/TobyDeathArena_V1-5.wad")
            if Path(deathMatchMap).exists():
                gameFiles.append(deathMatchMap)

            # Get deathmatch flags and add map selection
            gameFlags = self.get_deathmatch_flags(values)
            gameFlags.extend(["-warp", str(mapIndex)])

            # Check/set freedm.wad as IWAD
            freedmPath = self.find_freedm()
            if not freedmPath:
                QMessageBox.critical(self, "Error", "Could not find freedm.wad")
                return

            # Force freedm.wad selection
            for i in range(self.iwadCombo.count()):
                if "freedm" in self.iwadCombo.itemText(i).lower():
                    self.iwadCombo.setCurrentIndex(i)
                    break

            # Check if we should generate a script or launch the game
            if dialog.generateScript:
                self.generate_launcher_script(gameFiles, gameFlags)
            else:
                self.launch_game(gameFiles, gameFlags)

    def load_custom_games(self) -> Dict[str, dict]:
        """Load all custom game configurations"""
        customGames = {}
        if platform.system() == "Windows":
            customDir = Path.cwd() / "TobyCustom"
        else:
            pathList = [
                Path(__file__).parent / "TobyCustom",
                self.gamePath / "TobyCustom",
                Path(os.path.expanduser("~/.local/share/doom/TobyCustom"))
            ]

            # Use first existing path or fall back to original
            customDir = next(
                (path for path in pathList if path.exists()),
                Path(__file__).parent / "TobyCustom"
            )

        if not customDir.exists():
            return customGames

        for json_file in customDir.glob("*.json"):
            try:
                with open(json_file, 'r') as f:
                    game_config = json.load(f)
                    customGames[game_config['name']] = game_config
            except Exception as e:
                print(f"Error loading custom game {json_file}: {e}")

        return customGames

    def check_dependencies(self, dependencies: List[dict]) -> bool:
        """Check if required files exist and show download info if not"""
        for dep in dependencies:
            file_path = self.gamePath / dep['file']
            if not file_path.exists():
                message = [
                    f"You are missing the \"{dep['file']}\" Package.\n",
                    f"You can get it from \"{dep['url']}\"\n",
                    "The URL will now open in your browser.\n"
                ]
                message.extend(f"{msg}\n" for msg in dep.get('messages', []))

                QMessageBox.critical(
                    self,
                    "Missing Dependency",
                    "".join(message)
                )

                # Open the URL in browser
                try:
                    webbrowser.open(dep['url'])
                except Exception:
                    pass

                return False
        return True

    def show_custom_game_dialog(self):
        """Show dialog for custom game selection"""
        customGames = self.load_custom_games()
        if not customGames:
            QMessageBox.warning(
                self,
                "No Custom Games",
                "No custom game configurations found in TobyCustom directory."
            )
            return

        dialog = CustomGameDialog(customGames, self)
        if not dialog.exec():
            return

        selectedGame = dialog.get_selected_game()
        if selectedGame and selectedGame in customGames:
            config = customGames[selectedGame]

            # Check dependencies before launching
            if not self.check_dependencies(config.get('dependencies', [])):
                return

            gameFiles = []  # We'll build this up as we go

            # Always start with TobyAccMod
            tobyMod = self.gamePath / f"TobyAccMod_V{self.tobyVersion}.pk3"
            if not tobyMod.exists():
                QMessageBox.critical(self, "Error", f"Could not find {tobyMod}")
                return
            gameFiles.append(str(tobyMod))

            # Add script generation option to map selection dialog
            generateScript = False

            # Handle map selection right after TobyAccMod if specified
            if config.get('use_map_menu', False) and 'submenu' not in config:
                mapFiles = ["None"]  # Start with None option
                mapsDir = self.gamePath / "Addons/MAPS"
                if mapsDir.exists():
                    mapFiles.extend([p.name for p in mapsDir.glob("*.wad") 
                                if p.name != "TobyDeathArena_V1-5.wad"])

                # Add Operation MDK as special case
                opMDK = self.gamePath / "OpMDK.wad"
                if opMDK.exists():
                    mapFiles.append("OpMDK.wad")

                mapDialog = QDialog(self)
                mapDialog.setWindowTitle("Select Map")
                dialogLayout = QVBoxLayout(mapDialog)

                mapLabel = QLabel("Select Map:")
                mapCombo = AccessibleComboBox(mapDialog)
                mapCombo.setAccessibleName("Map Selection")
                mapCombo.addItems(mapFiles)

                dialogLayout.addWidget(mapLabel)
                dialogLayout.addWidget(mapCombo)

                # Create custom button box with Launch and Generate Script options
                buttonBox = QDialogButtonBox()
                launchButton = buttonBox.addButton("Launch Game", QDialogButtonBox.AcceptRole)
                scriptButton = buttonBox.addButton("Generate Script", QDialogButtonBox.ActionRole)
                buttonBox.addButton(QDialogButtonBox.Cancel)

                # Connect buttons
                launchButton.clicked.connect(mapDialog.accept)
                scriptButton.clicked.connect(lambda: setattr(mapDialog, "generateScript", True) or mapDialog.accept())
                buttonBox.rejected.connect(mapDialog.reject)

                dialogLayout.addWidget(buttonBox)

                # Initialize generateScript flag
                mapDialog.generateScript = False

                if not mapDialog.exec():
                    return

                # Capture the generateScript flag
                generateScript = getattr(mapDialog, "generateScript", False)

                selectedMap = mapCombo.currentText()
                if selectedMap != "None":
                    if selectedMap == "OpMDK.wad":
                        mapPath = str(self.gamePath / selectedMap)
                    else:
                        mapPath = str(self.gamePath / "Addons/MAPS" / selectedMap)
                    if Path(mapPath).exists():
                        gameFiles.append(mapPath)

                    if selectedMap == "TobyDoomLevels.wad":
                        musicRenamer = self.gamePath / "Toby-Doom-Level-Music-Renamer.pk3"
                        if musicRenamer.exists():
                            gameFiles.append(str(musicRenamer))

            # Handle submenu if present
            if 'submenu' in config:
                submenuResult = self.show_submenu_dialog_with_script_option(config['submenu'])
                if not submenuResult:
                    return
                selectedFile, submenuGenerateScript = submenuResult
                gameFiles.append(selectedFile)
                generateScript = submenuGenerateScript

            # Add remaining files
            tobyBaseVersion = self.tobyVersion.split('-')[0]
            for filePath in config.get('files', []):
                filePath = filePath.format(toby_base_version=tobyBaseVersion)
                # Handle glob patterns
                if '*' in filePath:
                    pathObj = self.gamePath / filePath.split('*')[0]
                    pattern = filePath.split('/')[-1]
                    if pathObj.parent.exists():
                        matches = list(pathObj.parent.glob(pattern))
                        gameFiles.extend(str(p) for p in matches)
                else:
                    fullPath = self.gamePath / filePath
                    if fullPath.exists():
                        gameFiles.append(str(fullPath))

            # Add optional files last
            for optFile in config.get('optional_files', []):
                optPath = self.gamePath / optFile
                if optPath.exists():
                    gameFiles.append(str(optPath))

            # Get any custom flags
            gameFlags = config.get('flags', [])

            # Launch the game if we have files
            if gameFiles:
                iwadIndex = self.iwadCombo.currentIndex()
                if iwadIndex < 0:
                    QMessageBox.critical(self, "Error", "Please select an IWAD first")
                    return

                # Either generate a script or launch the game based on user choice
                if generateScript:
                    self.generate_launcher_script(gameFiles, gameFlags)
                else:
                    self.launch_game(gameFiles, gameFlags)

    def show_submenu_dialog(self, submenu_config) -> Optional[str]:
        """Show dialog for selecting submenu option"""
        # For backward compatibility - calls new method
        result = self.show_submenu_dialog_with_script_option(submenu_config)
        if result:
            return result[0]  # Return just the file path
        return None

    def show_submenu_dialog_with_script_option(self, submenu_config) -> Optional[Tuple[str, bool]]:
        """Show dialog for selecting submenu option with script generation option"""
        dialog = QDialog(self)
        dialog.setWindowTitle(submenu_config['title'])
        dialogLayout = QVBoxLayout(dialog)

        # Game selection combobox
        label = QLabel("Select Version:")
        gameCombo = AccessibleComboBox(dialog)
        gameCombo.setAccessibleName("Game Version Selection")

        # Add options and store full file paths as user data
        for option in submenu_config['options']:
            gameCombo.addItem(option['name'], userData=str(self.gamePath / option['file']))

        dialogLayout.addWidget(label)
        dialogLayout.addWidget(gameCombo)

        # Create custom button box with Launch and Generate Script options
        buttonBox = QDialogButtonBox()
        launchButton = buttonBox.addButton("Launch Game", QDialogButtonBox.AcceptRole)
        scriptButton = buttonBox.addButton("Generate Script", QDialogButtonBox.ActionRole)
        buttonBox.addButton(QDialogButtonBox.Cancel)

        # Connect buttons
        launchButton.clicked.connect(dialog.accept)
        scriptButton.clicked.connect(lambda: setattr(dialog, "generateScript", True) or dialog.accept())
        buttonBox.rejected.connect(dialog.reject)

        dialogLayout.addWidget(buttonBox)

        # Initialize generateScript flag
        dialog.generateScript = False

        if dialog.exec():
            return gameCombo.currentData(), getattr(dialog, "generateScript", False)
        return None

    def launch_single_player(self):
        """Launch single player game"""
        selectedGame = self.gameCombo.currentText()
        if selectedGame == "Custom Game":
            self.show_custom_game_dialog()
        elif selectedGame == "Audio Manual":
            self.show_audio_manual()
        else:
            gameFiles = self.get_selected_game_files()
            if gameFiles:
                # Get selected IWAD
                iwadIndex = self.iwadCombo.currentIndex()
                if iwadIndex < 0:
                    QMessageBox.critical(self, "Error", "Please select an IWAD first")
                    return

                iwadPath = self.iwadCombo.itemData(iwadIndex)
                cmdLine = [self.find_gzdoom(), "-iwad", iwadPath] + gameFiles
                if cmdLine[0]:  # If gzdoom was found
                    self.launch_game(gameFiles)

    def show_audio_manual(self):
        """Show and play audio manual"""
        manualPath = self.gamePath / "Manual"
        if not manualPath.exists():
            QMessageBox.warning(self, "Error", "Manual directory not found")
            return

        dialog = AudioManualDialog(manualPath, self)
        dialog.exec()

    def show_deathmatch_dialog(self):
        """Show deathmatch configuration dialog"""
        # First show map selection
        mapOptions = {
            'map': {
                'type': 'combobox',
                'label': 'Select Map',
                'items': self.deathmatchMaps
            }
        }

        mapDialog = MenuDialog("Select Map", mapOptions, self)
        if not mapDialog.exec():
            return

        selectedMap = mapDialog.get_dialog_values()['map']
        mapIndex = mapOptions['map']['items'].index(selectedMap) + 1  # 1-based index

        # Show game options dialog
        options = {
            'mode': {
                'type': 'combobox',
                'label': 'Game Mode',
                'items': [
                    "Host Game",
                    "Join Game",
                    "Bots Only"
                ]
            },
            'ip': {
                'type': 'text',
                'placeholder': 'Enter IP address to join (required for joining)'
            },
            'fraglimit': {
                'type': 'spinbox',
                'label': 'Frag Limit',
                'min': 1,
                'max': 500,
                'default': 20
            },
            'players': {
                'type': 'spinbox',
                'label': 'Number of Players',
                'min': 2,
                'max': 4,
                'default': 2
            },
            'skill': {
                'type': 'spinbox',
                'label': 'Skill Level',
                'min': 1,
                'max': 5,
                'default': 3
            }
        }

        dialog = MenuDialog("Deathmatch Options", options, self)
        if dialog.exec():
            values = dialog.get_dialog_values()
            gameFiles = self.get_selected_game_files()
            # Add deathmatch map
            deathMatchMap = str(self.gamePath / "Addons/MAPS/TobyDeathArena_V1-5.wad")
            if Path(deathMatchMap).exists():
                gameFiles.append(deathMatchMap)
            gameFlags = self.get_deathmatch_flags(values)
            # Add map selection flag
            gameFlags.extend(["-warp", str(mapIndex)])

            # Check/set freedm.wad as IWAD
            freedmPath = self.find_freedm()
            if not freedmPath:
                QMessageBox.critical(self, "Error", "Could not find freedm.wad")
                return

            # Force freedm.wad selection
            for i in range(self.iwadCombo.count()):
                if "freedm" in self.iwadCombo.itemText(i).lower():
                    self.iwadCombo.setCurrentIndex(i)
                    break

            # Check if we should generate a script or launch the game
            if dialog.generateScript:
                self.generate_launcher_script(gameFiles, gameFlags)
            else:
                self.launch_game(gameFiles, gameFlags)

    def show_coop_dialog(self):
        """Show co-op configuration dialog"""
        options = {
            'host': {
                'type': 'radio',
                'label': 'Host Game'
            },
            'ip': {
                'type': 'text',
                'placeholder': 'Enter IP address to join'
            },
            'players': {
                'type': 'spinbox',
                'label': 'Number of Players',
                'min': 2,
                'max': 10,
                'default': 2
            },
            'skill': {
                'type': 'spinbox',
                'label': 'Skill Level',
                'min': 1,
                'max': 5,
                'default': 3
            }
        }

        dialog = MenuDialog("Co-op Options", options, self)
        if dialog.exec():
            values = dialog.get_dialog_values()
            gameFiles = self.get_selected_game_files()
            # Add keyshare for co-op
            keyshareFile = str(self.gamePath / "keyshare-universal.pk3")
            if Path(keyshareFile).exists():
                gameFiles.append(keyshareFile)
            gameFlags = self.get_coop_flags(values)

            # Check if we should generate a script or launch the game
            if dialog.generateScript:
                self.generate_launcher_script(gameFiles, gameFlags)
            else:
                self.launch_game(gameFiles, gameFlags)

    def get_deathmatch_flags(self, values: dict) -> List[str]:
        """Get command line flags for deathmatch mode"""
        mode = values['mode']

        if mode == "Join Game":
            if not values['ip'].strip():
                QMessageBox.warning(self, "Error", "IP address required for joining")
                return []
            return ["-join", values['ip']]

        # Handle both Host Game and Bots Only
        if mode == "Bots Only":
            values['players'] = 1
            QMessageBox.information(
                self,
                "Bot Instructions",
                "When the game starts, press ` to open the console.\n"
                "Type addbot and press enter.\n"
                "Repeat addbot for as many bots as you want.\n"
                "Press ` again to close the console."
            )

        return [
            "-host", str(values['players']),
            "-skill", str(values['skill']),
            "-deathmatch",
            "+Toby_SnapToTargetTargetingMode", "0",
            "+set", "sv_cheats", "1",
            "+fraglimit", str(values['fraglimit']),
            "+dmflags", "16384",
            "+dmflags", "4",
            "+dmflags", "128",
            "+dmflags", "4096",
            "+dmflags2", "512",
            "+dmflags2", "1024",
            "-extratic",
            "-dup", "3"
        ]

    def get_coop_flags(self, values: dict) -> List[str]:
        """Get command line flags for co-op mode"""
        if not values['host']:
            if not values['ip'].strip():
                QMessageBox.warning(self, "Error", "IP address required for joining")
                return []
            return ["-join", values['ip']]

        return [
            "-host", str(values['players']),
            "-skill", str(values['skill']),
            "+set", "sv_cheats", "1",
            "+set", "sv_weaponsstay", "1",
            "+set", "sv_respawnprotect", "1",
            "+set", "sv_respawnsuper", "1",
            "+set", "alwaysapplydmflags", "1",
            "-extratic",
            "-dup", "3"
        ]

    def monitor_game_process(self, process):
        """Monitor game process and exit when it's done"""
        process.wait()  # Wait for the game to finish
        QApplication.instance().quit()  # Quit the application

    def get_flags_from_file(self) -> List[str]:
        """Read additional launch flags from doom_flags.txt"""
        flags = []

        # Check multiple possible locations for the flags file
        flag_file_locations = [
            Path.cwd() / "doom_flags.txt",  # Current directory
            self.gamePath / "doom_flags.txt",  # Game path
            Path.home() / "doom_flags.txt",  # User's home directory
            Path.home() / ".local/doom/doom_flags.txt",  # ~/.local/doom directory
            Path.home() / ".local/share/doom/doom_flags.txt"  # ~/.local/share/doom directory
        ]

        for flag_file in flag_file_locations:
            if flag_file.exists():
                try:
                    with open(flag_file, 'r') as f:
                        # Read all lines, strip whitespace, and filter out empty lines
                        lines = [line.strip() for line in f.readlines()]
                        lines = [line for line in lines if line and not line.startswith('#')]

                        # Split each line by whitespace to get individual flags
                        for line in lines:
                            flags.extend(line.split())

                        print(f"Loaded {len(flags)} flags from {flag_file}")
                        break  # Use the first file found
                except Exception as e:
                    print(f"Error reading flags file {flag_file}: {e}", file=sys.stderr)

        return flags

    def launch_game(self, gameFiles: List[str], gameFlags: List[str] = None):
        """Launch game with speech processing"""
        if not gameFiles:
            return

        gzdoomPath = self.find_gzdoom()
        if not gzdoomPath:
            QMessageBox.critical(self, "Error", "GZDoom executable not found")
            return

        # Get selected IWAD
        iwadIndex = self.iwadCombo.currentIndex()
        if iwadIndex < 0:
            QMessageBox.critical(self, "Error", "Please select an IWAD first")
            return

        iwadPath = self.iwadCombo.itemData(iwadIndex)

        # Initialize gameFlags if None
        if gameFlags is None:
            gameFlags = []

        # Get additional flags from doom_flags.txt
        additionalFlags = self.get_flags_from_file()
        if additionalFlags:
            gameFlags.extend(additionalFlags)

        try:
            if platform.system() == "Windows":
                configFile = Path.cwd() / 'TobyConfig.ini'
                # For Windows, use unbuffered stdout for accessible_output2
                cmdLine = [gzdoomPath, "-stdout", "-config", str(configFile), 
                        "-iwad", iwadPath, "-file"] + gameFiles
                if gameFlags:
                    cmdLine.extend(gameFlags)

                # Use CREATE_NO_WINDOW flag to prevent console window
                startupinfo = subprocess.STARTUPINFO()
                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
                startupinfo.wShowWindow = subprocess.SW_HIDE

                process = subprocess.Popen(
                    cmdLine,
                    cwd=str(self.gamePath),
                    stdout=subprocess.PIPE,
                    stderr=subprocess.STDOUT,
                    bufsize=1,  # Line buffered
                    universal_newlines=True,  # This handles text encoding
                    env=dict(os.environ, PYTHONUNBUFFERED="1"),
                    startupinfo=startupinfo
                )

            else:
                # For Linux/Mac, use stdbuf to unbuffer output
                cmdLine = ["stdbuf", "-oL", gzdoomPath, "-stdout", 
                        "-iwad", iwadPath, "-file"] + gameFiles
                if gameFlags:
                    cmdLine.extend(gameFlags)

                process = subprocess.Popen(
                    cmdLine,
                    cwd=str(self.gamePath),
                    stdout=subprocess.PIPE,
                    stderr=subprocess.STDOUT,
                    bufsize=1,  # Line buffered
                    universal_newlines=True,  # This handles text encoding
                    env=dict(os.environ, PYTHONUNBUFFERED="1")
                )

            # Start speech processing thread
            speechThread = threading.Thread(
                target=self.speechHandler.speak_thread,
                args=(process,),
                daemon=True
            )
            speechThread.start()

            # Start process monitor thread
            monitorThread = threading.Thread(
                target=self.monitor_game_process,
                args=(process,),
                daemon=True
            )
            monitorThread.start()

            # Hide the window
            self.hide()

        except Exception as e:
            QMessageBox.critical(self, "Error", f"Failed to launch game: {e}")


if __name__ == "__main__":
    # Converts version number to required format (e.g., 8.0 -> "8-0")
    TOBY_VERSION: Final[str] = f"{int(TOBY_VERSION_NUMBER)}-{int(TOBY_VERSION_NUMBER * 10 % 10)}"
    setproctitle("Toby Doom Launcher")
    app = QApplication(sys.argv)
    window = DoomLauncher()
    window.show()
    sys.exit(app.exec())