diff --git a/src/lib/components/modules/PreviouslyPlayedSongs.svelte b/src/lib/components/modules/PreviouslyPlayedSongs.svelte
index 546ff78..0b5ac6c 100644
--- a/src/lib/components/modules/PreviouslyPlayedSongs.svelte
+++ b/src/lib/components/modules/PreviouslyPlayedSongs.svelte
@@ -2,42 +2,12 @@
     import { createEventDispatcher } from 'svelte';
     import { type Map, GameplayModifiers_GameOptions, Push_SongFinished, RealtimeScore } from 'moons-ta-client';
     import type { BeatSaverMap } from '$lib/services/beatsaver.js';
-
-    interface ScoreWithAccuracy extends Push_SongFinished {
-        accuracy: number;
-    }
-
-    interface PreviousResults {
-        taData: Map;
-        beatsaverData: BeatSaverMap;
-        scores: ScoreWithAccuracy[];
-        completionType: 'Completed' | 'Still Awaiting Scores' | 'Exited To Menu';
-    }
+    import { type ScoreWithAccuracy, type PreviousResults, MapDifficulty } from '$lib/interfaces/match.interfaces';
 
     export let maps: PreviousResults[] = [];
 
-    $: maps = maps.map(map => {
-        const newScores = map.scores.map(score => {
-            const accuracy = calculateAccuracy(score, map);
-            return {
-                ...score,
-                accuracy: parseFloat(accuracy)
-            } as ScoreWithAccuracy;
-        });
-        map.scores = newScores;
-        return map;
-    });
-
     const dispatch = createEventDispatcher();
 
-    enum MapDifficulty {
-        "Easy" = 0,
-        "Normal" = 1,
-        "Hard" = 2,
-        "Expert" = 3,
-        "ExpertPlus" = 4,
-    }
-
     const modifierNameMap: Record<number, string> = {
         [GameplayModifiers_GameOptions.None]: "",
         [GameplayModifiers_GameOptions.NoFail]: "No Fail",
@@ -87,7 +57,7 @@
             
             discordMessage += `**${positionText} ${displayName}**\n`;
             discordMessage += `Score: ${score.score.toLocaleString()}\n`;
-            discordMessage += `Accuracy: ${score.accuracy.toFixed(2)}%\n`;
+            discordMessage += `Accuracy: ${score.accuracy}%\n`;
             discordMessage += `Misses: ${score.misses} | Bad Cuts: ${score.badCuts}\n\n`;
         });
         
@@ -162,32 +132,6 @@
                 return 'help';
         }
     }
-
-    function getMaxScore(songInfo: BeatSaverMap, characteristic: string = "standard", difficulty: string): number {
-        const diff = maps.find(x => x.beatsaverData.versions[0].hash == songInfo.versions[0].hash)?.beatsaverData.versions[0].diffs.find(
-            (x) => ((characteristic.toLowerCase() !== 'expertplus' && characteristic.toLowerCase() !== 'expert+') ? x.characteristic.toLowerCase() === characteristic.toLowerCase() : (x.characteristic.toLowerCase() == 'expertplus' || x.characteristic.toLowerCase() == 'expert+')) && x.difficulty.toLowerCase() === difficulty.toLowerCase()
-        );
-
-        return diff?.maxScore ?? 0;
-    }
-
-    // Method to convert difficulty number to string
-    function getDifficultyAsString(difficulty: number): string {
-        return MapDifficulty[difficulty] || "ExpertPlus";
-    }
-
-    // Main accuracy calculation logic
-    function calculateAccuracy(score: Push_SongFinished, mapWithSongInfo: PreviousResults): string {
-        console.log(maps)
-        const maxScore = getMaxScore(
-            mapWithSongInfo.beatsaverData,
-            score.beatmap?.characteristic?.serializedName ?? "Standard",
-            getDifficultyAsString(score.beatmap?.difficulty ?? 4) || "ExpertPlus"
-        );
-        
-        const accuracy = ((score.score / maxScore) * 100).toFixed(2);
-        return accuracy;
-    }
 </script>
 
 <div class="previously-played">
diff --git a/src/lib/components/modules/SongQueue.svelte b/src/lib/components/modules/SongQueue.svelte
index 84c1871..226e6fd 100644
--- a/src/lib/components/modules/SongQueue.svelte
+++ b/src/lib/components/modules/SongQueue.svelte
@@ -58,6 +58,10 @@
         dispatch('removeMap', { map: map });
     }
 
+    function handleAddMapsFromTAPool() {
+        dispatch('addMapsFromTAPool');
+    }
+
     function handleLoadMap(map: CustomMap) {
         mapToLoad = map;
         showConfirmDialog = true;
@@ -121,6 +125,10 @@
             <span class="material-icons">add</span>
             Add Map
         </button>
+        <button class="action-button add-map" on:click={handleAddMapsFromTAPool}>
+            <span class="material-icons">add</span>
+            Add Maps From TA Pool
+        </button>
     </div>
 
     {#if maps.length === 0}
@@ -337,8 +345,8 @@
         display: flex;
         flex-direction: column;
         gap: 1rem;
-        max-height: 60vh;
-        overflow-y: auto;
+        /* max-height: 60vh;
+        overflow-y: auto; */
     }
 
     .map-card {
@@ -608,7 +616,7 @@
         -webkit-font-smoothing: antialiased;
     }
 
-    /* Scrollbar Styling */
+    /* Scrollbar Styling
     .maps-list::-webkit-scrollbar {
         width: 0.375rem;
     }
@@ -625,7 +633,7 @@
 
     .maps-list::-webkit-scrollbar-thumb:hover {
         background: var(--text-secondary);
-    }
+    } */
 
     /* Responsive Design */
     @media (max-width: 768px) {
diff --git a/src/lib/components/popups/AddMapsFromFile.svelte b/src/lib/components/popups/AddMapsFromFile.svelte
new file mode 100644
index 0000000..b0e11d2
--- /dev/null
+++ b/src/lib/components/popups/AddMapsFromFile.svelte
@@ -0,0 +1,1054 @@
+<script lang="ts">
+    import { fetchMapByHashOrKey, type BeatSaverMap } from '$lib/services/beatsaver';
+    import { createEventDispatcher } from 'svelte';
+    import { type Modifier, allGameModifiers } from '$lib/services/gamePlayModifiers';
+    import { GameplayModifiers_GameOptions } from 'moons-ta-client';
+    import type { CustomMap } from '$lib/interfaces/match.interfaces';
+    import { v4 as uuidv4 } from "uuid";
+
+    interface PlaylistSong {
+        songName: string;
+        levelAuthorName: string;
+        levelid: string;
+        hash: string;
+        difficulties?: Array<{
+            characteristic: string;
+            name: string;
+        }>;
+    }
+
+    interface PlaylistFile {
+        playlistTitle: string;
+        playlistAuthor: string;
+        image: string;
+        songs: PlaylistSong[];
+    }
+
+    interface ProcessedMap {
+        beatsaverData: BeatSaverMap;
+        author: string;
+        mapper: string;
+        hash: string;
+        key: string;
+        songName: string;
+        difficulty: string;
+    }
+
+    export let isOpen = false;
+
+    // Game modifiers with proper grouping and mode restrictions
+    let gameModifiers: Modifier[] = allGameModifiers;
+
+    // Tournament Assistant settings for both modes
+    let disableFail = false;
+    let disablePause = false;
+    let disableScoresaberSubmission = false;
+    let showScoreboard = false;
+
+    // Playing-specific settings
+    let disableCustomNotesOnStream = false;
+
+    const dispatch = createEventDispatcher();
+
+    let dragActive = false;
+    let isProcessing = false;
+    let errorMessage = '';
+    let processedMaps: ProcessedMap[] = [];
+    let fileInputRef: HTMLInputElement;
+
+    const difficultyOrder = ['Easy', 'Normal', 'Hard', 'Expert', 'ExpertPlus'];
+
+    function convertDifficultyName(diffName: string): string {
+        // Convert Expert+ to ExpertPlus and other variants
+        const normalizedName = diffName.replace(/[\s\+]/g, '');
+        switch (normalizedName.toLowerCase()) {
+            case 'expert+':
+            case 'expertplus':
+            case 'expert_plus':
+                return 'ExpertPlus';
+            case 'expert':
+                return 'Expert';
+            case 'hard':
+                return 'Hard';
+            case 'normal':
+                return 'Normal';
+            case 'easy':
+                return 'Easy';
+            default:
+                return diffName;
+        }
+    }
+
+    function getHighestDifficulty(difficulties: Array<{ difficulty: string; characteristic: string }>): string {
+        if (!difficulties || difficulties.length === 0) return 'ExpertPlus';
+        
+        const standardDiffs = difficulties.filter(d => d.characteristic === 'Standard');
+        const diffsToCheck = standardDiffs.length > 0 ? standardDiffs : difficulties;
+        
+        let highest = 'Easy';
+        let highestIndex = 0;
+        
+        for (const diff of diffsToCheck) {
+            const convertedName = convertDifficultyName(diff.difficulty);
+            const index = difficultyOrder.indexOf(convertedName);
+            if (index > highestIndex) {
+                highestIndex = index;
+                highest = convertedName;
+            }
+        }
+        
+        return highest;
+    }
+
+    async function processPlaylistFile(file: File): Promise<void> {
+        try {
+            isProcessing = true;
+            errorMessage = '';
+            processedMaps = [];
+
+            const text = await file.text();
+            let playlistData: PlaylistFile;
+
+            try {
+                playlistData = JSON.parse(text);
+            } catch (e) {
+                throw new Error('Invalid JSON format');
+            }
+
+            if (!playlistData.songs || !Array.isArray(playlistData.songs)) {
+                throw new Error('Invalid playlist format: missing songs array');
+            }
+
+            let maps: ProcessedMap[] = [];
+
+            for (const song of playlistData.songs) {
+                try {
+                    let difficulty = 'ExpertPlus';
+                    let mapBeatSaverData: BeatSaverMap | null = null;
+                    
+                    // If difficulties exist and are not empty, try to find ExpertPlus or get highest
+                    if (song.difficulties && song.difficulties.length > 0) {
+                        const expertPlus = song.difficulties.find(d => 
+                            convertDifficultyName(d.name) === 'ExpertPlus' && d.characteristic === 'Standard'
+                        );
+                        
+                        if (expertPlus) {
+                            difficulty = 'ExpertPlus';
+                            // Still need to fetch BeatSaver data for complete map info
+                            try {
+                                mapBeatSaverData = await fetchMapByHashOrKey(song.hash);
+                            } catch (e) {
+                                console.warn(`Failed to fetch BeatSaver data for ${song.songName}:`, e);
+                                continue; // Skip this song if we can't get BeatSaver data
+                            }
+                        } else {
+                            // Fetch from BeatSaver to get all difficulties
+                            try {
+                                const beatSaverData = await fetchMapByHashOrKey(song.hash);
+                                if (!beatSaverData) {
+                                    console.warn(`No BeatSaver data found for ${song.songName}`);
+                                    continue; // Skip this song
+                                }
+                                
+                                if (beatSaverData?.versions?.[0]?.diffs) {
+                                    difficulty = song.difficulties[0].name;
+                                }
+                                mapBeatSaverData = beatSaverData;
+                            } catch (e) {
+                                console.warn(`Failed to fetch BeatSaver data for ${song.songName}:`, e);
+                                continue; // Skip this song
+                            }
+                        }
+                    } else {
+                        // No difficulties in playlist, fetch from BeatSaver
+                        try {
+                            const beatSaverData = await fetchMapByHashOrKey(song.hash);
+                            if (!beatSaverData) {
+                                console.warn(`No BeatSaver data found for ${song.songName}`);
+                                continue; // Skip this song
+                            }
+                            
+                            if (beatSaverData?.versions?.[0]?.diffs) {
+                                difficulty = getHighestDifficulty(beatSaverData.versions[0].diffs);
+                            }
+                            mapBeatSaverData = beatSaverData;
+                        } catch (e) {
+                            console.warn(`Failed to fetch BeatSaver data for ${song.songName}:`, e);
+                            continue; // Skip this song
+                        }
+                    }
+
+                    // Only proceed if we have valid BeatSaver data
+                    if (!mapBeatSaverData) {
+                        console.warn(`Skipping ${song.songName}: no BeatSaver data available`);
+                        continue;
+                    }
+
+                    maps = [
+                        ...maps,
+                        {
+                            beatsaverData: mapBeatSaverData,
+                            author: song.levelAuthorName || 'Unknown Artist',
+                            mapper: song.levelAuthorName || 'Unknown Mapper',
+                            hash: song.hash,
+                            key: song.levelid?.replace('custom_level_', '') || song.hash,
+                            songName: song.songName || 'Unknown Song',
+                            difficulty
+                        }
+                    ];
+                } catch (e) {
+                    console.warn(`Failed to process song ${song.songName}:`, e);
+                    // Continue processing other songs instead of breaking
+                }
+            }
+
+            processedMaps = maps;
+        } catch (error) {
+            errorMessage = error instanceof Error ? error.message : 'An error occurred while processing the file';
+        } finally {
+            isProcessing = false;
+        }
+    }
+
+    function handleDragOver(e: DragEvent) {
+        e.preventDefault();
+        dragActive = true;
+    }
+
+    function handleDragLeave(e: DragEvent) {
+        e.preventDefault();
+        dragActive = false;
+    }
+
+    function handleDrop(e: DragEvent) {
+        e.preventDefault();
+        dragActive = false;
+        
+        const files = e.dataTransfer?.files;
+        if (files && files.length > 0) {
+            handleFileSelect(files[0]);
+        }
+    }
+
+    function handleFileInputChange(e: Event) {
+        const target = e.target as HTMLInputElement;
+        const files = target.files;
+        if (files && files.length > 0) {
+            handleFileSelect(files[0]);
+        }
+    }
+
+    function handleFileSelect(file: File) {
+        const extension = file.name.toLowerCase().split('.').pop();
+        if (extension !== 'bplist' && extension !== 'json') {
+            errorMessage = 'Please select a .bplist or .json file';
+            return;
+        }
+        
+        processPlaylistFile(file);
+    }
+
+    function handleClose() {
+        dispatch('close');
+    }
+
+    function handleAddMaps() {
+        if (processedMaps.length > 0) {
+            const modifiersBitmap = getActiveModifiersAsBitmap();
+            let finalisedMaps: CustomMap[] = processedMaps.map((map) => {
+                const mapObject: CustomMap = {
+                    beatsaverData: map.beatsaverData,
+                    taData: {
+                        guid: uuidv4(),
+                        gameplayParameters: {
+                            beatmap: {
+                                name: map.songName,
+                                levelId: `custom_level_${map.hash}`,
+                                difficulty: getDifficultyNumber(map.difficulty),
+                                characteristic: {
+                                    serializedName: 'Standard',
+                                    difficulties: []
+                                }
+                            },
+                            gameplayModifiers: {
+                                options: modifiersBitmap
+                            },
+                            attempts: 3,
+                            disableCustomNotesOnStream: disableCustomNotesOnStream,
+                            disableFail: disableFail,
+                            disablePause: disablePause,
+                            disableScoresaberSubmission: disableScoresaberSubmission,
+                            showScoreboard: showScoreboard,
+                            useSync: false,
+                            target: 0,
+                            playerSettings: {
+                                options: 0,
+                                playerHeight: 0,
+                                sfxVolume: 0,
+                                saberTrailIntensity: 0,
+                                noteJumpStartBeatOffset: 0,
+                                noteJumpFixedDuration: 0,
+                                noteJumpDurationTypeSettings: 0,
+                                arcVisibilityType: 0,
+                            }
+                        }
+                    }
+                }
+                return mapObject;
+            })
+            dispatch('addMaps', { maps: finalisedMaps });
+        }
+    }
+
+    // Get modifiers filtered by current mode
+    function getFilteredModifiers(): Modifier[] {
+        return gameModifiers.filter(modifier => 
+            !modifier.allowedInMode || modifier.allowedInMode.includes('playing')
+        );
+    }
+
+    function getDifficultyNumber(difficulty: string): number {
+        const difficultyMap: { [key: string]: number } = {
+            "Easy": 0,
+            "Normal": 1,
+            "Hard": 2,
+            "Expert": 3,
+            "Expert+": 4,
+            "ExpertPlus": 4
+        };
+        return difficultyMap[difficulty] || 0;
+    }
+
+    // Check if a modifier should be disabled due to incompatibilities
+    function isModifierDisabled(modifier: Modifier): boolean {
+        // Special case: No Fail is disabled when Disable Fail is enabled
+        if (modifier.id === GameplayModifiers_GameOptions.NoFail && disableFail) {
+            return true;
+        }
+        
+        if (!modifier.incompatibilityGroup) return false;
+        
+        // Check if any other modifier in the same incompatibility group is enabled
+        // and this modifier isn't the currently enabled one
+        return gameModifiers.some(m => 
+            m.id !== modifier.id && 
+            m.enabled && 
+            m.incompatibilityGroup === modifier.incompatibilityGroup
+        );
+    }
+    
+    function getActiveModifiersAsBitmap(): number {
+        return gameModifiers
+            .filter(modifier => modifier.enabled)
+            .reduce((bitmap, modifier) => bitmap | modifier.id, 0);
+    }
+
+    // Handle disable fail toggle
+    function handleDisableFailChange() {
+        if (disableFail) {
+            // If enabling disable fail, disable No Fail modifier
+            gameModifiers = gameModifiers.map(modifier => {
+                if (modifier.id === GameplayModifiers_GameOptions.NoFail) {
+                    return { ...modifier, enabled: false };
+                }
+                return modifier;
+            });
+        }
+    }
+
+    // Handle modifier changes with proper incompatibility checking
+    function handleModifierChange(changedModifier: Modifier) {
+        // Find the modifier and toggle it
+        const modifierIndex = gameModifiers.findIndex(m => m.id === changedModifier.id);
+        if (modifierIndex === -1) return;
+        
+        const newEnabled = !gameModifiers[modifierIndex].enabled;
+        
+        // Special case: If enabling No Fail, disable Disable Fail
+        if (changedModifier.id === GameplayModifiers_GameOptions.NoFail && newEnabled) {
+            disableFail = false;
+        }
+        
+        // Create new array for reactivity
+        gameModifiers = gameModifiers.map((modifier, index) => {
+            // If this is the modifier being changed, update its enabled state
+            if (index === modifierIndex) {
+                return { ...modifier, enabled: newEnabled };
+            }
+            
+            // If the changed modifier was enabled and has an incompatibility group,
+            // disable other modifiers in the same group
+            if (newEnabled && 
+                changedModifier.incompatibilityGroup && 
+                modifier.incompatibilityGroup === changedModifier.incompatibilityGroup && 
+                modifier.id !== changedModifier.id) {
+                return { ...modifier, enabled: false };
+            }
+            
+            return modifier;
+        });
+    }
+
+    $: filteredModifiers = gameModifiers.filter(modifier => 
+        !modifier.allowedInMode || modifier.allowedInMode.includes('playing')
+    );
+
+    $: groupedModifiers = (() => {
+        const groups: {[key: string]: Modifier[]} = {};
+        
+        filteredModifiers.forEach(modifier => {
+            const group = modifier.group;
+            if (!groups[group]) {
+                groups[group] = [];
+            }
+            groups[group].push(modifier);
+        });
+        
+        return groups;
+    })();
+
+    // Watch for disable fail changes to handle No Fail incompatibility
+    $: if (disableFail) {
+        handleDisableFailChange();
+    }
+</script>
+
+{#if isOpen}
+    <!-- svelte-ignore a11y-no-static-element-interactions -->
+    <!-- svelte-ignore a11y-click-events-have-key-events -->
+    <div class="popup-overlay" on:click={handleClose}>
+        <!-- svelte-ignore a11y-click-events-have-key-events -->
+        <div class="popup-container" on:click|stopPropagation>
+            <div class="popup-header">
+                <div class="header-content">
+                    <h3>Import Maps from Playlist</h3>
+                </div>
+                <button class="close-button" on:click={handleClose}>
+                    <span class="material-icons">close</span>
+                </button>
+            </div>
+
+            <div class="popup-content">
+                {#if errorMessage}
+                    <div class="error-message">
+                        <span class="material-icons">error</span>
+                        <p>{errorMessage}</p>
+                    </div>
+                {/if}
+
+                <div class="form-sections">
+                    <!-- svelte-ignore a11y-click-events-have-key-events -->
+                    <div class="form-section">
+                        <h4>Select Playlist File</h4>
+                        <p class="section-desc">Choose a .bplist or .json playlist file to import maps from</p>
+                        
+                        <div 
+                            class="file-drop-zone" 
+                            class:drag-active={dragActive}
+                            on:dragover={handleDragOver}
+                            on:dragleave={handleDragLeave}
+                            on:drop={handleDrop}
+                            on:click={() => fileInputRef?.click()}
+                        >
+                            <input 
+                                bind:this={fileInputRef}
+                                type="file" 
+                                accept=".bplist,.json"
+                                style="display: none;"
+                                on:change={handleFileInputChange}
+                            />
+                            
+                            {#if isProcessing}
+                                <div class="drop-zone-content">
+                                    <span class="material-icons loading-icon">refresh</span>
+                                    <p>Processing playlist...</p>
+                                </div>
+                            {:else}
+                                <div class="drop-zone-content">
+                                    <span class="material-icons">cloud_upload</span>
+                                    <p>Drop your playlist file here or click to browse</p>
+                                    <small>Supports .bplist and .json files</small>
+                                </div>
+                            {/if}
+                        </div>
+                    </div>
+
+                    {#if processedMaps.length > 0}
+                        <div class="form-section">
+                            <h4>Maps to Import ({processedMaps.length})</h4>
+                            <p class="section-desc">Review the maps that will be imported</p>
+                            
+                            <div class="maps-list">
+                                {#each processedMaps as map}
+                                    <div class="map-item">
+                                        <div class="map-info">
+                                            <div class="map-title">{map.songName}</div>
+                                            <div class="map-details">
+                                                <span class="map-author">{map.author}</span>
+                                                <span class="map-separator">•</span>
+                                                <span class="map-mapper">{map.mapper}</span>
+                                            </div>
+                                            <div class="map-meta">
+                                                <span class="map-difficulty">{map.difficulty}</span>
+                                                <span class="map-separator">•</span>
+                                                <span class="map-hash">{map.hash.substring(0, 8)}...</span>
+                                            </div>
+                                        </div>
+                                    </div>
+                                {/each}
+                            </div>
+
+                            <div class="form-section modifiers-section">
+                                <h4>Game Modifiers</h4>
+                                <p class="section-desc">Select which modifiers are enabled for all maps</p>
+                                
+                                {#each Object.entries(groupedModifiers) as [group, modifiers]}
+                                    <div class="modifier-group">
+                                        <h5>{group}</h5>
+                                        <div class="modifiers-grid">
+                                            {#each modifiers as modifier}
+                                                <div class="modifier-toggle">
+                                                    <label class="switch-label" title={modifier.description}>
+                                                        <input 
+                                                            type="checkbox" 
+                                                            checked={modifier.enabled}
+                                                            on:click={() => handleModifierChange(modifier)}
+                                                            disabled={isModifierDisabled(modifier)}
+                                                        />
+                                                        <span class="switch" class:disabled={isModifierDisabled(modifier)}></span>
+                                                        <span class="label-text">{modifier.name}</span>
+                                                    </label>
+                                                </div>
+                                            {/each}
+                                        </div>
+                                    </div>
+                                {/each}
+                            </div>
+
+                            <!-- Tournament Assistant Settings - now for both modes -->
+                            <div class="form-section qualifier-features-section">
+                                <h4>Tournament Assistant Settings</h4>
+                                <p class="section-desc">Configure game behavior options</p>
+                                
+                                <div class="qualifier-options">                            
+                                    <div class="qualifier-toggle">
+                                        <label class="switch-label">
+                                            <input 
+                                                type="checkbox" 
+                                                bind:checked={disablePause}
+                                            />
+                                            <span class="switch"></span>
+                                            <span class="label-text">Disable Pause</span>
+                                        </label>
+                                    </div>
+                                    
+                                    <div class="qualifier-toggle">
+                                        <label class="switch-label">
+                                            <input 
+                                                type="checkbox" 
+                                                bind:checked={disableFail}
+                                                on:change={handleDisableFailChange}
+                                            />
+                                            <span class="switch"></span>
+                                            <span class="label-text">Disable Fail</span>
+                                        </label>
+                                    </div>
+                                    
+                                    <div class="qualifier-toggle">
+                                        <label class="switch-label">
+                                            <input 
+                                                type="checkbox" 
+                                                bind:checked={disableScoresaberSubmission}
+                                            />
+                                            <span class="switch"></span>
+                                            <span class="label-text">Disable ScoreSaber Submission</span>
+                                        </label>
+                                    </div>
+                                    
+                                    <div class="qualifier-toggle">
+                                        <label class="switch-label">
+                                            <input 
+                                                type="checkbox" 
+                                                bind:checked={showScoreboard}
+                                            />
+                                            <span class="switch"></span>
+                                            <span class="label-text">Show Scoreboard</span>
+                                        </label>
+                                    </div>
+
+                                    <div class="qualifier-toggle">
+                                        <label class="switch-label">
+                                            <input 
+                                                type="checkbox" 
+                                                bind:checked={disableCustomNotesOnStream}
+                                            />
+                                            <span class="switch"></span>
+                                            <span class="label-text">Disable Custom Notes On Stream</span>
+                                        </label>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    {/if}
+                </div>
+
+                <div class="form-actions">
+                    <button class="action-button cancel" on:click={handleClose}>
+                        Cancel
+                    </button>
+                    <button 
+                        class="action-button save" 
+                        disabled={processedMaps.length === 0 || isProcessing}
+                        on:click={handleAddMaps}
+                    >
+                        {#if isProcessing}
+                            <span class="material-icons loading-icon">refresh</span>
+                        {:else}
+                            <span class="material-icons">add</span>
+                        {/if}
+                        Add Maps ({processedMaps.length})
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+{/if}
+
+<style>
+    .popup-overlay {
+        position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background-color: rgba(0, 0, 0, 0.5);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        z-index: 1000;
+    }
+    
+    .popup-container {
+        background-color: var(--bg-primary);
+        border-radius: 0.75rem;
+        width: 90%;
+        max-width: 800px;
+        max-height: 90vh;
+        box-shadow: 0 4px 20px rgba(0, 0, 0, 0.2);
+        display: flex;
+        flex-direction: column;
+        animation: slideIn 0.2s ease-out;
+    }
+    
+    @keyframes slideIn {
+        from {
+            opacity: 0;
+            transform: translateY(-20px) scale(0.95);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0) scale(1);
+        }
+    }
+    
+    .popup-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 1.25rem 1.5rem;
+        border-bottom: 1px solid var(--bg-secondary);
+    }
+    
+    .header-content h3 {
+        margin: 0;
+        font-size: 1.25rem;
+        font-weight: 600;
+    }
+    
+    .close-button {
+        background: none;
+        border: none;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: var(--text-secondary);
+        width: 2rem;
+        height: 2rem;
+        border-radius: 0.25rem;
+    }
+    
+    .close-button:hover {
+        background-color: var(--bg-secondary);
+        color: var(--text-primary);
+    }
+    
+    .popup-content {
+        padding: 1.5rem;
+        overflow-y: auto;
+    }
+    
+    .error-message {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        padding: 0.75rem 1rem;
+        background-color: rgba(255, 85, 85, 0.1);
+        border-left: 3px solid #ff5555;
+        border-radius: 0.25rem;
+        margin-bottom: 1.5rem;
+        animation: fadeIn 0.3s ease-out;
+    }
+    
+    @keyframes fadeIn {
+        from {
+            opacity: 0;
+            transform: translateY(-10px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+    
+    .error-message .material-icons {
+        color: #ff5555;
+    }
+    
+    .error-message p {
+        margin: 0;
+        color: #ff5555;
+    }
+    
+    .form-sections {
+        display: flex;
+        flex-direction: column;
+        gap: 2rem;
+    }
+    
+    .form-section {
+        background-color: var(--bg-secondary);
+        border-radius: 0.5rem;
+        padding: 1.25rem;
+    }
+    
+    .form-section h4 {
+        margin: 0 0 1rem 0;
+        font-size: 1rem;
+        font-weight: 600;
+    }
+    
+    .section-desc {
+        color: var(--text-secondary);
+        font-size: 0.875rem;
+        margin: -0.5rem 0 1rem 0;
+    }
+    
+    .file-drop-zone {
+        border: 2px dashed var(--bg-tertiary);
+        border-radius: 0.5rem;
+        padding: 2rem;
+        text-align: center;
+        cursor: pointer;
+        transition: all 0.2s ease;
+        background-color: var(--bg-primary);
+    }
+    
+    .file-drop-zone:hover,
+    .file-drop-zone.drag-active {
+        border-color: var(--accent-color);
+        background-color: rgba(var(--accent-color-rgb, 59, 130, 246), 0.05);
+    }
+    
+    .drop-zone-content {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: 0.75rem;
+    }
+    
+    .drop-zone-content .material-icons {
+        font-size: 3rem;
+        color: var(--text-secondary);
+    }
+    
+    .drop-zone-content p {
+        margin: 0;
+        font-size: 1rem;
+        font-weight: 500;
+        color: var(--text-primary);
+    }
+    
+    .drop-zone-content small {
+        color: var(--text-secondary);
+        font-size: 0.875rem;
+    }
+    
+    .loading-icon {
+        animation: spin 1s linear infinite;
+    }
+    
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+    
+    .maps-list {
+        display: flex;
+        flex-direction: column;
+        gap: 0.75rem;
+        max-height: 300px;
+        overflow-y: auto;
+    }
+    
+    .map-item {
+        background-color: var(--bg-primary);
+        border-radius: 0.375rem;
+        padding: 1rem;
+        border: 1px solid var(--bg-tertiary);
+    }
+    
+    .map-info {
+        display: flex;
+        flex-direction: column;
+        gap: 0.25rem;
+    }
+    
+    .map-title {
+        font-size: 1rem;
+        font-weight: 600;
+        color: var(--text-primary);
+        margin-bottom: 0.25rem;
+    }
+    
+    .map-details,
+    .map-meta {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        font-size: 0.875rem;
+        color: var(--text-secondary);
+    }
+    
+    .map-separator {
+        opacity: 0.5;
+    }
+    
+    .map-difficulty {
+        background-color: var(--accent-color);
+        color: white;
+        padding: 0.125rem 0.5rem;
+        border-radius: 1rem;
+        font-size: 0.75rem;
+        font-weight: 600;
+    }
+    
+    .map-hash {
+        font-family: monospace;
+        font-size: 0.8125rem;
+    }
+    
+    .form-actions {
+        display: flex;
+        justify-content: flex-end;
+        gap: 0.75rem;
+        margin-top: 2rem;
+    }
+    
+    .action-button {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        padding: 0.625rem 1.25rem;
+        border: none;
+        border-radius: 0.375rem;
+        font-weight: 500;
+        cursor: pointer;
+        transition: background-color 0.2s;
+    }
+    
+    .action-button.cancel {
+        background-color: var(--bg-tertiary);
+        color: var(--text-primary);
+    }
+    
+    .action-button.cancel:hover {
+        background-color: var(--bg-tertiary);
+        filter: brightness(0.95);
+    }
+    
+    .action-button.save {
+        background-color: var(--accent-color);
+        color: white;
+    }
+    
+    .action-button.save:hover {
+        background-color: var(--accent-hover);
+    }
+    
+    .action-button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+    }
+
+    /* Modifier section styling */
+    .modifiers-section {
+        overflow: hidden;
+    }
+    
+    .modifier-group {
+        margin-bottom: 1.5rem;
+    }
+    
+    .modifier-group h5 {
+        margin: 0 0 0.75rem 0;
+        font-size: 0.9375rem;
+        font-weight: 500;
+        color: var(--text-secondary);
+    }
+    
+    .modifiers-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+        gap: 0.75rem;
+    }
+    
+    /* Switch styling */
+    .switch-label {
+        display: flex;
+        align-items: center;
+        cursor: pointer;
+        user-select: none;
+    }
+    
+    .switch-label input {
+        opacity: 0;
+        width: 0;
+        height: 0;
+        position: absolute;
+    }
+    
+    .switch {
+        position: relative;
+        display: inline-block;
+        width: 2.5rem;
+        height: 1.25rem;
+        background-color: var(--bg-tertiary);
+        border-radius: 1.25rem;
+        margin-right: 0.75rem;
+        transition: background-color 0.2s;
+    }
+    
+    .switch:before {
+        position: absolute;
+        content: "";
+        height: 0.875rem;
+        width: 0.875rem;
+        left: 0.1875rem;
+        bottom: 0.1875rem;
+        background-color: white;
+        border-radius: 50%;
+        transition: transform 0.2s;
+    }
+
+    .switch:disabled {
+        opacity: 50%;
+        background-color: grey;
+        cursor: not-allowed;
+    }
+    
+    input:checked + .switch {
+        background-color: var(--accent-color);
+    }
+    
+    input:checked + .switch:before {
+        transform: translateX(1.25rem);
+    }
+    
+    .label-text {
+        font-size: 0.875rem;
+    }
+    
+    /* TA Features section */
+    .ta-features-toggle {
+        margin-bottom: 1rem;
+    }
+    
+    .ta-options {
+        display: grid;
+        grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+        gap: 0.75rem;
+        padding: 0.75rem;
+        background-color: var(--bg-tertiary);
+        border-radius: 0.375rem;
+        margin-top: 0.5rem;
+    }
+
+    /* Qualifier-specific styling */
+    .qualifier-features-section {
+        border-left: 3px solid #ffc107;
+        background-color: rgba(255, 193, 7, 0.05);
+    }
+    
+    .qualifier-options {
+        display: flex;
+        flex-direction: column;
+        gap: 1rem;
+    }
+    
+    .qualifier-toggle {
+        display: flex;
+        align-items: center;
+    }
+    
+    .attempts-input {
+        margin-left: 3.25rem;
+        margin-top: 0.75rem;
+        max-width: 200px;
+    }
+    
+    .attempts-input input {
+        padding: 0.5rem 0.75rem;
+        font-size: 0.875rem;
+    }
+    
+    @media (max-width: 768px) {
+        .popup-container {
+            width: 95%;
+            max-height: 95vh;
+        }
+        
+        .form-actions {
+            flex-direction: column;
+            gap: 0.5rem;
+        }
+        
+        .action-button {
+            width: 100%;
+            justify-content: center;
+        }
+    }
+    
+    @media (max-width: 480px) {
+        .file-drop-zone {
+            padding: 1.5rem;
+        }
+        
+        .drop-zone-content .material-icons {
+            font-size: 2rem;
+        }
+        
+        .drop-zone-content p {
+            font-size: 0.875rem;
+        }
+        
+        .map-details,
+        .map-meta {
+            flex-wrap: wrap;
+        }
+        
+        .maps-list {
+            max-height: 200px;
+        }
+    }
+</style>
\ No newline at end of file
diff --git a/src/lib/components/popups/AddMapsFromTAPool.svelte b/src/lib/components/popups/AddMapsFromTAPool.svelte
new file mode 100644
index 0000000..fdbdf03
--- /dev/null
+++ b/src/lib/components/popups/AddMapsFromTAPool.svelte
@@ -0,0 +1,657 @@
+<script lang="ts">
+    import { createEventDispatcher } from 'svelte';
+    import type { CustomTAMapPool, CustomMap } from '$lib/interfaces/match.interfaces';
+    import { bufferToImageUrl } from '$lib/services/taImages';
+
+    export let isOpen = false;
+    export let mapPools: CustomTAMapPool[] = [];
+
+    const dispatch = createEventDispatcher();
+
+    // Track which pools are expanded
+    let expandedPools: Set<string> = new Set();
+    
+    // Track selected maps by their guid
+    let selectedMaps: Set<string> = new Set();
+    
+    // Track if entire pools are selected
+    let selectedPools: Set<string> = new Set();
+
+    function togglePoolExpansion(poolGuid: string) {
+        const newExpanded = new Set(expandedPools);
+        if (newExpanded.has(poolGuid)) {
+            newExpanded.delete(poolGuid);
+        } else {
+            newExpanded.add(poolGuid);
+        }
+        expandedPools = newExpanded;
+    }
+
+    function togglePoolSelection(pool: CustomTAMapPool) {
+        const newSelectedPools = new Set(selectedPools);
+        const newSelectedMaps = new Set(selectedMaps);
+        
+        if (selectedPools.has(pool.guid)) {
+            // Unselect pool and all its maps
+            newSelectedPools.delete(pool.guid);
+            pool.maps.forEach(map => {
+                newSelectedMaps.delete(map.taData.guid);
+            });
+        } else {
+            // Select pool and all its maps
+            newSelectedPools.add(pool.guid);
+            pool.maps.forEach(map => {
+                newSelectedMaps.add(map.taData.guid);
+            });
+        }
+        
+        selectedPools = newSelectedPools;
+        selectedMaps = newSelectedMaps;
+    }
+
+    function toggleMapSelection(map: CustomMap, poolGuid: string) {
+        const newSelectedMaps = new Set(selectedMaps);
+        const newSelectedPools = new Set(selectedPools);
+        
+        if (selectedMaps.has(map.taData.guid)) {
+            newSelectedMaps.delete(map.taData.guid);
+            // If pool was fully selected, unselect it
+            newSelectedPools.delete(poolGuid);
+        } else {
+            newSelectedMaps.add(map.taData.guid);
+            
+            // Check if all maps in this pool are now selected
+            const pool = mapPools.find(p => p.guid === poolGuid);
+            if (pool && pool.maps.every(m => newSelectedMaps.has(m.taData.guid))) {
+                newSelectedPools.add(poolGuid);
+            }
+        }
+        
+        selectedMaps = newSelectedMaps;
+        selectedPools = newSelectedPools;
+    }
+
+    function getDifficultyName(difficulty: number): string {
+        const difficultyMap: { [key: number]: string } = {
+            0: "Easy",
+            1: "Normal", 
+            2: "Hard",
+            3: "Expert",
+            4: "Expert+"
+        };
+        return difficultyMap[difficulty] || "Unknown";
+    }
+
+    function getModifiersText(modifiersBitmap: number): string {
+        // This would need your actual modifiers mapping
+        // For now, just show if modifiers are present
+        return modifiersBitmap > 0 ? "Modifiers Active" : "No Modifiers";
+    }
+
+    function calculateDuration(map: CustomMap): string {
+        // You mentioned you have a function for this - placeholder implementation
+        if (map.beatsaverData?.metadata?.duration) {
+            const duration = map.beatsaverData.metadata.duration;
+            const minutes = Math.floor(duration / 60);
+            const seconds = duration % 60;
+            return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+        }
+        return "0:00";
+    }
+
+    function getCoverUrl(map: CustomMap): string {
+        return map.beatsaverData?.versions?.[0]?.coverURL || '';
+    }
+
+    function handleClose() {
+        dispatch('close');
+    }
+
+    function handleAddMaps() {
+        const mapsToAdd: CustomMap[] = [];
+        
+        mapPools.forEach(pool => {
+            pool.maps.forEach(map => {
+                if (selectedMaps.has(map.taData.guid)) {
+                    mapsToAdd.push(map);
+                }
+            });
+        });
+        
+        if (mapsToAdd.length > 0) {
+            dispatch('addMaps', { maps: mapsToAdd });
+        }
+    }
+
+    $: selectedCount = selectedMaps.size;
+</script>
+
+{#if isOpen}
+    <!-- svelte-ignore a11y-no-static-element-interactions -->
+    <!-- svelte-ignore a11y-click-events-have-key-events -->
+    <div class="popup-overlay" on:click={handleClose}>
+        <div class="popup-container" on:click|stopPropagation>
+            <div class="popup-header">
+                <div class="header-content">
+                    <h3>Add Maps from TA Pool</h3>
+                </div>
+                <button class="close-button" on:click={handleClose}>
+                    <span class="material-icons">close</span>
+                </button>
+            </div>
+
+            <div class="popup-content">
+                <div class="form-sections">
+                    <div class="form-section">
+                        <h4>Map Pools</h4>
+                        <p class="section-desc">Select individual maps or entire pools to add to your match</p>
+                        
+                        <div class="pools-list">
+                            {#each mapPools as pool (pool.guid)}
+                                <div class="pool-container">
+                                    <div class="pool-header">
+                                        <div class="pool-info">
+                                            <div class="pool-image">
+                                                <img src={bufferToImageUrl(pool.image)} alt={pool.name} />
+                                            </div>
+                                            <div class="pool-details">
+                                                <h5 class="pool-name">{pool.name}</h5>
+                                                <span class="pool-count">{pool.maps.length} maps</span>
+                                            </div>
+                                        </div>
+                                        <div class="pool-controls">
+                                            <label class="pool-checkbox">
+                                                <input 
+                                                    type="checkbox" 
+                                                    checked={selectedPools.has(pool.guid)}
+                                                    on:change={() => togglePoolSelection(pool)}
+                                                />
+                                                <span class="checkmark"></span>
+                                            </label>
+                                            <button 
+                                                class="expand-button" 
+                                                on:click={() => togglePoolExpansion(pool.guid)}
+                                                class:expanded={expandedPools.has(pool.guid)}
+                                            >
+                                                <span class="material-icons">expand_more</span>
+                                            </button>
+                                        </div>
+                                    </div>
+                                    
+                                    {#if expandedPools.has(pool.guid)}
+                                        <div class="maps-list">
+                                            {#each pool.maps as map (map.taData.guid)}
+                                                <div class="map-item">
+                                                    <div class="map-checkbox">
+                                                        <label>
+                                                            <input 
+                                                                type="checkbox" 
+                                                                checked={selectedMaps.has(map.taData.guid)}
+                                                                on:change={() => toggleMapSelection(map, pool.guid)}
+                                                            />
+                                                            <span class="checkmark"></span>
+                                                        </label>
+                                                    </div>
+                                                    <div class="map-cover">
+                                                        <img src={getCoverUrl(map)} alt={map.taData.gameplayParameters?.beatmap?.name} />
+                                                    </div>
+                                                    <div class="map-info">
+                                                        <div class="map-title">{map.taData.gameplayParameters?.beatmap?.name}</div>
+                                                        <div class="map-details">
+                                                            <span class="map-duration">{calculateDuration(map)}</span>
+                                                            <span class="map-separator">•</span>
+                                                            <span class="map-difficulty {getDifficultyName(map.taData.gameplayParameters?.beatmap?.difficulty || 4).toLowerCase()}">
+                                                                {getDifficultyName(map.taData.gameplayParameters?.beatmap?.difficulty || 4)}
+                                                            </span>
+                                                            <span class="map-separator">•</span>
+                                                            <span class="map-modifiers">{getModifiersText(map.taData.gameplayParameters?.gameplayModifiers?.options || 0)}</span>
+                                                        </div>
+                                                    </div>
+                                                </div>
+                                            {/each}
+                                        </div>
+                                    {/if}
+                                </div>
+                            {/each}
+                        </div>
+                    </div>
+                </div>
+
+                <div class="form-actions">
+                    <button class="action-button cancel" on:click={handleClose}>
+                        Cancel
+                    </button>
+                    <button 
+                        class="action-button save" 
+                        on:click={handleAddMaps}
+                        disabled={selectedCount === 0}
+                    >
+                        <span class="material-icons">add</span>
+                        Add {selectedCount} Maps
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+{/if}
+
+<style>
+    .popup-overlay {
+        position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background-color: rgba(0, 0, 0, 0.5);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        z-index: 1000;
+    }
+    
+    .popup-container {
+        background-color: var(--bg-primary);
+        border-radius: 0.75rem;
+        width: 90%;
+        max-width: 900px;
+        max-height: 90vh;
+        box-shadow: 0 4px 20px rgba(0, 0, 0, 0.2);
+        display: flex;
+        flex-direction: column;
+        animation: slideIn 0.2s ease-out;
+    }
+    
+    @keyframes slideIn {
+        from {
+            opacity: 0;
+            transform: translateY(-20px) scale(0.95);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0) scale(1);
+        }
+    }
+    
+    .popup-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 1.25rem 1.5rem;
+        border-bottom: 1px solid var(--bg-secondary);
+    }
+    
+    .header-content h3 {
+        margin: 0;
+        font-size: 1.25rem;
+        font-weight: 600;
+    }
+    
+    .close-button {
+        background: none;
+        border: none;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: var(--text-secondary);
+        width: 2rem;
+        height: 2rem;
+        border-radius: 0.25rem;
+    }
+    
+    .close-button:hover {
+        background-color: var(--bg-secondary);
+        color: var(--text-primary);
+    }
+    
+    .popup-content {
+        padding: 1.5rem;
+        overflow-y: auto;
+    }
+    
+    .form-sections {
+        display: flex;
+        flex-direction: column;
+        gap: 2rem;
+    }
+    
+    .form-section {
+        background-color: var(--bg-secondary);
+        border-radius: 0.5rem;
+        padding: 1.25rem;
+    }
+    
+    .form-section h4 {
+        margin: 0 0 1rem 0;
+        font-size: 1rem;
+        font-weight: 600;
+    }
+    
+    .section-desc {
+        color: var(--text-secondary);
+        font-size: 0.875rem;
+        margin: -0.5rem 0 1rem 0;
+    }
+    
+    .pools-list {
+        display: flex;
+        flex-direction: column;
+        gap: 1rem;
+    }
+    
+    .pool-container {
+        background-color: var(--bg-primary);
+        border-radius: 0.5rem;
+        border: 1px solid var(--bg-tertiary);
+        overflow: hidden;
+    }
+    
+    .pool-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 1rem;
+        cursor: pointer;
+    }
+    
+    .pool-info {
+        display: flex;
+        align-items: center;
+        gap: 1rem;
+    }
+    
+    .pool-image {
+        width: 3rem;
+        height: 3rem;
+        border-radius: 0.375rem;
+        overflow: hidden;
+        flex-shrink: 0;
+    }
+    
+    .pool-image img {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+    }
+    
+    .pool-details {
+        display: flex;
+        flex-direction: column;
+        gap: 0.25rem;
+    }
+    
+    .pool-name {
+        margin: 0;
+        font-size: 1rem;
+        font-weight: 600;
+        color: var(--text-primary);
+    }
+    
+    .pool-count {
+        font-size: 0.875rem;
+        color: var(--text-secondary);
+    }
+    
+    .pool-controls {
+        display: flex;
+        align-items: center;
+        gap: 0.75rem;
+    }
+    
+    .expand-button {
+        background: none;
+        border: none;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: var(--text-secondary);
+        width: 2rem;
+        height: 2rem;
+        border-radius: 0.25rem;
+        transition: all 0.2s;
+    }
+    
+    .expand-button:hover {
+        background-color: var(--bg-secondary);
+        color: var(--text-primary);
+    }
+    
+    .expand-button.expanded {
+        transform: rotate(180deg);
+    }
+    
+    .maps-list {
+        border-top: 1px solid var(--bg-tertiary);
+        padding: 1rem;
+        display: flex;
+        flex-direction: column;
+        gap: 0.75rem;
+        max-height: 400px;
+        overflow-y: auto;
+    }
+    
+    .map-item {
+        display: flex;
+        align-items: center;
+        gap: 1rem;
+        padding: 0.75rem;
+        background-color: var(--bg-secondary);
+        border-radius: 0.375rem;
+        border: 1px solid var(--bg-tertiary);
+    }
+    
+    .map-checkbox {
+        flex-shrink: 0;
+    }
+    
+    .map-cover {
+        width: 2.5rem;
+        height: 2.5rem;
+        border-radius: 0.25rem;
+        overflow: hidden;
+        flex-shrink: 0;
+    }
+    
+    .map-cover img {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+    }
+    
+    .map-info {
+        flex: 1;
+        min-width: 0;
+    }
+    
+    .map-title {
+        font-size: 0.9375rem;
+        font-weight: 600;
+        color: var(--text-primary);
+        margin-bottom: 0.25rem;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+    
+    .map-details {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        font-size: 0.8125rem;
+        color: var(--text-secondary);
+        flex-wrap: wrap;
+    }
+    
+    .map-separator {
+        opacity: 0.5;
+    }
+    
+    .map-difficulty {
+        background-color: var(--accent-color);
+        color: white;
+        padding: 0.125rem 0.5rem;
+        border-radius: 1rem;
+        font-size: 0.75rem;
+        font-weight: 600;
+        text-transform: uppercase;
+    }
+    
+    .map-difficulty.easy {
+        background-color: #4ade80;
+    }
+    
+    .map-difficulty.normal {
+        background-color: #3b82f6;
+    }
+    
+    .map-difficulty.hard {
+        background-color: #f59e0b;
+    }
+    
+    .map-difficulty.expert {
+        background-color: #ef4444;
+    }
+    
+    .map-difficulty.expert\+ {
+        background-color: #8b5cf6;
+    }
+    
+    .map-duration,
+    .map-modifiers {
+        font-size: 0.8125rem;
+    }
+    
+    /* Checkbox styling */
+    .pool-checkbox,
+    .map-checkbox label {
+        display: flex;
+        align-items: center;
+        cursor: pointer;
+        user-select: none;
+    }
+    
+    .pool-checkbox input,
+    .map-checkbox input {
+        opacity: 0;
+        width: 0;
+        height: 0;
+        position: absolute;
+    }
+    
+    .checkmark {
+        position: relative;
+        display: inline-block;
+        width: 1.25rem;
+        height: 1.25rem;
+        background-color: var(--bg-tertiary);
+        border: 2px solid var(--bg-tertiary);
+        border-radius: 0.25rem;
+        transition: all 0.2s;
+    }
+    
+    .checkmark:after {
+        content: "";
+        position: absolute;
+        display: none;
+        left: 0.3125rem;
+        top: 0.125rem;
+        width: 0.3125rem;
+        height: 0.625rem;
+        border: solid white;
+        border-width: 0 2px 2px 0;
+        transform: rotate(45deg);
+    }
+    
+    input:checked + .checkmark {
+        background-color: var(--accent-color);
+        border-color: var(--accent-color);
+    }
+    
+    input:checked + .checkmark:after {
+        display: block;
+    }
+    
+    .form-actions {
+        display: flex;
+        justify-content: flex-end;
+        gap: 0.75rem;
+        margin-top: 2rem;
+    }
+    
+    .action-button {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        padding: 0.625rem 1.25rem;
+        border: none;
+        border-radius: 0.375rem;
+        font-weight: 500;
+        cursor: pointer;
+        transition: background-color 0.2s;
+    }
+    
+    .action-button.cancel {
+        background-color: var(--bg-tertiary);
+        color: var(--text-primary);
+    }
+    
+    .action-button.cancel:hover {
+        background-color: var(--bg-tertiary);
+        filter: brightness(0.95);
+    }
+    
+    .action-button.save {
+        background-color: var(--accent-color);
+        color: white;
+    }
+    
+    .action-button.save:hover {
+        background-color: var(--accent-hover);
+    }
+    
+    .action-button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+    }
+    
+    @media (max-width: 768px) {
+        .popup-container {
+            width: 95%;
+            max-height: 95vh;
+        }
+        
+        .pool-header {
+            padding: 0.75rem;
+        }
+        
+        .pool-info {
+            gap: 0.75rem;
+        }
+        
+        .pool-image {
+            width: 2.5rem;
+            height: 2.5rem;
+        }
+        
+        .map-item {
+            padding: 0.5rem;
+            gap: 0.75rem;
+        }
+        
+        .map-cover {
+            width: 2rem;
+            height: 2rem;
+        }
+        
+        .form-actions {
+            flex-direction: column;
+            gap: 0.5rem;
+        }
+        
+        .action-button {
+            width: 100%;
+            justify-content: center;
+        }
+    }
+</style>
\ No newline at end of file
diff --git a/src/lib/components/popups/EditMap.svelte b/src/lib/components/popups/EditMap.svelte
index 582a085..38da52a 100644
--- a/src/lib/components/popups/EditMap.svelte
+++ b/src/lib/components/popups/EditMap.svelte
@@ -6,6 +6,7 @@
     import { v4 as uuidv4 } from "uuid";
     import { onMount } from "svelte";
     import type { BeatSaverMap } from "$lib/services/beatsaver";
+    import { type Modifier, allGameModifiers } from "$lib/services/gamePlayModifiers";
     
     export let tournamentGuid: string;
     export let mode: 'qualifier' | 'playing' = 'playing';
@@ -38,177 +39,18 @@
     // Qualifier-specific settings
     let limitAttemptsEnabled = false;
     let numberOfAttempts = 1;
-    let disableScoresaberSubmission = false;
     let showScoreboard = false;
     
     // Tournament Assistant settings for both modes
     let disableFail = false;
     let disablePause = false;
+    let disableScoresaberSubmission = false;
 
     // Playing-specific settings
     let disableCustomNotesOnStream = false;
     
-    // Beat Saber Modifiers with incompatibility groups
-    interface Modifier {
-        id: GameplayModifiers_GameOptions;
-        name: string;
-        description: string;
-        enabled: boolean;
-        group: string;
-        incompatibilityGroup?: string; // Modifiers in same group are mutually exclusive
-        allowedInMode?: ('qualifier' | 'playing')[];
-    }
-
-    enum MapDifficulty {
-        "Easy" = 0,
-        "Normal" = 1,
-        "Hard" = 2,
-        "Expert" = 3,
-        "Expert+" = 4
-    }
-    
     // Game modifiers with proper grouping and mode restrictions
-    let gameModifiers: Modifier[] = [
-        // Failure Prevention (mutually exclusive)
-        { 
-            id: GameplayModifiers_GameOptions.NoFail, 
-            name: "No Fail", 
-            description: "You can't fail the level", 
-            enabled: false, 
-            group: "Failure Prevention",
-            incompatibilityGroup: "failure",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        { 
-            id: GameplayModifiers_GameOptions.InstaFail, 
-            name: "One Life", 
-            description: "You only have one life", 
-            enabled: false, 
-            group: "Failure Prevention",
-            incompatibilityGroup: "failure",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        { 
-            id: GameplayModifiers_GameOptions.BatteryEnergy, 
-            name: "Four Lives", 
-            description: "You have four lives", 
-            enabled: false, 
-            group: "Failure Prevention",
-            incompatibilityGroup: "failure",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        
-        // Environment Modifiers
-        { 
-            id: GameplayModifiers_GameOptions.NoBombs, 
-            name: "No Bombs", 
-            description: "No bombs will appear", 
-            enabled: false, 
-            group: "Environment",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        { 
-            id: GameplayModifiers_GameOptions.NoObstacles, 
-            name: "No Walls", 
-            description: "No walls will appear", 
-            enabled: false, 
-            group: "Environment",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        
-        // Note Modifiers (some mutually exclusive)
-        { 
-            id: GameplayModifiers_GameOptions.NoArrows, 
-            name: "No Arrows", 
-            description: "All notes can be cut in any direction", 
-            enabled: false, 
-            group: "Note Modifiers",
-            incompatibilityGroup: "arrows",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        { 
-            id: GameplayModifiers_GameOptions.DisappearingArrows, 
-            name: "Disappearing Arrows", 
-            description: "Arrows disappear as they approach you", 
-            enabled: false, 
-            group: "Note Modifiers",
-            incompatibilityGroup: "arrows",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        { 
-            id: GameplayModifiers_GameOptions.GhostNotes, 
-            name: "Ghost Notes", 
-            description: "Note colors are hidden", 
-            enabled: false, 
-            group: "Note Modifiers",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        
-        // Speed Modifiers (mutually exclusive)
-        { 
-            id: GameplayModifiers_GameOptions.SlowSong, 
-            name: "Slower Song", 
-            description: "Reduces the song speed by 15%", 
-            enabled: false, 
-            group: "Speed",
-            incompatibilityGroup: "speed",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        { 
-            id: GameplayModifiers_GameOptions.FastSong, 
-            name: "Faster Song", 
-            description: "Increases the song speed by 20%", 
-            enabled: false, 
-            group: "Speed",
-            incompatibilityGroup: "speed",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        { 
-            id: GameplayModifiers_GameOptions.SuperFastSong, 
-            name: "Super Fast Song", 
-            description: "Increases the song speed by 50%", 
-            enabled: false, 
-            group: "Speed",
-            incompatibilityGroup: "speed",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        
-        // Visual Modifiers (some mutually exclusive)
-        { 
-            id: GameplayModifiers_GameOptions.SmallCubes, 
-            name: "Small Notes", 
-            description: "Notes are smaller", 
-            enabled: false, 
-            group: "Visual",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        { 
-            id: GameplayModifiers_GameOptions.ProMode, 
-            name: "Pro Mode", 
-            description: "Makes notes smaller, removes debris, and adds hit scores", 
-            enabled: false, 
-            group: "Visual",
-            allowedInMode: ['qualifier', 'playing']
-        },
-        
-        // Special Modifiers
-        { 
-            id: GameplayModifiers_GameOptions.ZenMode, 
-            name: "Zen Mode", 
-            description: "No fail, no bombs, reduced obstacles", 
-            enabled: false, 
-            group: "Special",
-            allowedInMode: ['playing'] // Only for playing mode
-        },
-        { 
-            id: GameplayModifiers_GameOptions.StrictAngles, 
-            name: "Strict Angles", 
-            description: "Stricter angle enforcement for cuts", 
-            enabled: false, 
-            group: "Special",
-            allowedInMode: ['qualifier', 'playing']
-        }
-    ];
+    let gameModifiers: Modifier[] = allGameModifiers;
     
     // Initialize from existing map data
     function initializeFromMap() {
diff --git a/src/lib/components/popups/ResultsForMap.svelte b/src/lib/components/popups/ResultsForMap.svelte
new file mode 100644
index 0000000..39286ac
--- /dev/null
+++ b/src/lib/components/popups/ResultsForMap.svelte
@@ -0,0 +1,828 @@
+<script lang="ts">
+    import { createEventDispatcher } from 'svelte';
+    import { type Map, GameplayModifiers_GameOptions, Push_SongFinished } from 'moons-ta-client';
+    import type { BeatSaverMap } from '$lib/services/beatsaver.js';
+    import { type ScoreWithAccuracy, type PreviousResults, MapDifficulty } from '$lib/interfaces/match.interfaces';
+
+    export let mapData: PreviousResults | null;
+    export let isVisible: boolean = false;
+
+    const dispatch = createEventDispatcher();
+
+    // Copy options
+    let includeMapInfo = true;
+    let includeEndTime = false;
+    let includeMisses = true;
+    let includeBadCuts = true;
+    let includeAccuracy = true;
+
+    // Modifiers mapping
+    const modifierNameMap: Record<number, string> = {
+        [GameplayModifiers_GameOptions.None]: "",
+        [GameplayModifiers_GameOptions.NoFail]: "No Fail",
+        [GameplayModifiers_GameOptions.NoBombs]: "No Bombs",
+        [GameplayModifiers_GameOptions.NoArrows]: "No Arrows",
+        [GameplayModifiers_GameOptions.NoObstacles]: "No Walls",
+        [GameplayModifiers_GameOptions.SlowSong]: "Slower Song",
+        [GameplayModifiers_GameOptions.InstaFail]: "One Life",
+        [GameplayModifiers_GameOptions.FailOnClash]: "Fail on Clash",
+        [GameplayModifiers_GameOptions.BatteryEnergy]: "Four Lives",
+        [GameplayModifiers_GameOptions.FastNotes]: "Fast Notes",
+        [GameplayModifiers_GameOptions.FastSong]: "Faster Song",
+        [GameplayModifiers_GameOptions.DisappearingArrows]: "Disappearing Arrows",
+        [GameplayModifiers_GameOptions.GhostNotes]: "Ghost Notes",
+        [GameplayModifiers_GameOptions.DemoNoFail]: "Demo No Fail",
+        [GameplayModifiers_GameOptions.DemoNoObstacles]: "Demo No Obstacles",
+        [GameplayModifiers_GameOptions.StrictAngles]: "Strict Angles",
+        [GameplayModifiers_GameOptions.ProMode]: "Pro Mode",
+        [GameplayModifiers_GameOptions.ZenMode]: "Zen Mode",
+        [GameplayModifiers_GameOptions.SmallCubes]: "Small Notes",
+        [GameplayModifiers_GameOptions.SuperFastSong]: "Super Fast Song"
+    };
+
+    function closePopup() {
+        dispatch('close');
+    }
+
+    function getActiveModifiers(gameplayModifiers: number): string[] {
+        const activeModifiers: string[] = [];
+        const values = Object.values(GameplayModifiers_GameOptions)
+            .filter((value): value is number => 
+                typeof value === 'number' && 
+                value !== GameplayModifiers_GameOptions.None &&
+                value > 0
+            )
+            .sort((a, b) => a - b);
+        
+        for (const value of values) {
+            if ((gameplayModifiers & value) === value) {
+                const name = modifierNameMap[value];
+                if (name && name.trim() !== "") {
+                    activeModifiers.push(name);
+                }
+            }
+        }
+        
+        return activeModifiers;
+    }
+
+    function getDifficultyName(difficulty: number): string {
+        return MapDifficulty[difficulty] || 'Unknown';
+    }
+
+    function formatTime(seconds: number): string {
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = Math.floor(seconds % 60);
+        return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
+    }
+
+    function formatBPM(bpm: number): string {
+        return Math.round(bpm).toString();
+    }
+
+    function getCompletionStatus(score: ScoreWithAccuracy, songDuration: number): string {
+        const timeDifference = Math.abs(score.endTime - songDuration);
+        if (timeDifference <= 2) {
+            return 'Completed';
+        } else {
+            return `Exited early at: ${formatTime(score.endTime)}`;
+        }
+    }
+
+    function isCompleted(score: ScoreWithAccuracy, songDuration: number): boolean {
+        const timeDifference = Math.abs(score.endTime - songDuration);
+        return timeDifference <= 2;
+    }
+
+    function copyScoresToClipboard() {
+        const mapName = mapData!.beatsaverData.name || 'Unknown Song';
+        const artist = mapData!.beatsaverData.metadata?.songAuthorName || 'Unknown Artist';
+        const difficulty = getDifficultyName(mapData!.taData.gameplayParameters?.beatmap?.difficulty || 0);
+        const songDuration = mapData!.beatsaverData.metadata?.duration || 0;
+        
+        let discordMessage = '';
+        
+        if (includeMapInfo) {
+            discordMessage += `## **${mapName}** by ${artist}\n`;
+            discordMessage += `**Difficulty:** ${difficulty}\n`;
+            
+            const modifiers = getActiveModifiers(mapData!.taData.gameplayParameters?.gameplayModifiers?.options || 0);
+            if (modifiers.length > 0) {
+                discordMessage += `**Modifiers:** ${modifiers.join(', ')}\n`;
+            }
+            
+            discordMessage += '\n';
+        }
+        
+        // Sort scores by total score (descending)
+        const sortedScores = [...mapData!.scores].sort((a, b) => b.score - a.score);
+        
+        sortedScores.forEach((score, index) => {
+            const position = index + 1;
+            const positionText = position === 1 ? '1st' : position === 2 ? '2nd' : position === 3 ? '3rd' : `${position}th`;
+            const displayName = score.player?.name || score.player?.discordInfo?.username || 'Unknown Player';
+            
+            discordMessage += `**${positionText} ${displayName}**\n`;
+            discordMessage += `Score: ${score.score.toLocaleString()}`;
+            
+            if (includeAccuracy) {
+                discordMessage += ` | Accuracy: ${score.accuracy}%\n`;
+            }
+            
+            if (includeEndTime) {
+                discordMessage += `-# `;
+                const completionStatus = getCompletionStatus(score, songDuration);
+                discordMessage += `Status: ${completionStatus}\n`;
+            }
+
+            if (includeMisses || includeBadCuts) {
+                let errorLine = '';
+                if (includeMisses) errorLine += `Misses: ${score.misses}`;
+                if (includeMisses && includeBadCuts) errorLine += ' | ';
+                if (includeBadCuts) errorLine += `Bad Cuts: ${score.badCuts}`;
+                discordMessage += `${errorLine}\n`;
+            }
+            
+            discordMessage += '\n';
+        });
+        
+        navigator.clipboard.writeText(discordMessage).then(() => {
+            console.log('Scores copied to clipboard');
+        });
+    }
+
+    $: activeModifiers = getActiveModifiers(mapData?.taData.gameplayParameters?.gameplayModifiers?.options || 0);
+    $: sortedScores = mapData?.scores ? [...mapData.scores].sort((a, b) => b.score - a.score) : [];
+    $: songDuration = mapData?.beatsaverData.metadata?.duration || 0;
+    $: isAwaitingScores = mapData?.completionType === 'Still Awaiting Scores';
+</script>
+
+{#if isVisible && mapData}
+    <!-- svelte-ignore a11y-no-static-element-interactions -->
+    <!-- svelte-ignore a11y-click-events-have-key-events -->
+    <div class="popup-overlay" on:click={closePopup}>
+        <div class="popup-content" on:click|stopPropagation>
+            <!-- Header -->
+            <div class="popup-header">
+                <div class="header-content">
+                    <div class="map-cover">
+                        <img 
+                            src={mapData.beatsaverData.versions[0]?.coverURL || '/default-song-cover.png'} 
+                            alt="Map Cover" 
+                        />
+                    </div>
+                    <div class="map-info">
+                        <h2 class="map-title">{mapData.beatsaverData.name || 'Unknown Song'}</h2>
+                        <p class="map-artist">{mapData.beatsaverData.metadata?.songAuthorName || 'Unknown Artist'}</p>
+                        <p class="map-mapper">Mapped by {mapData.beatsaverData.metadata?.levelAuthorName || 'Unknown Mapper'}</p>
+                    </div>
+                </div>
+                <button class="close-button" on:click={closePopup}>
+                    <span class="material-icons">close</span>
+                </button>
+            </div>
+
+            <!-- Awaiting Scores Indicator -->
+            {#if isAwaitingScores}
+                <div class="awaiting-scores">
+                    <div class="loader"></div>
+                    <span>Still awaiting scores...</span>
+                </div>
+            {/if}
+
+            <!-- Map Details -->
+            <div class="map-details-section">
+                <h3>Map Details</h3>
+                <div class="details-grid">
+                    <div class="detail-item">
+                        <span class="material-icons">schedule</span>
+                        <span class="detail-label">Duration</span>
+                        <span class="detail-value">{formatTime(songDuration)}</span>
+                    </div>
+                    <div class="detail-item">
+                        <span class="material-icons">speed</span>
+                        <span class="detail-label">BPM</span>
+                        <span class="detail-value">{formatBPM(mapData.beatsaverData.metadata?.bpm || 0)}</span>
+                    </div>
+                    <div class="detail-item">
+                        <span class="material-icons">star</span>
+                        <span class="detail-label">Difficulty</span>
+                        <span class="detail-value difficulty-badge difficulty-{mapData.taData.gameplayParameters?.beatmap?.difficulty}">
+                            {getDifficultyName(mapData.taData.gameplayParameters?.beatmap?.difficulty || 0)}
+                        </span>
+                    </div>
+                </div>
+                
+                {#if activeModifiers.length > 0}
+                    <div class="modifiers-section">
+                        <h4>Active Modifiers</h4>
+                        <div class="modifiers-list">
+                            {#each activeModifiers as modifier}
+                                <span class="modifier-tag">
+                                    <span class="material-icons">tune</span>
+                                    {modifier}
+                                </span>
+                            {/each}
+                        </div>
+                    </div>
+                {/if}
+            </div>
+
+            <!-- Copy Options -->
+            <div class="copy-options-section">
+                <h3>Copy Options</h3>
+                <div class="copy-controls">
+                    <div class="toggle-row">
+                        <label class="toggle-label">
+                            <input type="checkbox" bind:checked={includeMapInfo} />
+                            <span class="toggle-slider"></span>
+                            Include Map Info
+                        </label>
+                        <label class="toggle-label">
+                            <input type="checkbox" bind:checked={includeAccuracy} />
+                            <span class="toggle-slider"></span>
+                            Include Accuracy
+                        </label>
+                    </div>
+                    <div class="toggle-row">
+                        <label class="toggle-label">
+                            <input type="checkbox" bind:checked={includeMisses} />
+                            <span class="toggle-slider"></span>
+                            Include Misses
+                        </label>
+                        <label class="toggle-label">
+                            <input type="checkbox" bind:checked={includeBadCuts} />
+                            <span class="toggle-slider"></span>
+                            Include Bad Cuts
+                        </label>
+                    </div>
+                    <div class="toggle-row">
+                        <label class="toggle-label">
+                            <input type="checkbox" bind:checked={includeEndTime} />
+                            <span class="toggle-slider"></span>
+                            Include End Time
+                        </label>
+                    </div>
+                </div>
+                <button class="copy-button" on:click={copyScoresToClipboard}>
+                    <span class="material-icons">content_copy</span>
+                    Copy Scores to Clipboard
+                </button>
+            </div>
+
+            <!-- Scores Section -->
+            <div class="scores-section">
+                <h3>Scores ({sortedScores.length})</h3>
+                {#if sortedScores.length === 0}
+                    <div class="no-scores">
+                        <span class="material-icons">leaderboard</span>
+                        <p>No scores available</p>
+                    </div>
+                {:else}
+                    <div class="scores-list">
+                        {#each sortedScores as score, index}
+                            {@const position = index + 1}
+                            {@const displayName = score.player?.name || score.player?.discordInfo?.username || 'Unknown Player'}
+                            {@const completed = isCompleted(score, songDuration)}
+                            <div class="score-card {completed ? 'completed' : 'exited-early'}">
+                                <div class="score-position">
+                                    <span class="position-number">{position}</span>
+                                    <span class="position-suffix">{position === 1 ? 'st' : position === 2 ? 'nd' : position === 3 ? 'rd' : 'th'}</span>
+                                </div>
+                                <div class="score-info">
+                                    <div class="player-name">{displayName}</div>
+                                    <div class="score-stats">
+                                        <div class="stat-item primary">
+                                            <span class="material-icons">emoji_events</span>
+                                            <span class="stat-value">{score.score.toLocaleString()}</span>
+                                        </div>
+                                        <div class="stat-item">
+                                            <span class="material-icons">percent</span>
+                                            <span class="stat-value">{score.accuracy}%</span>
+                                        </div>
+                                        <div class="stat-item error">
+                                            <span class="material-icons">close</span>
+                                            <span class="stat-value">{score.misses}</span>
+                                        </div>
+                                        <div class="stat-item error">
+                                            <span class="material-icons">content_cut</span>
+                                            <span class="stat-value">{score.badCuts}</span>
+                                        </div>
+                                    </div>
+                                    <div class="completion-status">
+                                        <span class="material-icons">
+                                            {completed ? 'check_circle' : 'exit_to_app'}
+                                        </span>
+                                        <span class="status-text">
+                                            {getCompletionStatus(score, songDuration)}
+                                        </span>
+                                    </div>
+                                </div>
+                            </div>
+                        {/each}
+                    </div>
+                {/if}
+            </div>
+        </div>
+    </div>
+{/if}
+
+<style>
+    .popup-overlay {
+        position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background-color: rgba(0, 0, 0, 0.8);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        z-index: 1000;
+        padding: 1rem;
+    }
+
+    .popup-content {
+        background-color: var(--bg-secondary);
+        border-radius: 1rem;
+        max-width: 800px;
+        width: 100%;
+        max-height: 90vh;
+        overflow-y: auto;
+        box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
+    }
+
+    .popup-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 1.5rem;
+        border-bottom: 1px solid var(--bg-tertiary);
+    }
+
+    .header-content {
+        display: flex;
+        align-items: center;
+        gap: 1rem;
+        flex: 1;
+    }
+
+    .map-cover {
+        width: 4rem;
+        height: 4rem;
+        border-radius: 0.5rem;
+        overflow: hidden;
+        flex-shrink: 0;
+    }
+
+    .map-cover img {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+    }
+
+    .map-info {
+        flex: 1;
+        min-width: 0;
+    }
+
+    .map-title {
+        font-size: 1.5rem;
+        font-weight: 600;
+        margin: 0 0 0.25rem 0;
+        color: var(--text-primary);
+    }
+
+    .map-artist {
+        font-size: 1rem;
+        color: var(--text-secondary);
+        margin: 0 0 0.25rem 0;
+    }
+
+    .map-mapper {
+        font-size: 0.875rem;
+        color: var(--text-tertiary);
+        margin: 0;
+    }
+
+    .close-button {
+        background: none;
+        border: none;
+        color: var(--text-secondary);
+        cursor: pointer;
+        padding: 0.5rem;
+        border-radius: 0.375rem;
+        transition: all 0.2s ease;
+    }
+
+    .close-button:hover {
+        background-color: var(--bg-tertiary);
+        color: var(--text-primary);
+    }
+
+    .awaiting-scores {
+        display: flex;
+        align-items: center;
+        gap: 0.75rem;
+        padding: 1rem 1.5rem;
+        background-color: rgba(245, 158, 11, 0.1);
+        border: 1px solid rgba(245, 158, 11, 0.2);
+        border-left: 4px solid #F59E0B;
+        margin: 0 1.5rem;
+        border-radius: 0.5rem;
+        color: #F59E0B;
+        font-weight: 500;
+    }
+
+    .loader {
+        width: 1rem;
+        height: 1rem;
+        border: 2px solid rgba(245, 158, 11, 0.3);
+        border-top: 2px solid #F59E0B;
+        border-radius: 50%;
+        animation: spin 1s linear infinite;
+    }
+
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+
+    .map-details-section,
+    .copy-options-section,
+    .scores-section {
+        padding: 1.5rem;
+        border-bottom: 1px solid var(--bg-tertiary);
+    }
+
+    .scores-section {
+        border-bottom: none;
+    }
+
+    .map-details-section h3,
+    .copy-options-section h3,
+    .scores-section h3 {
+        font-size: 1.25rem;
+        font-weight: 600;
+        margin: 0 0 1rem 0;
+        color: var(--text-primary);
+    }
+
+    .details-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+        gap: 1rem;
+        margin-bottom: 1.5rem;
+    }
+
+    .detail-item {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        padding: 0.75rem;
+        background-color: var(--bg-tertiary);
+        border-radius: 0.5rem;
+    }
+
+    .detail-item .material-icons {
+        color: var(--accent-color);
+        font-size: 1.25rem;
+    }
+
+    .detail-label {
+        color: var(--text-secondary);
+        font-size: 0.875rem;
+        font-weight: 500;
+        flex: 1;
+    }
+
+    .detail-value {
+        color: var(--text-primary);
+        font-weight: 600;
+    }
+
+    .difficulty-badge {
+        padding: 0.25rem 0.75rem;
+        border-radius: 0.375rem;
+        font-size: 0.75rem;
+        font-weight: 600;
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+    }
+
+    .difficulty-0 { background-color: #10B981; color: white; }
+    .difficulty-1 { background-color: #3B82F6; color: white; }
+    .difficulty-2 { background-color: #F59E0B; color: white; }
+    .difficulty-3 { background-color: #EF4444; color: white; }
+    .difficulty-4 { background-color: #8B5CF6; color: white; }
+
+    .modifiers-section h4 {
+        font-size: 1rem;
+        font-weight: 500;
+        margin: 0 0 0.75rem 0;
+        color: var(--text-primary);
+    }
+
+    .modifiers-list {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.5rem;
+    }
+
+    .modifier-tag {
+        display: flex;
+        align-items: center;
+        gap: 0.375rem;
+        padding: 0.5rem 0.75rem;
+        background-color: rgba(79, 70, 229, 0.1);
+        color: var(--accent-color);
+        border-radius: 0.375rem;
+        font-size: 0.875rem;
+        font-weight: 500;
+        border: 1px solid rgba(79, 70, 229, 0.2);
+    }
+
+    .modifier-tag .material-icons {
+        font-size: 1rem;
+    }
+
+    .copy-controls {
+        margin-bottom: 1.5rem;
+    }
+
+    .toggle-row {
+        display: flex;
+        gap: 2rem;
+        margin-bottom: 1rem;
+    }
+
+    .toggle-label {
+        display: flex;
+        align-items: center;
+        gap: 0.75rem;
+        cursor: pointer;
+        color: var(--text-primary);
+        font-weight: 500;
+    }
+
+    .toggle-label input[type="checkbox"] {
+        display: none;
+    }
+
+    .toggle-slider {
+        position: relative;
+        width: 2.5rem;
+        height: 1.5rem;
+        background-color: var(--bg-tertiary);
+        border-radius: 0.75rem;
+        transition: background-color 0.2s ease;
+    }
+
+    .toggle-slider::before {
+        content: '';
+        position: absolute;
+        top: 2px;
+        left: 2px;
+        width: 1.25rem;
+        height: 1.25rem;
+        background-color: white;
+        border-radius: 50%;
+        transition: transform 0.2s ease;
+    }
+
+    .toggle-label input[type="checkbox"]:checked + .toggle-slider {
+        background-color: var(--accent-color);
+    }
+
+    .toggle-label input[type="checkbox"]:checked + .toggle-slider::before {
+        transform: translateX(1rem);
+    }
+
+    .copy-button {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        padding: 0.75rem 1.5rem;
+        background-color: var(--accent-color);
+        color: white;
+        border: none;
+        border-radius: 0.5rem;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.2s ease;
+        box-shadow: 0 0 0 0 var(--accent-glow);
+    }
+
+    .copy-button:hover {
+        background-color: var(--accent-hover);
+        box-shadow: 0 0 15px var(--accent-glow);
+        transform: translateY(-1px);
+    }
+
+    .no-scores {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        padding: 3rem 1rem;
+        color: var(--text-secondary);
+        gap: 0.75rem;
+        text-align: center;
+    }
+
+    .no-scores .material-icons {
+        font-size: 3rem;
+        opacity: 0.6;
+    }
+
+    .scores-list {
+        display: flex;
+        flex-direction: column;
+        gap: 1rem;
+    }
+
+    .score-card {
+        display: flex;
+        align-items: center;
+        gap: 1rem;
+        padding: 1rem;
+        background-color: var(--bg-tertiary);
+        border-radius: 0.75rem;
+        transition: all 0.2s ease;
+        border-left: 4px solid transparent;
+    }
+
+    .score-card.completed {
+        border-left-color: #10B981;
+    }
+
+    .score-card.exited-early {
+        border-left-color: #EF4444;
+    }
+
+    .score-card:hover {
+        background-color: var(--bg-primary);
+        transform: translateY(-1px);
+    }
+
+    .score-position {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        width: 3rem;
+        height: 3rem;
+        background-color: var(--bg-secondary);
+        border-radius: 0.5rem;
+        flex-shrink: 0;
+    }
+
+    .position-number {
+        font-size: 1.25rem;
+        font-weight: 700;
+        color: var(--text-primary);
+        line-height: 1;
+    }
+
+    .position-suffix {
+        font-size: 0.625rem;
+        color: var(--text-secondary);
+        line-height: 1;
+    }
+
+    .score-info {
+        flex: 1;
+        min-width: 0;
+    }
+
+    .player-name {
+        font-size: 1rem;
+        font-weight: 600;
+        color: var(--text-primary);
+        margin-bottom: 0.5rem;
+    }
+
+    .score-stats {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 1rem;
+        margin-bottom: 0.5rem;
+    }
+
+    .stat-item {
+        display: flex;
+        align-items: center;
+        gap: 0.375rem;
+        padding: 0.25rem 0.5rem;
+        background-color: var(--bg-secondary);
+        border-radius: 0.375rem;
+        font-size: 0.875rem;
+        font-weight: 500;
+    }
+
+    .stat-item.primary {
+        background-color: rgba(251, 191, 36, 0.1);
+        color: #F59E0B;
+    }
+
+    .stat-item.error {
+        background-color: rgba(239, 68, 68, 0.1);
+        color: #EF4444;
+    }
+
+    .stat-item .material-icons {
+        font-size: 1rem;
+    }
+
+    .completion-status {
+        display: flex;
+        align-items: center;
+        gap: 0.375rem;
+        font-size: 0.75rem;
+        color: var(--text-secondary);
+    }
+
+    .completion-status .material-icons {
+        font-size: 1rem;
+    }
+
+    .score-card.completed .completion-status {
+        color: #10B981;
+    }
+
+    .score-card.exited-early .completion-status {
+        color: #EF4444;
+    }
+
+    .material-icons {
+        font-family: 'Material Icons';
+        font-weight: normal;
+        font-style: normal;
+        font-size: 24px;
+        line-height: 1;
+        letter-spacing: normal;
+        text-transform: none;
+        display: inline-block;
+        white-space: nowrap;
+        word-wrap: normal;
+        direction: ltr;
+        -webkit-font-feature-settings: 'liga';
+        -webkit-font-smoothing: antialiased;
+    }
+
+    /* Scrollbar Styling */
+    .popup-content::-webkit-scrollbar {
+        width: 0.5rem;
+    }
+
+    .popup-content::-webkit-scrollbar-track {
+        background: var(--bg-tertiary);
+        border-radius: 0.25rem;
+    }
+
+    .popup-content::-webkit-scrollbar-thumb {
+        background: var(--text-secondary);
+        border-radius: 0.25rem;
+    }
+
+    .popup-content::-webkit-scrollbar-thumb:hover {
+        background: var(--text-primary);
+    }
+
+    /* Responsive Design */
+    @media (max-width: 768px) {
+        .popup-overlay {
+            padding: 0.5rem;
+        }
+
+        .popup-content {
+            max-height: 95vh;
+        }
+
+        .header-content {
+            flex-direction: column;
+            text-align: center;
+            gap: 0.75rem;
+        }
+
+        .details-grid {
+            grid-template-columns: 1fr;
+        }
+
+        .toggle-row {
+            flex-direction: column;
+            gap: 1rem;
+        }
+
+        .score-stats {
+            flex-direction: column;
+            gap: 0.5rem;
+        }
+
+        .score-card {
+            flex-direction: column;
+            text-align: center;
+            gap: 0.75rem;
+        }
+    }
+</style>
\ No newline at end of file
diff --git a/src/lib/config.json b/src/lib/config.json
index ed73de2..1d54d99 100644
--- a/src/lib/config.json
+++ b/src/lib/config.json
@@ -1,6 +1,7 @@
 {
-    "discordAuthUrl": "https://discord.com/oauth2/authorize?client_id=1348291960552820757&response_type=token&redirect_uri=http%3A%2F%2Flocalhost%3A1420%2FdiscordAuth&scope=identify",
+    "discordAuthUrl": "https://discord.com/oauth2/authorize?client_id=1348291960552820757&response_type=token&redirect_uri=https%3A%2F%2Fstaging.taui.shyyluna.dev%2FdiscordAuth&scope=identify",
     "bkAPIUrl": "https://api.beatkhana.com/api",
     "prodAuthUrl": "https://discord.com/oauth2/authorize?client_id=1348291960552820757&response_type=token&redirect_uri=https%3A%2F%2Ftaui.shyyluna.dev%2FdiscordAuth&scope=identify",
-    "stagingAuthUrl": "https://discord.com/oauth2/authorize?client_id=1348291960552820757&response_type=token&redirect_uri=https%3A%2F%2Fstaging.taui.shyyluna.dev%2FdiscordAuth&scope=identify"
+    "stagingAuthUrl": "https://discord.com/oauth2/authorize?client_id=1348291960552820757&response_type=token&redirect_uri=https%3A%2F%2Fstaging.taui.shyyluna.dev%2FdiscordAuth&scope=identify",
+    "devAuthUrl": "https://discord.com/oauth2/authorize?client_id=1348291960552820757&response_type=token&redirect_uri=http%3A%2F%2Flocalhost%3A1420%2FdiscordAuth&scope=identify"
 }
\ No newline at end of file
diff --git a/src/lib/interfaces/match.interfaces.ts b/src/lib/interfaces/match.interfaces.ts
new file mode 100644
index 0000000..b1f0b09
--- /dev/null
+++ b/src/lib/interfaces/match.interfaces.ts
@@ -0,0 +1,61 @@
+// src/lib/types/match.ts
+import type { Map, User, RealtimeScore, Push_SongFinished } from 'moons-ta-client';
+import type { BeatSaverMap } from '$lib/services/beatsaver.js';
+
+export interface CustomMap {
+    taData: Map;
+    beatsaverData: BeatSaverMap;
+}
+
+export interface RealTimeScoreForPlayers {
+    player: User;
+    recentScore: RealtimeScore;
+}
+
+export interface ScoreWithAccuracy extends Push_SongFinished {
+    accuracy: string;
+}
+
+export interface PreviousResults {
+    taData: Map;
+    beatsaverData: BeatSaverMap;
+    scores: ScoreWithAccuracy[];
+    completionType: 'Completed' | 'Still Awaiting Scores' | 'Exited To Menu';
+}
+
+export enum MapDifficulty {
+    "Easy" = 0,
+    "Normal" = 1,
+    "Hard" = 2,
+    "Expert" = 3,
+    "ExpertPlus" = 4,
+}
+
+export const colorPresets = {
+    primary: 'var(--accent-glow)',
+    secondary: 'var(--text-secondary)',
+    success: '#4CAF50',
+    warning: '#FFC107',
+    error: '#F44336',
+    info: '#2196F3',
+    default: 'var(--text-primary)'
+} as const;
+
+export type ColorPreset = keyof typeof colorPresets;
+export type ButtonType = 'primary' | 'secondary' | 'text' | 'outlined';
+
+export interface ButtonConfig {
+    text: string;
+    type: ButtonType;
+    href?: string;
+    color?: ColorPreset;
+    icon?: string;
+    action?: () => void;
+}
+
+export interface CustomTAMapPool {
+    guid: string;
+    name: string;
+    image: Uint8Array;
+    maps: CustomMap[];
+}
\ No newline at end of file
diff --git a/src/lib/services/gamePlayModifiers.ts b/src/lib/services/gamePlayModifiers.ts
new file mode 100644
index 0000000..a10ed84
--- /dev/null
+++ b/src/lib/services/gamePlayModifiers.ts
@@ -0,0 +1,155 @@
+import { Response_ResponseType, Map, Characteristic, GameplayModifiers_GameOptions } from 'moons-ta-client';
+
+// Beat Saber Modifiers with incompatibility groups
+export interface Modifier {
+    id: GameplayModifiers_GameOptions;
+    name: string;
+    description: string;
+    enabled: boolean;
+    group: string;
+    incompatibilityGroup?: string; // Modifiers in same group are mutually exclusive
+    allowedInMode?: ('qualifier' | 'playing')[];
+}
+
+// Game modifiers with proper grouping and mode restrictions
+export const allGameModifiers: Modifier[] = [
+    // Failure Prevention (mutually exclusive)
+    { 
+        id: GameplayModifiers_GameOptions.NoFail, 
+        name: "No Fail", 
+        description: "You can't fail the level", 
+        enabled: false, 
+        group: "Failure Prevention",
+        incompatibilityGroup: "failure",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    { 
+        id: GameplayModifiers_GameOptions.InstaFail, 
+        name: "One Life", 
+        description: "You only have one life", 
+        enabled: false, 
+        group: "Failure Prevention",
+        incompatibilityGroup: "failure",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    { 
+        id: GameplayModifiers_GameOptions.BatteryEnergy, 
+        name: "Four Lives", 
+        description: "You have four lives", 
+        enabled: false, 
+        group: "Failure Prevention",
+        incompatibilityGroup: "failure",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    
+    // Environment Modifiers
+    { 
+        id: GameplayModifiers_GameOptions.NoBombs, 
+        name: "No Bombs", 
+        description: "No bombs will appear", 
+        enabled: false, 
+        group: "Environment",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    { 
+        id: GameplayModifiers_GameOptions.NoObstacles, 
+        name: "No Walls", 
+        description: "No walls will appear", 
+        enabled: false, 
+        group: "Environment",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    
+    // Note Modifiers (some mutually exclusive)
+    { 
+        id: GameplayModifiers_GameOptions.NoArrows, 
+        name: "No Arrows", 
+        description: "All notes can be cut in any direction", 
+        enabled: false, 
+        group: "Note Modifiers",
+        incompatibilityGroup: "arrows",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    { 
+        id: GameplayModifiers_GameOptions.DisappearingArrows, 
+        name: "Disappearing Arrows", 
+        description: "Arrows disappear as they approach you", 
+        enabled: false, 
+        group: "Note Modifiers",
+        incompatibilityGroup: "arrows",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    { 
+        id: GameplayModifiers_GameOptions.GhostNotes, 
+        name: "Ghost Notes", 
+        description: "Note colors are hidden", 
+        enabled: false, 
+        group: "Note Modifiers",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    
+    // Speed Modifiers (mutually exclusive)
+    { 
+        id: GameplayModifiers_GameOptions.SlowSong, 
+        name: "Slower Song", 
+        description: "Reduces the song speed by 15%", 
+        enabled: false, 
+        group: "Speed",
+        incompatibilityGroup: "speed",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    { 
+        id: GameplayModifiers_GameOptions.FastSong, 
+        name: "Faster Song", 
+        description: "Increases the song speed by 20%", 
+        enabled: false, 
+        group: "Speed",
+        incompatibilityGroup: "speed",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    { 
+        id: GameplayModifiers_GameOptions.SuperFastSong, 
+        name: "Super Fast Song", 
+        description: "Increases the song speed by 50%", 
+        enabled: false, 
+        group: "Speed",
+        incompatibilityGroup: "speed",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    
+    // Visual Modifiers (some mutually exclusive)
+    { 
+        id: GameplayModifiers_GameOptions.SmallCubes, 
+        name: "Small Notes", 
+        description: "Notes are smaller", 
+        enabled: false, 
+        group: "Visual",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    { 
+        id: GameplayModifiers_GameOptions.ProMode, 
+        name: "Pro Mode", 
+        description: "Makes notes smaller, removes debris, and adds hit scores", 
+        enabled: false, 
+        group: "Visual",
+        allowedInMode: ['qualifier', 'playing']
+    },
+    
+    // Special Modifiers
+    { 
+        id: GameplayModifiers_GameOptions.ZenMode, 
+        name: "Zen Mode", 
+        description: "No fail, no bombs, reduced obstacles", 
+        enabled: false, 
+        group: "Special",
+        allowedInMode: ['playing'] // Only for playing mode
+    },
+    { 
+        id: GameplayModifiers_GameOptions.StrictAngles, 
+        name: "Strict Angles", 
+        description: "Stricter angle enforcement for cuts", 
+        enabled: false, 
+        group: "Special",
+        allowedInMode: ['qualifier', 'playing']
+    }
+];
\ No newline at end of file
diff --git a/src/routes/tournaments/[tournamentguid]/mappools/[poolGuid]/+page.svelte b/src/routes/tournaments/[tournamentguid]/mappools/[poolGuid]/+page.svelte
index ffca3fd..e839549 100644
--- a/src/routes/tournaments/[tournamentguid]/mappools/[poolGuid]/+page.svelte
+++ b/src/routes/tournaments/[tournamentguid]/mappools/[poolGuid]/+page.svelte
@@ -8,7 +8,10 @@
     import Popup from "$lib/components/notifications/Popup.svelte";
     import InfoPopup from "$lib/components/notifications/InfoPopup.svelte";
     import EditMapModal from "$lib/components/popups/EditMap.svelte";
+    import AddMapsFromFile from "$lib/components/popups/AddMapsFromFile.svelte";
+    import { type BeatSaverMap } from "$lib/services/beatsaver.js";
     import { goto } from "$app/navigation";
+    import type { CustomMap } from "$lib/interfaces/match.interfaces.js";
 
     export let data;
 
@@ -19,37 +22,7 @@
     let isLoading = false;
     let error: string | null = null;
     let poolName: string = "";
-    let maps: {
-        taData: Map,
-        beatsaverData: BeatSaverMap
-    }[] = [];
-
-    type BeatSaverMap = {
-        id: string;
-        metadata: {
-            songName: string;
-            songAuthorName: string;
-            levelAuthorName: string;
-            songSubName: string;
-            duration: number;
-            bpm: number;
-        };
-        versions: Array<{
-            hash: string;
-            state: string;
-            createdAt: string;
-            downloadURL: string;
-            diffs: Array<{
-                characteristic: string;
-                difficulty: string;
-                maxScore: number;
-                nps: number;
-            }>;
-            coverURL: string;
-            previewURL: string;
-        }>;
-        uploaded: string;
-    };
+    let maps: CustomMap[] = [];
 
     enum MapDifficulty {
         "Easy" = 0,
@@ -59,17 +32,6 @@
         "Expert+" = 4
     }
 
-    interface Modifier {
-        id: GameplayModifiers_GameOptions;
-        name: string;
-        description: string;
-        enabled: boolean;
-        disabled?: boolean;
-        group?: string;
-        incompatibilityGroup?: string;
-        allowedInMode: string[];
-    }
-
     const modifierNameMap: Record<number, string> = {
         [GameplayModifiers_GameOptions.None]: "",
         [GameplayModifiers_GameOptions.NoFail]: "No Fail",
@@ -108,6 +70,9 @@
     // Success notification
     let showSuccessNotification = false;
     let successMessage = "";
+
+    // Import maps popup
+    let showLoadMapsFromFilePopup: boolean = false;
     
     // Remove 'Bearer ' from the token
     if ($authTokenStore) {
@@ -133,6 +98,14 @@
         showEditMapModal = false;
         currentEditMap = null;
     }
+
+    function openLoadMapsFromFilePopup() {
+        showLoadMapsFromFilePopup = true;
+    }
+
+    function closeLoadMapsFromFilePopup() {
+        showLoadMapsFromFilePopup = false;
+    }
     
     function openDeleteConfirmation(mapId: string) {
         mapToDelete = mapId;
@@ -147,6 +120,21 @@
     function closeNotification() {
         showSuccessNotification = false;
     }
+
+    async function handleAddMapsFromFile(event: CustomEvent) {
+        const toAddMaps = (event.detail.maps as CustomMap[]);
+
+        const taDatasToAdd = await toAddMaps.map((map) => map.taData);
+        const addResponse = await client.addTournamentPoolMaps(tournamentGuid, poolGuid, taDatasToAdd);
+
+        console.log('Added multiple maps response:', addResponse);
+        fetchMapPoolData();
+        showSuccessNotification = true;
+        setTimeout(() => {
+            showSuccessNotification = false;
+        }, 2500);
+        successMessage = "Map successfully updated!";
+    }
     
     async function handleMapUpdated(event: CustomEvent) {
         await client.updateTournamentPoolMap(tournamentGuid, poolGuid, event.detail.map);
@@ -331,6 +319,10 @@
                             <span class="material-icons">add</span>
                             Add Map
                         </button>
+                        <button class="action-button add" on:click={() => openLoadMapsFromFilePopup()}>
+                            <span class="material-icons">add</span>
+                            Load Maps From File
+                        </button>
                         <button class="action-button refresh" on:click={fetchMapPoolData}>
                             <span class="material-icons">refresh</span>
                             Refresh
@@ -446,8 +438,7 @@
 {#if showEditMapModal}
     <EditMapModal 
         tournamentGuid={tournamentGuid}
-        poolGuid={poolGuid}
-        map={maps.find(map => map.taData.guid == currentEditMap?.guid) || null}
+        map={maps.filter(map => map.taData.guid == currentEditMap?.guid)[0] || null}
         on:close={closeEditMapModal} 
         on:mapUpdated={handleMapUpdated}
         on:mapAdded={handleMapAdded}
@@ -455,6 +446,13 @@
     />
 {/if}
 
+<!-- Add Maps From File Modal Component -->
+<AddMapsFromFile
+    isOpen={showLoadMapsFromFilePopup}
+    on:close={closeLoadMapsFromFilePopup}
+    on:addMaps={handleAddMapsFromFile}
+/>
+
 <!-- Info Popup -->
 {#if showInfoPopup}
     <InfoPopup content={infoPopupContent} onClose={closeInfoPopup} />
diff --git a/src/routes/tournaments/[tournamentguid]/matches/[matchGuid]/+page.svelte b/src/routes/tournaments/[tournamentguid]/matches/[matchGuid]/+page.svelte
index a215d3e..8bb4f85 100644
--- a/src/routes/tournaments/[tournamentguid]/matches/[matchGuid]/+page.svelte
+++ b/src/routes/tournaments/[tournamentguid]/matches/[matchGuid]/+page.svelte
@@ -4,43 +4,51 @@
     import { bkAPIUrl } from '$lib/config.json';
     import Notification from '$lib/components/notifications/Popup.svelte';
     //@ts-ignore
-    import { Match, Tournament, TAClient, Response_ResponseType, User, RealtimeScore, Push_SongFinished, Map, User_DownloadStates, User_PlayStates } from 'moons-ta-client';
+    import { 
+        Match, 
+        Tournament, 
+        TAClient, 
+        Response_ResponseType, 
+        User, 
+        RealtimeScore, 
+        Push_SongFinished, 
+        Map, 
+        User_DownloadStates, 
+        User_PlayStates,
+        Tournament_TournamentSettings_Pool
+    } from 'moons-ta-client';
     import { writable } from "svelte/store";
     import { goto } from "$app/navigation";
-    import { fetchMapByLevelId, type BeatSaverMap } from "$lib/services/beatsaver.js";
+    import { fetchMapByLevelId, fetchMapsByLevelIds, type BeatSaverMap } from "$lib/services/beatsaver.js";
     import SongQueue from "$lib/components/modules/SongQueue.svelte";
     import EditMap from "$lib/components/popups/EditMap.svelte";
     import Popup from "$lib/components/notifications/Popup.svelte";
     import PreviouslyPlayedSongs from "$lib/components/modules/PreviouslyPlayedSongs.svelte";
+    import ResultsForMap from "$lib/components/popups/ResultsForMap.svelte";
+    import AddMapsFromTAPool from "$lib/components/popups/AddMapsFromTAPool.svelte";
+    
+    // Types
+    import { 
+        type CustomMap, 
+        type RealTimeScoreForPlayers, 
+        type ScoreWithAccuracy, 
+        type PreviousResults, 
+        type ButtonConfig, 
+        type ColorPreset,
+        MapDifficulty,
+
+        type CustomTAMapPool
+
+    } from "$lib/interfaces/match.interfaces";
+    import AddMapsFromFile from "$lib/components/popups/AddMapsFromFile.svelte";
 
     export let data;
 
-    interface CustomMap {
-        taData: Map,
-        beatsaverData: BeatSaverMap
-    }
-
-    interface RealTimeScoreForPlayers {
-        player: User,
-        recentScore: RealtimeScore
-    }
-
-    interface ScoreWithAccuracy extends Push_SongFinished {
-        accuracy: number;
-    }
-
-    interface PreviousResults {
-        taData: Map;
-        beatsaverData: BeatSaverMap;
-        scores: ScoreWithAccuracy[];
-        completionType: 'Completed' | 'Still Awaiting Scores' | 'Exited To Menu';
-    }
-
-    let upcomingQueueMaps: CustomMap[] = [];
-
+    // Route params
     const tournamentGuid: string = data.tournamentGuid;
     const matchGuid: string = data.matchGuid;
-    
+
+    // Core state
     let tournament: Tournament | undefined;
     let match: Match | undefined;
     let isLoading = false;
@@ -51,29 +59,11 @@
     let isMatchActive = false;
     let streamSyncEnabled = false;
 
+    // Song queue and results
+    let upcomingQueueMaps: CustomMap[] = [];
     let realTimeScores: RealTimeScoreForPlayers[] = [];
     let previousMatchResults: PreviousResults[] = [];
-
-    const colorPresets = {
-        primary: 'var(--accent-glow)',
-        secondary: 'var(--text-secondary)',
-        success: '#4CAF50',
-        warning: '#FFC107',
-        error: '#F44336',
-        info: '#2196F3',
-        default: 'var(--text-primary)'
-    };
-    type ColorPreset = keyof typeof colorPresets;
-    
-    type ButtonType = 'primary' | 'secondary' | 'text' | 'outlined';
-    interface ButtonConfig {
-        text: string;
-        type: ButtonType;
-        href?: string;
-        color?: ColorPreset;
-        icon?: string;
-        action?: () => void;
-    }
+    let showingResultsData: PreviousResults;
 
     // Modal states
     let showKickConfirmModal = false;
@@ -86,30 +76,60 @@
     let modalIconColor: ColorPreset = 'error';
     let modalButtons: ButtonConfig[] = [];
     let modalCustomImage: string = "";
-    let modalAutoClose: number = 0; // no auto close
+    let modalAutoClose: number = 0;
 
+    // Map editing states
     let showMapModal: boolean = false;
     let currentlyEditingMap: CustomMap | null = null;
 
+    // Song loading states
     let loadingSongForPlayers: boolean = false;
     let failedToLoadSongForPlayers: boolean = false;
 
+    // Results popup states
+    let showResultsPopup: boolean = false;
+    let dontShowResultsPopupForThisSong: boolean = false;
+    let currentlyShowingOldMapResults: boolean = false;
+
+    // Add maps from TA pool modal state
+    let taPools: Tournament_TournamentSettings_Pool[] = [];
+    let customTAPools: CustomTAMapPool[] = [];
+    let showAddFromTAPoolPopup: boolean = false;
+    let allowAddFromTAPool: boolean = true;
+
+    // Active song tracking
     const activeSongPlayers = new Set<`${string}-${string}`>(); // Format: "userGuid-levelId"
 
-    // Remove 'Bearer ' from the token
-    if($authTokenStore) {
+    // Reactive statements
+    $: isAnyPlayerPlaying = matchPlayers.some(player => (player.playState as any) === User_PlayStates.InGame);
+
+    if ($authTokenStore) {
         const cleanToken = $authTokenStore.replace('Bearer ', '');
         client.setAuthToken(cleanToken);
     }
 
-    $: isAnyPlayerPlaying = matchPlayers.some(player => (player.playState as any) === User_PlayStates.InGame);
-
-    // Show notification function (you mentioned you have this)
+    // Show notification function
     function showNotification(message: string, type: 'warning' | 'error' | 'success' = 'warning') {
         // Your existing notification function
         console.log(`${type}: ${message}`);
     }
 
+    function handleExitResultsPopupClicked() {
+        showResultsPopup = false;
+        if(!currentlyShowingOldMapResults) {
+            dontShowResultsPopupForThisSong = true;
+        }
+        currentlyShowingOldMapResults = false;
+    }
+
+    function showResultsPopupWithOldScores(event: CustomEvent) {
+        const oldData: PreviousResults = event.detail.map;
+        currentlyShowingOldMapResults = true;
+        showingResultsData = oldData;
+        showResultsPopup = true;
+        dontShowResultsPopupForThisSong = false;
+    }
+
     // Handle back to matches with confirmation if needed
     async function handleBackToMatches(endMatch: boolean) {
         if(match!.leader !== client.stateManager.getSelfGuid()) {
@@ -344,11 +364,74 @@
 
                 if(tempMapData) {
                     currentSongData = tempMapData;
+                    if(!upcomingQueueMaps.some(x => x.taData.gameplayParameters?.beatmap?.levelId.toUpperCase() == currentSong.beatmap.levelId.toUpperCase())) {
+                        upcomingQueueMaps = [
+                            {
+                                taData: match.selectedMap!,
+                                beatsaverData: tempMapData!
+                            },
+                            ...upcomingQueueMaps
+                        ];
+                    }
                 }
             } catch (error) {
                 console.log('Current song beatsaver data fetch failed');
             }
         }
+
+        const tournament = client.stateManager.getTournament(tournamentGuid);
+
+        if(!tournament!.settings!.enablePools) {
+            allowAddFromTAPool = false;
+            return;
+        }
+
+        taPools = tournament!.settings!.pools;
+
+        // First, collect all unique level IDs from all pools
+        const allLevelIds = taPools.flatMap(pool => 
+            pool.maps.map(map => map.gameplayParameters!.beatmap!.levelId)
+        );
+
+        // Remove duplicates to avoid fetching the same map multiple times
+        const uniqueLevelIds = [...new Set(allLevelIds)];
+
+        // Fetch all maps data in one go (your function handles chunking internally)
+        const allMapBeatSaverDatas = await fetchMapsByLevelIds(uniqueLevelIds);
+
+        // Create a lookup object for quick access
+        const mapDataLookup: { [levelId: string]: any } = {};
+        allMapBeatSaverDatas.forEach(mapData => {
+            if (mapData && mapData.versions[0].hash) {
+                mapDataLookup[mapData.versions[0].hash] = mapData;
+            }
+        });
+
+        // Now process each pool using the pre-fetched data
+        customTAPools = await Promise.all(
+            taPools.map(async (pool) => {
+                const poolCustomMaps: CustomMap[] = pool.maps
+                    .map(map => {
+                        const levelId = map.gameplayParameters!.beatmap!.levelId;
+                        const beatsaverData = mapDataLookup[(levelId.replace('custom_level_', ''))];
+                        
+                        if (!beatsaverData) return null;
+                        
+                        return {
+                            taData: map,
+                            beatsaverData: beatsaverData
+                        };
+                    })
+                    .filter(result => result !== null) as CustomMap[];
+                
+                return {
+                    name: pool.name,
+                    guid: pool.guid,
+                    image: pool.image,
+                    maps: poolCustomMaps
+                };
+            })
+        );
     }
 
     async function fetchMatchData() {
@@ -399,6 +482,9 @@
     async function startSongForMatch() {
         if (!currentSong) return;
         
+        showResultsPopup = false;
+        dontShowResultsPopupForThisSong = false;
+
         const levelId = currentSong.beatmap.levelId;
         const playingPlayerIds = matchPlayers.map(player => player.guid);
         
@@ -454,6 +540,8 @@
 
         const player = matchPlayers.find(x => x.guid === rts.userGuid)!;
 
+        if(!player) return;
+
         const index = realTimeScores.findIndex(x => x.player.guid === rts.userGuid);
 
         if (index !== -1) {
@@ -495,6 +583,39 @@
         return playerScore;
     }
 
+    function getMaxScore(songInfo: BeatSaverMap, characteristic: string = "standard", difficulty: string): number {
+        const diff = songInfo.versions[0].diffs.find(
+            (x) => {
+                const charMatch = x.characteristic.toLowerCase() === characteristic.toLowerCase();
+                
+                // Normalize difficulty strings for comparison
+                const searchDiff = difficulty.toLowerCase() === "expert+" ? "expertplus" : difficulty.toLowerCase();
+                const diffDiff = x.difficulty.toLowerCase() === "expert+" ? "expertplus" : x.difficulty.toLowerCase();
+                
+                return charMatch && diffDiff === searchDiff;
+            }
+        );
+
+        return diff?.maxScore ?? 100000;
+    }
+
+    // Method to convert difficulty number to string
+    function getDifficultyAsString(difficulty: number): string {
+        return MapDifficulty[difficulty] || "ExpertPlus";
+    }
+
+    // Main accuracy calculation logic
+    function calculateAccuracy(score: Push_SongFinished, mapWithSongInfo: CustomMap): string {
+        const maxScore = getMaxScore(
+            mapWithSongInfo.beatsaverData,
+            score.beatmap?.characteristic?.serializedName ?? "Standard",
+            getDifficultyAsString(score.beatmap?.difficulty ?? 4) || "ExpertPlus",
+        );
+        
+        const accuracy = ((score.score / maxScore) * 100).toFixed(2);
+        return accuracy;
+    }
+
     async function handleSongFinished(rts: Push_SongFinished) {
         if (rts.matchId !== matchGuid) return;
         
@@ -513,7 +634,8 @@
             return;
         }
         
-        const newRts: ScoreWithAccuracy = {...rts, accuracy: 0};
+        let newRts: ScoreWithAccuracy = {...rts, accuracy: "0"};
+        newRts.accuracy = calculateAccuracy(rts, map);
         
         // Check if any players are still playing this song
         const playersStillPlaying = Array.from(activeSongPlayers)
@@ -551,6 +673,9 @@
                 ...previousMatchResults.filter((_, i) => i !== existingRecordIndex)
             ];
         }
+
+        showingResultsData = previousMatchResults[0];
+        showResultsPopup = true;
     }
 
     async function handleMapUpdated(event: CustomEvent) {
@@ -582,6 +707,23 @@
         ];
     }
 
+    function handleShowAddMapsFromTAPool() {
+        showAddFromTAPoolPopup = true;
+    }
+
+    function handleCloseAddMapsFromTAPool() {
+        showAddFromTAPoolPopup = false;
+    }
+
+    function handleAddMapsFromTAPool(event: CustomEvent) {
+        showAddFromTAPoolPopup = false;
+        const mapsToAdd: CustomMap[] = event.detail.maps;
+        upcomingQueueMaps = [
+            ...mapsToAdd,
+            ...upcomingQueueMaps
+        ];
+    }
+
     function closeEditMapModal() {
         showMapModal = false;
     }
@@ -606,6 +748,7 @@
         const map: CustomMap = event.detail.map;
         loadingSongForPlayers = false;
         failedToLoadSongForPlayers = false;
+        dontShowResultsPopupForThisSong = false;
 
         let playingPlayerIds = matchPlayers
             .filter(player => player.playState !== User_PlayStates.InGame)
@@ -704,7 +847,7 @@
                         End Match
                     </button>
                     <div class="match-info">
-                        <h2>Match: {'Unknown'}</h2>
+                        <h2>Match: {match?.guid || 'Undefined'}</h2>
                         <p class="tournament-name">{tournament?.settings?.tournamentName}</p>
                     </div>
                 </div>
@@ -865,6 +1008,7 @@
                             on:editMap={handleEditMap} 
                             on:removeMap={handleRemoveMapFromQueue}
                             on:songLoad={handleLoadMap}
+                            on:addMapsFromTAPool={handleShowAddMapsFromTAPool}
                         />
                     </div>
 
@@ -872,6 +1016,7 @@
                     <div class="queue-section">
                         <PreviouslyPlayedSongs
                             maps={previousMatchResults}
+                            on:showMapDetails={showResultsPopupWithOldScores}
                         />
                     </div>
                 </div>
@@ -901,6 +1046,21 @@
     autoClose={modalAutoClose}
 />
 
+<ResultsForMap 
+    mapData={showingResultsData}
+    isVisible={showResultsPopup && !dontShowResultsPopupForThisSong}
+    on:close={handleExitResultsPopupClicked}
+/>
+
+{#if allowAddFromTAPool}
+    <AddMapsFromTAPool
+        isOpen={showAddFromTAPoolPopup}
+        mapPools={customTAPools}
+        on:close={handleCloseAddMapsFromTAPool}
+        on:addMaps={handleAddMapsFromTAPool}
+    />
+{/if}
+
 <style>
     .match-dashboard {
         display: flex;
@@ -1048,6 +1208,8 @@
         border-radius: 0.75rem;
         padding-top: 1rem;
         box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        max-height: 20rem;
+        overflow-y: scroll;
     }
     
     /* Section Styles */
@@ -1111,8 +1273,8 @@
         display: flex;
         flex-direction: column;
         gap: 0.75rem;
-        max-height: 50vh;
-        overflow-y: auto;
+        max-height: 20rem;
+        overflow-y: scroll;
     }
     
     .player-card {