From d184724c70cec5c065bdb32c099c640a43cc541a Mon Sep 17 00:00:00 2001
From: mbrucedogs <mbrucedogs@gmail.com>
Date: Wed, 30 Jul 2025 18:20:10 -0500
Subject: [PATCH] Signed-off-by: mbrucedogs <mbrucedogs@gmail.com>

---
 cli/main.py                            |  495 ++++++++---
 cli/playlist_validator.py              |  344 ++++++++
 web/app.py                             |  734 ++++++++++++++++-
 web/templates/favorites.html           | 1000 ++++++++++++++++++++++
 web/templates/history.html             | 1047 ++++++++++++++++++++++++
 web/templates/index.html               |   37 +-
 web/templates/playlist_validation.html | 1002 +++++++++++++++++++++++
 web/templates/remaining_songs.html     |   32 +
 8 files changed, 4552 insertions(+), 139 deletions(-)
 create mode 100644 cli/playlist_validator.py
 create mode 100644 web/templates/favorites.html
 create mode 100644 web/templates/history.html
 create mode 100644 web/templates/playlist_validation.html

diff --git a/cli/main.py b/cli/main.py
index 35186e4..532f58d 100644
--- a/cli/main.py
+++ b/cli/main.py
@@ -15,6 +15,192 @@ from matching import SongMatcher
 from report import ReportGenerator
 
 
+def merge_history_objects(data_dir: str, args) -> None:
+    """Merge history objects that match on artist, title, and path, summing their count properties."""
+    history_path = os.path.join(data_dir, 'history.json')
+    
+    if not os.path.exists(history_path):
+        print(f"History file not found: {history_path}")
+        return
+    
+    try:
+        # Load current history
+        history_items = load_json_file(history_path)
+        if not history_items:
+            print("No history items found to merge")
+            return
+        
+        print(f"\n🔄 Merging history objects...")
+        print(f"Processing {len(history_items):,} history entries...")
+        
+        # Create a dictionary to group items by artist, title, and path
+        grouped_items = {}
+        merged_count = 0
+        total_merged_entries = 0
+        
+        for item in history_items:
+            if not isinstance(item, dict):
+                continue
+                
+            artist = item.get('artist', '').strip()
+            title = item.get('title', '').strip()
+            path = item.get('path', '').strip()
+            
+            if not artist or not title or not path:
+                continue
+            
+            # Create a key for grouping
+            key = (artist.lower(), title.lower(), path.lower())
+            
+            if key not in grouped_items:
+                grouped_items[key] = []
+            grouped_items[key].append(item)
+        
+        # Process groups with multiple items
+        merged_items = []
+        
+        for key, items in grouped_items.items():
+            if len(items) == 1:
+                # Single item, keep as is
+                merged_items.append(items[0])
+            else:
+                # Multiple items, merge them
+                artist, title, path = key
+                
+                # Start with the first item as the base
+                merged_item = items[0].copy()
+                
+                # Sum the counts (handle both int and string values)
+                total_count = 0
+                for item in items:
+                    count_value = item.get('count', 0)
+                    if isinstance(count_value, str):
+                        try:
+                            total_count += int(count_value)
+                        except ValueError:
+                            total_count += 0
+                    else:
+                        total_count += count_value
+                merged_item['count'] = total_count
+                
+                # For boolean properties, if any are True, keep True
+                merged_item['favorite'] = any(item.get('favorite', False) for item in items)
+                merged_item['disabled'] = any(item.get('disabled', False) for item in items)
+                
+                # For other properties, keep the first non-empty value
+                for prop in ['key', 'original_path', 'genre']:
+                    if prop in merged_item and merged_item[prop]:
+                        continue
+                    for item in items[1:]:  # Skip first item since we already have it
+                        if item.get(prop):
+                            merged_item[prop] = item[prop]
+                            break
+                
+                merged_items.append(merged_item)
+                merged_count += 1
+                total_merged_entries += len(items)
+                
+                if args.verbose:
+                    print(f"Merged {len(items)} entries for '{artist} - {title}': total count = {total_count}")
+        
+        # Save the merged history
+        if not args.dry_run:
+            save_json_file(merged_items, history_path)
+            print(f"✅ Merged {merged_count} groups ({total_merged_entries} total entries → {len(merged_items)} entries)")
+            print(f"📁 Saved to: {history_path}")
+        else:
+            print(f"DRY RUN: Would merge {merged_count} groups ({total_merged_entries} total entries → {len(merged_items)} entries)")
+        
+    except Exception as e:
+        print(f"Error merging history objects: {e}")
+
+
+def process_favorites_and_history(matcher: SongMatcher, all_songs: List[Dict[str, Any]], data_dir: str, args) -> None:
+    """Process favorites and history with priority-based logic to select best versions."""
+    
+    def process_file(file_type: str, file_path: str) -> List[Dict[str, Any]]:
+        """Process a single favorites or history file."""
+        try:
+            items = load_json_file(file_path)
+            if not items:
+                print(f"No {file_type} found in {file_path}")
+                return []
+            
+            print(f"\nProcessing {len(items):,} {file_type} entries...")
+            
+            # Find matching songs for each item
+            processed_items = []
+            updated_count = 0
+            
+            for i, item in enumerate(items):
+                if not isinstance(item, dict):
+                    print(f"Warning: Skipping invalid {file_type} item at index {i}")
+                    continue
+                
+                artist = item.get('artist', '')
+                title = item.get('title', '')
+                current_path = item.get('path', '')
+                
+                if not artist or not title:
+                    print(f"Warning: Skipping {file_type} item with missing artist/title at index {i}")
+                    continue
+                
+                # Find all matching songs for this artist/title
+                matching_songs = []
+                for song in all_songs:
+                    if (song.get('artist', '').lower().strip() == artist.lower().strip() and 
+                        song.get('title', '').lower().strip() == title.lower().strip()):
+                        matching_songs.append(song)
+                
+                if not matching_songs:
+                    print(f"Warning: No matching songs found for {artist} - {title}")
+                    processed_items.append(item)
+                    continue
+                
+                # Use the same priority logic as duplicates
+                best_song, skip_songs = matcher.select_best_song(matching_songs, artist, title)
+                
+                if best_song and best_song['path'] != current_path:
+                    # Update the path to the best version
+                    item['path'] = best_song['path']
+                    item['original_path'] = current_path  # Keep track of the original
+                    updated_count += 1
+                    if args.verbose:
+                        print(f"Updated {artist} - {title}: {current_path} → {best_song['path']}")
+                
+                processed_items.append(item)
+            
+            # Save the updated file
+            if not args.dry_run:
+                save_json_file(processed_items, file_path)
+                print(f"✅ Updated {updated_count:,} {file_type} entries with best versions")
+                print(f"📁 Saved to: {file_path}")
+            else:
+                print(f"DRY RUN: Would update {updated_count:,} {file_type} entries")
+            
+            return processed_items
+            
+        except Exception as e:
+            print(f"Error processing {file_type}: {e}")
+            return []
+    
+    # Process favorites if requested
+    if args.process_favorites:
+        favorites_path = os.path.join(data_dir, 'favorites.json')
+        if os.path.exists(favorites_path):
+            process_file('favorites', favorites_path)
+        else:
+            print(f"Favorites file not found: {favorites_path}")
+    
+    # Process history if requested
+    if args.process_history:
+        history_path = os.path.join(data_dir, 'history.json')
+        if os.path.exists(history_path):
+            process_file('history', history_path)
+        else:
+            print(f"History file not found: {history_path}")
+
+
 def parse_arguments():
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(
@@ -27,25 +213,31 @@ Examples:
   python main.py --config custom_config.json        # Use custom config
   python main.py --output-dir ./reports             # Save reports to custom directory
   python main.py --dry-run                          # Analyze without generating files
+  python main.py --process-favorites                # Process favorites with priority logic (MP4 over MP3)
+  python main.py --process-history                  # Process history with priority logic (MP4 over MP4)
+  python main.py --process-all                      # Process everything: duplicates, generate reports, AND update favorites/history with priority logic
+  python main.py --process-all --dry-run            # Preview changes without saving
+  python main.py --merge-history                    # Merge history objects that match on artist, title, and path
+  python main.py --merge-history --dry-run          # Preview history merging without saving
         """
     )
     
     parser.add_argument(
         '--config', 
-        default='config/config.json',
-        help='Path to configuration file (default: config/config.json)'
+        default='../config/config.json',
+        help='Path to configuration file (default: ../config/config.json)'
     )
     
     parser.add_argument(
         '--input', 
-        default='data/allSongs.json',
-        help='Path to input songs file (default: data/allSongs.json)'
+        default='../data/allSongs.json',
+        help='Path to input songs file (default: ../data/allSongs.json)'
     )
     
     parser.add_argument(
         '--output-dir', 
-        default='data',
-        help='Directory for output files (default: data)'
+        default='../data',
+        help='Directory for output files (default: ../data)'
     )
     
     parser.add_argument(
@@ -72,6 +264,30 @@ Examples:
         help='Show current configuration and exit'
     )
     
+    parser.add_argument(
+        '--process-favorites',
+        action='store_true',
+        help='Process favorites with priority-based logic to select best versions (MP4 over MP3)'
+    )
+    
+    parser.add_argument(
+        '--process-history',
+        action='store_true',
+        help='Process history with priority-based logic to select best versions (MP4 over MP3)'
+    )
+    
+    parser.add_argument(
+        '--process-all',
+        action='store_true',
+        help='Process everything: duplicates, generate reports, AND update favorites/history with priority logic'
+    )
+    
+    parser.add_argument(
+        '--merge-history',
+        action='store_true',
+        help='Merge history objects that match on artist, title, and path, summing their count properties'
+    )
+    
     return parser.parse_args()
 
 
@@ -119,137 +335,172 @@ def main():
         reporter.print_report("config", config)
         return
     
-    # Load songs
-    songs = load_songs(args.input)
-    
-    # Initialize components
+    # Load songs (only if needed for processing)
     data_dir = args.output_dir
-    matcher = SongMatcher(config, data_dir)
-    reporter = ReportGenerator(config)
+    songs = None
+    matcher = None
+    reporter = None
     
-    print("\nStarting song analysis...")
-    print("=" * 60)
+    if not args.merge_history:
+        songs = load_songs(args.input)
+        matcher = SongMatcher(config, data_dir)
+        reporter = ReportGenerator(config)
     
-    # Process songs
-    try:
-        best_songs, skip_songs, stats = matcher.process_songs(songs)
+    # Process favorites and history if requested
+    if args.process_favorites or args.process_history or args.process_all:
+        print("\n🎯 Processing favorites and history with priority logic...")
+        print("=" * 60)
         
-        # Generate reports
+        # If --process-all is used, set both flags
+        if args.process_all:
+            args.process_favorites = True
+            args.process_history = True
+        
+        process_favorites_and_history(matcher, songs, data_dir, args)
         print("\n" + "=" * 60)
-        reporter.print_report("summary", stats)
+        print("Favorites/History processing complete!")
         
-        # Add channel priority report
-        if config.get('channel_priorities'):
-            channel_report = reporter.generate_channel_priority_report(stats, config['channel_priorities'])
-            print("\n" + channel_report)
+        # If --process-all, also do the full duplicate analysis and reporting
+        if args.process_all:
+            print("\n🔄 Processing duplicates and generating reports...")
+            print("=" * 60)
+        else:
+            return
+    
+    # Merge history objects if requested (separate operation)
+    if args.merge_history:
+        print("\n🔄 Merging history objects...")
+        print("=" * 60)
+        merge_history_objects(data_dir, args)
+        print("\n" + "=" * 60)
+        print("History merging complete!")
+        return
+    
+    # If not processing favorites/history OR if --process-all, do the full analysis
+    if not (args.process_favorites or args.process_history) or args.process_all:
+        print("\nStarting song analysis...")
+        print("=" * 60)
         
-        if config['output']['verbose']:
-            duplicate_info = matcher.get_detailed_duplicate_info(songs)
-            reporter.print_report("duplicates", duplicate_info)
-        
-        reporter.print_report("skip_summary", skip_songs)
-        
-        # Save skip list if not dry run
-        if not args.dry_run and skip_songs:
-            skip_list_path = os.path.join(args.output_dir, 'skipSongs.json')
+        # Process songs
+        try:
+            best_songs, skip_songs, stats = matcher.process_songs(songs)
             
-            # Create simplified skip list (just paths and reasons) with deduplication
-            seen_paths = set()
-            simple_skip_list = []
-            duplicate_count = 0
+            # Generate reports
+            print("\n" + "=" * 60)
+            reporter.print_report("summary", stats)
             
-            for skip_song in skip_songs:
-                path = skip_song['path']
-                if path not in seen_paths:
-                    seen_paths.add(path)
-                    skip_entry = {'path': path}
-                    if config['output']['include_reasons']:
-                        skip_entry['reason'] = skip_song['reason']
-                    simple_skip_list.append(skip_entry)
-                else:
-                    duplicate_count += 1
+            # Add channel priority report
+            if config.get('channel_priorities'):
+                channel_report = reporter.generate_channel_priority_report(stats, config['channel_priorities'])
+                print("\n" + channel_report)
             
-            save_json_file(simple_skip_list, skip_list_path)
-            print(f"\nSkip list saved to: {skip_list_path}")
-            print(f"Total songs to skip: {len(simple_skip_list):,}")
-            if duplicate_count > 0:
-                print(f"Removed {duplicate_count:,} duplicate entries from skip list")
-        elif args.dry_run:
-            print("\nDRY RUN MODE: No skip list generated")
-        
-        # Always generate detailed reports (not just when --save-reports is used)
-        if not args.dry_run:
-            reports_dir = os.path.join(args.output_dir, 'reports')
-            os.makedirs(reports_dir, exist_ok=True)
-            
-            print(f"\n📊 Generating enhanced analysis reports...")
-            
-            # Analyze skip patterns
-            skip_analysis = reporter.analyze_skip_patterns(skip_songs)
-            
-            # Analyze channel optimization
-            channel_analysis = reporter.analyze_channel_optimization(stats, skip_analysis)
-            
-            # Generate and save enhanced reports
-            enhanced_summary = reporter.generate_enhanced_summary_report(stats, skip_analysis)
-            reporter.save_report_to_file(enhanced_summary, os.path.join(reports_dir, 'enhanced_summary_report.txt'))
-            
-            channel_optimization = reporter.generate_channel_optimization_report(channel_analysis)
-            reporter.save_report_to_file(channel_optimization, os.path.join(reports_dir, 'channel_optimization_report.txt'))
-            
-            duplicate_patterns = reporter.generate_duplicate_pattern_report(skip_analysis)
-            reporter.save_report_to_file(duplicate_patterns, os.path.join(reports_dir, 'duplicate_pattern_report.txt'))
-            
-            actionable_insights = reporter.generate_actionable_insights_report(stats, skip_analysis, channel_analysis)
-            reporter.save_report_to_file(actionable_insights, os.path.join(reports_dir, 'actionable_insights_report.txt'))
-            
-            # Generate detailed duplicate analysis
-            detailed_duplicates = reporter.generate_detailed_duplicate_analysis(skip_songs, best_songs)
-            reporter.save_report_to_file(detailed_duplicates, os.path.join(reports_dir, 'detailed_duplicate_analysis.txt'))
-            
-            # Save original reports for compatibility
-            summary_report = reporter.generate_summary_report(stats)
-            reporter.save_report_to_file(summary_report, os.path.join(reports_dir, 'summary_report.txt'))
-            
-            skip_report = reporter.generate_skip_list_summary(skip_songs)
-            reporter.save_report_to_file(skip_report, os.path.join(reports_dir, 'skip_list_summary.txt'))
-            
-            # Save detailed duplicate report if verbose
             if config['output']['verbose']:
                 duplicate_info = matcher.get_detailed_duplicate_info(songs)
-                duplicate_report = reporter.generate_duplicate_details(duplicate_info)
-                reporter.save_report_to_file(duplicate_report, os.path.join(reports_dir, 'duplicate_details.txt'))
+                reporter.print_report("duplicates", duplicate_info)
             
-            # Save analysis data as JSON for further processing
-            analysis_data = {
-                'stats': stats,
-                'skip_analysis': skip_analysis,
-                'channel_analysis': channel_analysis,
-                'timestamp': __import__('datetime').datetime.now().isoformat()
-            }
-            save_json_file(analysis_data, os.path.join(reports_dir, 'analysis_data.json'))
+            reporter.print_report("skip_summary", skip_songs)
             
-            # Save full skip list data (this is what the web UI needs)
-            save_json_file(skip_songs, os.path.join(reports_dir, 'skip_songs_detailed.json'))
+            # Save skip list if not dry run
+            if not args.dry_run and skip_songs:
+                skip_list_path = os.path.join(args.output_dir, 'skipSongs.json')
+                
+                # Create simplified skip list (just paths and reasons) with deduplication
+                seen_paths = set()
+                simple_skip_list = []
+                duplicate_count = 0
+                
+                for skip_song in skip_songs:
+                    path = skip_song['path']
+                    if path not in seen_paths:
+                        seen_paths.add(path)
+                        skip_entry = {'path': path}
+                        if config['output']['include_reasons']:
+                            skip_entry['reason'] = skip_song['reason']
+                        simple_skip_list.append(skip_entry)
+                    else:
+                        duplicate_count += 1
+                
+                save_json_file(simple_skip_list, skip_list_path)
+                print(f"\nSkip list saved to: {skip_list_path}")
+                print(f"Total songs to skip: {len(simple_skip_list):,}")
+                if duplicate_count > 0:
+                    print(f"Removed {duplicate_count:,} duplicate entries from skip list")
+            elif args.dry_run:
+                print("\nDRY RUN MODE: No skip list generated")
             
-            print(f"✅ Enhanced reports saved to: {reports_dir}")
-            print(f"📋 Generated reports:")
-            print(f"   • enhanced_summary_report.txt - Comprehensive analysis")
-            print(f"   • channel_optimization_report.txt - Priority optimization suggestions")
-            print(f"   • duplicate_pattern_report.txt - Duplicate pattern analysis")
-            print(f"   • actionable_insights_report.txt - Recommendations and insights")
-            print(f"   • detailed_duplicate_analysis.txt - Specific songs and their duplicates")
-            print(f"   • analysis_data.json - Raw analysis data for further processing")
-            print(f"   • skip_songs_detailed.json - Web UI data (always generated)")
-        elif args.dry_run:
-            print("\nDRY RUN MODE: No reports generated")
-        
-        print("\n" + "=" * 60)
-        print("Analysis complete!")
-        
-    except Exception as e:
-        print(f"\nError during processing: {e}")
-        sys.exit(1)
+            # Always generate detailed reports (not just when --save-reports is used)
+            if not args.dry_run:
+                reports_dir = os.path.join(args.output_dir, 'reports')
+                os.makedirs(reports_dir, exist_ok=True)
+                
+                print(f"\n📊 Generating enhanced analysis reports...")
+                
+                # Analyze skip patterns
+                skip_analysis = reporter.analyze_skip_patterns(skip_songs)
+                
+                # Analyze channel optimization
+                channel_analysis = reporter.analyze_channel_optimization(stats, skip_analysis)
+                
+                # Generate and save enhanced reports
+                enhanced_summary = reporter.generate_enhanced_summary_report(stats, skip_analysis)
+                reporter.save_report_to_file(enhanced_summary, os.path.join(reports_dir, 'enhanced_summary_report.txt'))
+                
+                channel_optimization = reporter.generate_channel_optimization_report(channel_analysis)
+                reporter.save_report_to_file(channel_optimization, os.path.join(reports_dir, 'channel_optimization_report.txt'))
+                
+                duplicate_patterns = reporter.generate_duplicate_pattern_report(skip_analysis)
+                reporter.save_report_to_file(duplicate_patterns, os.path.join(reports_dir, 'duplicate_pattern_report.txt'))
+                
+                actionable_insights = reporter.generate_actionable_insights_report(stats, skip_analysis, channel_analysis)
+                reporter.save_report_to_file(actionable_insights, os.path.join(reports_dir, 'actionable_insights_report.txt'))
+                
+                # Generate detailed duplicate analysis
+                detailed_duplicates = reporter.generate_detailed_duplicate_analysis(skip_songs, best_songs)
+                reporter.save_report_to_file(detailed_duplicates, os.path.join(reports_dir, 'detailed_duplicate_analysis.txt'))
+                
+                # Save original reports for compatibility
+                summary_report = reporter.generate_summary_report(stats)
+                reporter.save_report_to_file(summary_report, os.path.join(reports_dir, 'summary_report.txt'))
+                
+                skip_report = reporter.generate_skip_list_summary(skip_songs)
+                reporter.save_report_to_file(skip_report, os.path.join(reports_dir, 'skip_list_summary.txt'))
+                
+                # Save detailed duplicate report if verbose
+                if config['output']['verbose']:
+                    duplicate_info = matcher.get_detailed_duplicate_info(songs)
+                    duplicate_report = reporter.generate_duplicate_details(duplicate_info)
+                    reporter.save_report_to_file(duplicate_report, os.path.join(reports_dir, 'duplicate_details.txt'))
+                
+                # Save analysis data as JSON for further processing
+                analysis_data = {
+                    'stats': stats,
+                    'skip_analysis': skip_analysis,
+                    'channel_analysis': channel_analysis,
+                    'timestamp': __import__('datetime').datetime.now().isoformat()
+                }
+                save_json_file(analysis_data, os.path.join(reports_dir, 'analysis_data.json'))
+                
+                # Save full skip list data (this is what the web UI needs)
+                save_json_file(skip_songs, os.path.join(reports_dir, 'skip_songs_detailed.json'))
+                
+                print(f"✅ Enhanced reports saved to: {reports_dir}")
+                print(f"📋 Generated reports:")
+                print(f"   • enhanced_summary_report.txt - Comprehensive analysis")
+                print(f"   • channel_optimization_report.txt - Priority optimization suggestions")
+                print(f"   • duplicate_pattern_report.txt - Duplicate pattern analysis")
+                print(f"   • actionable_insights_report.txt - Recommendations and insights")
+                print(f"   • detailed_duplicate_analysis.txt - Specific songs and their duplicates")
+                print(f"   • analysis_data.json - Raw analysis data for further processing")
+                print(f"   • skip_songs_detailed.json - Web UI data (always generated)")
+            elif args.dry_run:
+                print("\nDRY RUN MODE: No reports generated")
+            
+            print("\n" + "=" * 60)
+            print("Analysis complete!")
+            
+        except Exception as e:
+            print(f"\nError during processing: {e}")
+            sys.exit(1)
 
 
 if __name__ == "__main__":
diff --git a/cli/playlist_validator.py b/cli/playlist_validator.py
new file mode 100644
index 0000000..c5de831
--- /dev/null
+++ b/cli/playlist_validator.py
@@ -0,0 +1,344 @@
+#!/usr/bin/env python3
+"""
+Playlist validation module for the Karaoke Song Library Cleanup Tool.
+Validates playlist songs against the song library using exact and fuzzy matching.
+"""
+
+import json
+import os
+from typing import Dict, List, Any, Tuple, Optional
+from collections import defaultdict
+import difflib
+
+try:
+    from fuzzywuzzy import fuzz
+    FUZZY_AVAILABLE = True
+except ImportError:
+    FUZZY_AVAILABLE = False
+
+from utils import (
+    normalize_artist_title,
+    extract_channel_from_path,
+    get_file_extension,
+    parse_multi_artist,
+    validate_song_data
+)
+
+from matching import SongMatcher
+
+
+class PlaylistValidator:
+    """Validates playlist songs against the song library."""
+    
+    def __init__(self, config: Dict[str, Any], data_dir: str = "../data"):
+        self.config = config
+        self.data_dir = data_dir
+        self.song_matcher = SongMatcher(config, data_dir)
+        self.fuzzy_threshold = config.get('matching', {}).get('fuzzy_threshold', 0.8)
+        
+        # Load song library
+        self.all_songs = self._load_all_songs()
+        if not self.all_songs:
+            raise ValueError("Could not load song library from allSongs.json")
+        
+        # Create lookup dictionaries for faster matching
+        self._build_lookup_tables()
+    
+    def _load_all_songs(self) -> List[Dict[str, Any]]:
+        """Load the song library from allSongs.json."""
+        all_songs_path = os.path.join(self.data_dir, 'allSongs.json')
+        try:
+            with open(all_songs_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Error loading song library: {e}")
+            return []
+    
+    def _build_lookup_tables(self):
+        """Build lookup tables for faster exact matching."""
+        self.exact_lookup = {}
+        self.artist_title_lookup = {}
+        
+        for song in self.all_songs:
+            if not validate_song_data(song):
+                continue
+            
+            # Handle multi-artist songs
+            artists = parse_multi_artist(song['artist'])
+            if not artists:
+                artists = [song['artist']]
+            
+            # Create exact match keys
+            for artist in artists:
+                normalized_key = normalize_artist_title(artist, song['title'], False)
+                if normalized_key not in self.exact_lookup:
+                    self.exact_lookup[normalized_key] = []
+                self.exact_lookup[normalized_key].append(song)
+                
+                # Also store by artist-title for fuzzy matching
+                artist_title_key = f"{artist.lower()} - {song['title'].lower()}"
+                if artist_title_key not in self.artist_title_lookup:
+                    self.artist_title_lookup[artist_title_key] = []
+                self.artist_title_lookup[artist_title_key].append(song)
+    
+    def find_exact_match(self, artist: str, title: str) -> Optional[List[Dict[str, Any]]]:
+        """Find exact matches for artist/title combination."""
+        normalized_key = normalize_artist_title(artist, title, False)
+        return self.exact_lookup.get(normalized_key, [])
+    
+    def find_fuzzy_matches(self, artist: str, title: str, threshold: float = None) -> List[Tuple[Dict[str, Any], float]]:
+        """Find fuzzy matches for artist/title combination."""
+        if not FUZZY_AVAILABLE:
+            return []
+        
+        if threshold is None:
+            threshold = self.fuzzy_threshold
+        
+        query = f"{artist.lower()} - {title.lower()}"
+        matches = []
+        
+        for key, songs in self.artist_title_lookup.items():
+            similarity = fuzz.ratio(query, key) / 100.0
+            if similarity >= threshold:
+                # Get the best song from this group using existing priority logic
+                best_song, _ = self.song_matcher.select_best_song(songs, artist, title)
+                matches.append((best_song, similarity))
+        
+        # Sort by similarity score (highest first)
+        matches.sort(key=lambda x: x[1], reverse=True)
+        return matches
+    
+    def validate_playlist(self, playlist: Dict[str, Any], dry_run: bool = True) -> Dict[str, Any]:
+        """Validate a single playlist against the song library."""
+        results = {
+            'playlist_title': playlist.get('title', 'Unknown Playlist'),
+            'total_songs': len(playlist.get('songs', [])),
+            'exact_matches': [],
+            'fuzzy_matches': [],
+            'missing_songs': [],
+            'summary': {
+                'exact_match_count': 0,
+                'fuzzy_match_count': 0,
+                'missing_count': 0,
+                'needs_manual_review': 0
+            }
+        }
+        
+        for song in playlist.get('songs', []):
+            artist = song.get('artist', '')
+            title = song.get('title', '')
+            position = song.get('position', 0)
+            
+            if not artist or not title:
+                results['missing_songs'].append({
+                    'position': position,
+                    'artist': artist,
+                    'title': title,
+                    'reason': 'Missing artist or title'
+                })
+                results['summary']['missing_count'] += 1
+                continue
+            
+            # Try exact match first
+            exact_matches = self.find_exact_match(artist, title)
+            
+            if exact_matches:
+                # Get the best song using existing priority logic
+                best_song, _ = self.song_matcher.select_best_song(exact_matches, artist, title)
+                
+                results['exact_matches'].append({
+                    'position': position,
+                    'playlist_artist': artist,
+                    'playlist_title': title,
+                    'found_song': best_song,
+                    'match_type': 'exact'
+                })
+                results['summary']['exact_match_count'] += 1
+                
+            else:
+                # Try fuzzy matching
+                fuzzy_matches = self.find_fuzzy_matches(artist, title)
+                
+                if fuzzy_matches:
+                    best_fuzzy_song, similarity = fuzzy_matches[0]
+                    
+                    results['fuzzy_matches'].append({
+                        'position': position,
+                        'playlist_artist': artist,
+                        'playlist_title': title,
+                        'found_song': best_fuzzy_song,
+                        'similarity': similarity,
+                        'match_type': 'fuzzy',
+                        'needs_manual_review': True
+                    })
+                    results['summary']['fuzzy_match_count'] += 1
+                    results['summary']['needs_manual_review'] += 1
+                    
+                else:
+                    results['missing_songs'].append({
+                        'position': position,
+                        'artist': artist,
+                        'title': title,
+                        'reason': 'No matches found'
+                    })
+                    results['summary']['missing_count'] += 1
+        
+        return results
+    
+    def validate_all_playlists(self, dry_run: bool = True) -> Dict[str, Any]:
+        """Validate all playlists in songLists.json."""
+        playlists_path = os.path.join(self.data_dir, 'songLists.json')
+        
+        try:
+            with open(playlists_path, 'r', encoding='utf-8') as f:
+                playlists = json.load(f)
+        except Exception as e:
+            print(f"Error loading playlists: {e}")
+            return {}
+        
+        all_results = {
+            'total_playlists': len(playlists),
+            'playlist_results': [],
+            'overall_summary': {
+                'total_songs': 0,
+                'exact_matches': 0,
+                'fuzzy_matches': 0,
+                'missing_songs': 0,
+                'needs_manual_review': 0
+            }
+        }
+        
+        for playlist in playlists:
+            result = self.validate_playlist(playlist, dry_run)
+            all_results['playlist_results'].append(result)
+            
+            # Update overall summary
+            summary = result['summary']
+            all_results['overall_summary']['total_songs'] += result['total_songs']
+            all_results['overall_summary']['exact_matches'] += summary['exact_match_count']
+            all_results['overall_summary']['fuzzy_matches'] += summary['fuzzy_match_count']
+            all_results['overall_summary']['missing_songs'] += summary['missing_count']
+            all_results['overall_summary']['needs_manual_review'] += summary['needs_manual_review']
+        
+        return all_results
+    
+    def update_playlist_song(self, playlist_index: int, song_position: int, 
+                           new_artist: str, new_title: str, dry_run: bool = True) -> bool:
+        """Update a playlist song with corrected artist/title."""
+        playlists_path = os.path.join(self.data_dir, 'songLists.json')
+        
+        try:
+            with open(playlists_path, 'r', encoding='utf-8') as f:
+                playlists = json.load(f)
+        except Exception as e:
+            print(f"Error loading playlists: {e}")
+            return False
+        
+        if playlist_index >= len(playlists):
+            print(f"Invalid playlist index: {playlist_index}")
+            return False
+        
+        playlist = playlists[playlist_index]
+        songs = playlist.get('songs', [])
+        
+        # Find the song by position
+        for song in songs:
+            if song.get('position') == song_position:
+                if dry_run:
+                    print(f"DRY RUN: Would update playlist '{playlist['title']}' song {song_position}")
+                    print(f"  From: {song['artist']} - {song['title']}")
+                    print(f"  To:   {new_artist} - {new_title}")
+                else:
+                    song['artist'] = new_artist
+                    song['title'] = new_title
+                    
+                    # Save the updated playlists
+                    try:
+                        with open(playlists_path, 'w', encoding='utf-8') as f:
+                            json.dump(playlists, f, indent=2, ensure_ascii=False)
+                        print(f"Updated playlist '{playlist['title']}' song {song_position}")
+                        return True
+                    except Exception as e:
+                        print(f"Error saving playlists: {e}")
+                        return False
+                break
+        else:
+            print(f"Song with position {song_position} not found in playlist")
+            return False
+        
+        return True
+
+
+def main():
+    """Main function for CLI usage."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Validate playlists against song library')
+    parser.add_argument('--config', default='../config/config.json', help='Configuration file path')
+    parser.add_argument('--data-dir', default='../data', help='Data directory path')
+    parser.add_argument('--dry-run', action='store_true', default=True, help='Dry run mode (default)')
+    parser.add_argument('--apply', action='store_true', help='Apply changes (disable dry run)')
+    parser.add_argument('--playlist-index', type=int, help='Validate specific playlist by index')
+    parser.add_argument('--output', help='Output results to JSON file')
+    
+    args = parser.parse_args()
+    
+    # Load configuration
+    try:
+        with open(args.config, 'r') as f:
+            config = json.load(f)
+    except Exception as e:
+        print(f"Error loading config: {e}")
+        return
+    
+    # Create validator
+    validator = PlaylistValidator(config, args.data_dir)
+    
+    # Determine dry run mode
+    dry_run = not args.apply
+    
+    if args.playlist_index is not None:
+        # Validate specific playlist
+        playlists_path = os.path.join(args.data_dir, 'songLists.json')
+        try:
+            with open(playlists_path, 'r', encoding='utf-8') as f:
+                playlists = json.load(f)
+        except Exception as e:
+            print(f"Error loading playlists: {e}")
+            return
+        
+        if args.playlist_index >= len(playlists):
+            print(f"Invalid playlist index: {args.playlist_index}")
+            return
+        
+        result = validator.validate_playlist(playlists[args.playlist_index], dry_run)
+        print(f"\nPlaylist: {result['playlist_title']}")
+        print(f"Total songs: {result['total_songs']}")
+        print(f"Exact matches: {result['summary']['exact_match_count']}")
+        print(f"Fuzzy matches: {result['summary']['fuzzy_match_count']}")
+        print(f"Missing: {result['summary']['missing_count']}")
+        print(f"Need manual review: {result['summary']['needs_manual_review']}")
+        
+    else:
+        # Validate all playlists
+        results = validator.validate_all_playlists(dry_run)
+        
+        print(f"\nPlaylist Validation Results:")
+        print(f"Total playlists: {results['total_playlists']}")
+        print(f"Total songs: {results['overall_summary']['total_songs']}")
+        print(f"Exact matches: {results['overall_summary']['exact_matches']}")
+        print(f"Fuzzy matches: {results['overall_summary']['fuzzy_matches']}")
+        print(f"Missing: {results['overall_summary']['missing_songs']}")
+        print(f"Need manual review: {results['overall_summary']['needs_manual_review']}")
+        
+        if args.output:
+            try:
+                with open(args.output, 'w', encoding='utf-8') as f:
+                    json.dump(results, f, indent=2, ensure_ascii=False)
+                print(f"\nResults saved to: {args.output}")
+            except Exception as e:
+                print(f"Error saving results: {e}")
+
+
+if __name__ == '__main__':
+    main() 
\ No newline at end of file
diff --git a/web/app.py b/web/app.py
index 5330d85..b248d1e 100644
--- a/web/app.py
+++ b/web/app.py
@@ -10,6 +10,11 @@ import os
 from typing import Dict, List, Any
 from datetime import datetime
 
+# Import playlist validator
+import sys
+sys.path.append('../cli')
+from playlist_validator import PlaylistValidator
+
 app = Flask(__name__)
 
 # Configuration
@@ -178,7 +183,7 @@ def normalize_path(file_path: str) -> str:
         
         # Simple fix: replace :// with :\
         fixed_path = file_path.replace('://', ':\\')
-        print(f"DEBUG: Fixed path (simple :// to :\ conversion): {fixed_path}")
+        print(f"DEBUG: Fixed path (simple :// to :\\ conversion): {fixed_path}")
         return fixed_path
     
     # If no :// corruption detected, return the path as-is
@@ -196,6 +201,16 @@ def remaining_songs():
     """Page showing remaining songs after cleanup."""
     return render_template('remaining_songs.html')
 
+@app.route('/favorites')
+def favorites():
+    """Page showing favorites with matching songs."""
+    return render_template('favorites.html')
+
+@app.route('/history')
+def history():
+    """Page showing history with matching songs."""
+    return render_template('history.html')
+
 @app.route('/api/duplicates')
 def get_duplicates():
     """API endpoint to get duplicate data."""
@@ -230,23 +245,59 @@ def get_duplicates():
         if channel_filter or file_type_filter:
             matches_filter = False
             
-            # Check kept version
-            kept_channel = extract_channel(group['kept_version'])
-            kept_file_type = get_file_type(group['kept_version'])
-            if (not channel_filter or channel_filter in kept_channel.lower()) and \
-               (not file_type_filter or file_type_filter in kept_file_type.lower()):
-                matches_filter = True
-            
-            # Check skipped versions if kept version doesn't match
-            if not matches_filter:
+            # Special handling for mp3-only filter
+            if file_type_filter == 'mp3-only':
+                # Check if kept version is MP3 and there are no MP4 alternatives
+                kept_file_type = get_file_type(group['kept_version'])
+                has_mp4_alternative = False
+                
+                # Check if any skipped version is MP4
                 for version in group['skipped_versions']:
-                    if (not channel_filter or channel_filter in version['channel'].lower()) and \
-                       (not file_type_filter or file_type_filter in version['file_type'].lower()):
-                        matches_filter = True
+                    if version['file_type'].upper() == 'MP4':
+                        has_mp4_alternative = True
                         break
-            
-            if not matches_filter:
-                continue
+                
+                # Only show if kept version is MP3 and no MP4 alternatives exist
+                if kept_file_type.upper() != 'MP3' or has_mp4_alternative:
+                    continue
+                
+                # Apply channel filter if specified
+                if channel_filter:
+                    kept_channel = extract_channel(group['kept_version'])
+                    if channel_filter not in kept_channel.lower():
+                        continue
+            elif file_type_filter == 'mp3':
+                # Special handling for MP3 filter - show songs where primary is MP3 and has alternatives
+                kept_file_type = get_file_type(group['kept_version'])
+                
+                # Only show if kept version is MP3 and there are alternatives
+                if kept_file_type.upper() != 'MP3' or len(group['skipped_versions']) == 0:
+                    continue
+                
+                # Apply channel filter if specified
+                if channel_filter:
+                    kept_channel = extract_channel(group['kept_version'])
+                    if channel_filter not in kept_channel.lower():
+                        continue
+            else:
+                # Regular file type and channel filtering
+                # Check kept version
+                kept_channel = extract_channel(group['kept_version'])
+                kept_file_type = get_file_type(group['kept_version'])
+                if (not channel_filter or channel_filter in kept_channel.lower()) and \
+                   (not file_type_filter or file_type_filter in kept_file_type.lower()):
+                    matches_filter = True
+                
+                # Check skipped versions if kept version doesn't match
+                if not matches_filter:
+                    for version in group['skipped_versions']:
+                        if (not channel_filter or channel_filter in version['channel'].lower()) and \
+                           (not file_type_filter or file_type_filter in version['file_type'].lower()):
+                            matches_filter = True
+                            break
+                
+                if not matches_filter:
+                    continue
         
         filtered_groups.append(group)
     
@@ -644,6 +695,491 @@ def load_priority_preferences():
     except Exception as e:
         return jsonify({'error': f'Error loading priority preferences: {str(e)}'}), 500
 
+def find_matching_songs(item: Dict[str, Any], all_songs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Find all songs from allSongs.json that match a given item (favorite/history)."""
+    matching_songs = []
+    
+    # Validate input
+    if item is None or not isinstance(item, dict):
+        print(f"Warning: Invalid item passed to find_matching_songs: {item}")
+        return matching_songs
+    
+    item_artist = item.get('artist', '').lower().strip()
+    item_title = item.get('title', '').lower().strip()
+    
+    for song in all_songs:
+        # Skip None songs
+        if song is None or not isinstance(song, dict):
+            continue
+            
+        song_artist = song.get('artist', '').lower().strip()
+        song_title = song.get('title', '').lower().strip()
+        
+        # Exact match on artist and title
+        if song_artist == item_artist and song_title == item_title:
+            matching_songs.append({
+                'path': song.get('path', ''),
+                'artist': song.get('artist', 'Unknown'),
+                'title': song.get('title', 'Unknown'),
+                'file_type': get_file_type(song.get('path', '')),
+                'channel': extract_channel(song.get('path', '')),
+                'is_current': song.get('path', '') == item.get('path', '')
+            })
+    
+    # Sort by priority: current path first, then by file type priority
+    def sort_key(song):
+        # Current path gets highest priority
+        if song['is_current']:
+            return (0, 0)
+        
+        # File type priority: MP4 > CDG/MP3 > standalone MP3 > standalone CDG
+        file_type_priority = {
+            'MP4': 1,
+            'MP3': 2,
+            'Unknown': 3
+        }
+        return (1, file_type_priority.get(song['file_type'], 3))
+    
+    matching_songs.sort(key=sort_key)
+    return matching_songs
+
+@app.route('/api/favorites')
+def get_favorites():
+    """Get favorites data with matching songs for each favorite."""
+    try:
+        # Load data files
+        favorites_file = os.path.join(DATA_DIR, 'favorites.json')
+        all_songs_file = os.path.join(DATA_DIR, 'allSongs.json')
+        
+        favorites = load_json_file(favorites_file)
+        all_songs = load_json_file(all_songs_file)
+        
+        if not favorites or not all_songs:
+            return jsonify({'error': 'Failed to load data files'}), 500
+        
+        # Process each favorite
+        processed_favorites = []
+        for i, favorite in enumerate(favorites):
+            # Skip None items or items without required fields
+            if favorite is None:
+                print(f"Warning: Skipping None item at index {i} in favorites")
+                continue
+                
+            if not isinstance(favorite, dict):
+                print(f"Warning: Skipping non-dict item at index {i} in favorites: {type(favorite)}")
+                continue
+            
+            try:
+                matching_songs = find_matching_songs(favorite, all_songs)
+                
+                processed_favorite = {
+                    'index': i,
+                    'original': favorite,
+                    'matching_songs': matching_songs,
+                    'artist': favorite.get('artist', 'Unknown'),
+                    'title': favorite.get('title', 'Unknown'),
+                    'current_path': favorite.get('path', ''),
+                    'count': favorite.get('count', 0),
+                    'favorite': favorite.get('favorite', False),
+                    'disabled': favorite.get('disabled', False)
+                }
+                processed_favorites.append(processed_favorite)
+            except Exception as item_error:
+                print(f"Error processing favorite item {i}: {item_error}")
+                print(f"Item data: {favorite}")
+                continue
+        
+        # Sort by artist, then by title
+        processed_favorites.sort(key=lambda x: (x['artist'].lower(), x['title'].lower()))
+        
+        return jsonify({
+            'success': True,
+            'favorites': processed_favorites,
+            'total': len(processed_favorites)
+        })
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/history')
+def get_history():
+    """Get history data with matching songs for each history item."""
+    try:
+        # Load data files
+        history_file = os.path.join(DATA_DIR, 'history.json')
+        all_songs_file = os.path.join(DATA_DIR, 'allSongs.json')
+        
+        history = load_json_file(history_file)
+        all_songs = load_json_file(all_songs_file)
+        
+        if not history or not all_songs:
+            return jsonify({'error': 'Failed to load data files'}), 500
+        
+        # Process each history item
+        processed_history = []
+        for i, item in enumerate(history):
+            # Skip None items or items without required fields
+            if item is None:
+                print(f"Warning: Skipping None item at index {i} in history")
+                continue
+                
+            if not isinstance(item, dict):
+                print(f"Warning: Skipping non-dict item at index {i} in history: {type(item)}")
+                continue
+            
+            try:
+                matching_songs = find_matching_songs(item, all_songs)
+                
+                processed_item = {
+                    'index': i,
+                    'original': item,
+                    'matching_songs': matching_songs,
+                    'artist': item.get('artist', 'Unknown'),
+                    'title': item.get('title', 'Unknown'),
+                    'current_path': item.get('path', ''),
+                    'count': item.get('count', 0),
+                    'favorite': item.get('favorite', False),
+                    'disabled': item.get('disabled', False)
+                }
+                processed_history.append(processed_item)
+            except Exception as item_error:
+                print(f"Error processing history item {i}: {item_error}")
+                print(f"Item data: {item}")
+                continue
+        
+        # Sort by artist, then by title
+        processed_history.sort(key=lambda x: (x['artist'].lower(), x['title'].lower()))
+        
+        return jsonify({
+            'success': True,
+            'history': processed_history,
+            'total': len(processed_history)
+        })
+    except Exception as e:
+        print(f"Error in get_history: {e}")
+        import traceback
+        print(f"Full traceback: {traceback.format_exc()}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/update-favorite-path', methods=['POST'])
+def update_favorite_path():
+    """Update the path of a favorite item."""
+    try:
+        data = request.get_json()
+        favorite_index = data.get('index')
+        new_path = data.get('path')
+        
+        if favorite_index is None or new_path is None:
+            return jsonify({'success': False, 'error': 'Missing index or path'}), 400
+        
+        # Load favorites file
+        favorites_file = os.path.join(DATA_DIR, 'favorites.json')
+        favorites = load_json_file(favorites_file)
+        
+        if not favorites or favorite_index >= len(favorites):
+            return jsonify({'success': False, 'error': 'Invalid favorite index'}), 400
+        
+        # Update the path
+        favorites[favorite_index]['path'] = new_path
+        
+        # Save back to file
+        with open(favorites_file, 'w', encoding='utf-8') as f:
+            json.dump(favorites, f, indent=2, ensure_ascii=False)
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/update-history-path', methods=['POST'])
+def update_history_path():
+    """Update the path of a history item."""
+    try:
+        data = request.get_json()
+        history_index = data.get('index')
+        new_path = data.get('path')
+        
+        if history_index is None or new_path is None:
+            return jsonify({'success': False, 'error': 'Missing index or path'}), 400
+        
+        # Load history file
+        history_file = os.path.join(DATA_DIR, 'history.json')
+        history = load_json_file(history_file)
+        
+        if not history or history_index >= len(history):
+            return jsonify({'success': False, 'error': 'Invalid history index'}), 400
+        
+        # Update the path
+        history[history_index]['path'] = new_path
+        
+        # Save back to file
+        with open(history_file, 'w', encoding='utf-8') as f:
+            json.dump(history, f, indent=2, ensure_ascii=False)
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/api/update-favorite-property', methods=['POST'])
+def update_favorite_property():
+    """Update any property of a favorite item."""
+    try:
+        data = request.get_json()
+        index = data.get('index')
+        property_name = data.get('property')
+        new_value = data.get('value')
+        
+        if index is None or property_name is None or new_value is None:
+            return jsonify({'success': False, 'error': 'Missing index, property, or value'}), 400
+        
+        # Load current favorites
+        favorites_file = os.path.join(DATA_DIR, 'favorites.json')
+        if not os.path.exists(favorites_file):
+            return jsonify({'success': False, 'error': 'Favorites file not found'}), 404
+        
+        with open(favorites_file, 'r', encoding='utf-8') as f:
+            favorites = json.load(f)
+        
+        # Update the property
+        if 0 <= index < len(favorites):
+            favorites[index][property_name] = new_value
+            # Special handling for path updates
+            if property_name == 'path' and 'original_path' in favorites[index]:
+                # Update original_path if it matches the old path
+                if favorites[index]['original_path'] == favorites[index].get('path'):
+                    favorites[index]['original_path'] = new_value
+            
+            # Save updated favorites
+            with open(favorites_file, 'w', encoding='utf-8') as f:
+                json.dump(favorites, f, indent=2, ensure_ascii=False)
+            
+            return jsonify({'success': True})
+        else:
+            return jsonify({'success': False, 'error': 'Invalid index'}), 400
+            
+    except Exception as e:
+        print(f"Error updating favorite property: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/api/update-history-property', methods=['POST'])
+def update_history_property():
+    """Update any property of a history item."""
+    try:
+        data = request.get_json()
+        index = data.get('index')
+        property_name = data.get('property')
+        new_value = data.get('value')
+        
+        if index is None or property_name is None or new_value is None:
+            return jsonify({'success': False, 'error': 'Missing index, property, or value'}), 400
+        
+        # Load current history
+        history_file = os.path.join(DATA_DIR, 'history.json')
+        if not os.path.exists(history_file):
+            return jsonify({'success': False, 'error': 'History file not found'}), 404
+        
+        with open(history_file, 'r', encoding='utf-8') as f:
+            history = json.load(f)
+        
+        # Update the property
+        if 0 <= index < len(history):
+            history[index][property_name] = new_value
+            # Special handling for path updates
+            if property_name == 'path' and 'original_path' in history[index]:
+                # Update original_path if it matches the old path
+                if history[index]['original_path'] == history[index].get('path'):
+                    history[index]['original_path'] = new_value
+            
+            # Save updated history
+            with open(history_file, 'w', encoding='utf-8') as f:
+                json.dump(history, f, indent=2, ensure_ascii=False)
+            
+            return jsonify({'success': True})
+        else:
+            return jsonify({'success': False, 'error': 'Invalid index'}), 400
+            
+    except Exception as e:
+        print(f"Error updating history property: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/api/delete-favorite', methods=['POST'])
+def delete_favorite():
+    """Delete a favorite item by index."""
+    try:
+        data = request.get_json()
+        index = data.get('index')
+        
+        if index is None:
+            return jsonify({'success': False, 'error': 'Missing index'}), 400
+        
+        # Load current favorites
+        favorites_file = os.path.join(DATA_DIR, 'favorites.json')
+        if not os.path.exists(favorites_file):
+            return jsonify({'success': False, 'error': 'Favorites file not found'}), 404
+        
+        with open(favorites_file, 'r', encoding='utf-8') as f:
+            favorites = json.load(f)
+        
+        # Delete the item at the specified index
+        if 0 <= index < len(favorites):
+            deleted_item = favorites.pop(index)
+            
+            # Save updated favorites
+            with open(favorites_file, 'w', encoding='utf-8') as f:
+                json.dump(favorites, f, indent=2, ensure_ascii=False)
+            
+            return jsonify({
+                'success': True, 
+                'deleted_item': deleted_item,
+                'message': f'Deleted "{deleted_item.get("artist", "Unknown")} - {deleted_item.get("title", "Unknown")}"'
+            })
+        else:
+            return jsonify({'success': False, 'error': 'Invalid index'}), 400
+            
+    except Exception as e:
+        print(f"Error deleting favorite: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/api/delete-history', methods=['POST'])
+def delete_history():
+    """Delete a history item by index."""
+    try:
+        data = request.get_json()
+        index = data.get('index')
+        
+        if index is None:
+            return jsonify({'success': False, 'error': 'Missing index'}), 400
+        
+        # Load current history
+        history_file = os.path.join(DATA_DIR, 'history.json')
+        if not os.path.exists(history_file):
+            return jsonify({'success': False, 'error': 'History file not found'}), 404
+        
+        with open(history_file, 'r', encoding='utf-8') as f:
+            history = json.load(f)
+        
+        # Delete the item at the specified index
+        if 0 <= index < len(history):
+            deleted_item = history.pop(index)
+            
+            # Save updated history
+            with open(history_file, 'w', encoding='utf-8') as f:
+                json.dump(history, f, indent=2, ensure_ascii=False)
+            
+            return jsonify({
+                'success': True, 
+                'deleted_item': deleted_item,
+                'message': f'Deleted "{deleted_item.get("artist", "Unknown")} - {deleted_item.get("title", "Unknown")}"'
+            })
+        else:
+            return jsonify({'success': False, 'error': 'Invalid index'}), 400
+            
+    except Exception as e:
+        print(f"Error deleting history item: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/api/merge-history', methods=['POST'])
+def merge_history():
+    """Merge history objects that match on artist, title, and path, summing their count properties."""
+    try:
+        # Load current history
+        history_file = os.path.join(DATA_DIR, 'history.json')
+        if not os.path.exists(history_file):
+            return jsonify({'success': False, 'error': 'History file not found'}), 404
+        
+        with open(history_file, 'r', encoding='utf-8') as f:
+            history_items = json.load(f)
+        
+        if not history_items:
+            return jsonify({'success': False, 'error': 'No history items found to merge'}), 400
+        
+        # Create a dictionary to group items by artist, title, and path
+        grouped_items = {}
+        merged_count = 0
+        total_merged_entries = 0
+        
+        for item in history_items:
+            if not isinstance(item, dict):
+                continue
+                
+            artist = item.get('artist', '').strip()
+            title = item.get('title', '').strip()
+            path = item.get('path', '').strip()
+            
+            if not artist or not title or not path:
+                continue
+            
+            # Create a key for grouping
+            key = (artist.lower(), title.lower(), path.lower())
+            
+            if key not in grouped_items:
+                grouped_items[key] = []
+            grouped_items[key].append(item)
+        
+        # Process groups with multiple items
+        merged_items = []
+        
+        for key, items in grouped_items.items():
+            if len(items) == 1:
+                # Single item, keep as is
+                merged_items.append(items[0])
+            else:
+                # Multiple items, merge them
+                artist, title, path = key
+                
+                # Start with the first item as the base
+                merged_item = items[0].copy()
+                
+                # Sum the counts (handle both int and string values)
+                total_count = 0
+                for item in items:
+                    count_value = item.get('count', 0)
+                    if isinstance(count_value, str):
+                        try:
+                            total_count += int(count_value)
+                        except ValueError:
+                            total_count += 0
+                    else:
+                        total_count += count_value
+                merged_item['count'] = total_count
+                
+                # For boolean properties, if any are True, keep True
+                merged_item['favorite'] = any(item.get('favorite', False) for item in items)
+                merged_item['disabled'] = any(item.get('disabled', False) for item in items)
+                
+                # For other properties, keep the first non-empty value
+                for prop in ['key', 'original_path', 'genre']:
+                    if prop in merged_item and merged_item[prop]:
+                        continue
+                    for item in items[1:]:  # Skip first item since we already have it
+                        if item.get(prop):
+                            merged_item[prop] = item[prop]
+                            break
+                
+                merged_items.append(merged_item)
+                merged_count += 1
+                total_merged_entries += len(items)
+        
+        # Save the merged history
+        with open(history_file, 'w', encoding='utf-8') as f:
+            json.dump(merged_items, f, indent=2, ensure_ascii=False)
+        
+        return jsonify({
+            'success': True,
+            'merged_groups': merged_count,
+            'total_merged_entries': total_merged_entries,
+            'final_count': len(merged_items),
+            'message': f'Successfully merged {merged_count} groups ({total_merged_entries} total entries → {len(merged_items)} entries)'
+        })
+        
+    except Exception as e:
+        print(f"Error merging history objects: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
 @app.route('/api/video/<path:file_path>')
 def serve_video(file_path):
     """Serve video files for playback in the web UI."""
@@ -746,5 +1282,171 @@ def serve_video(file_path):
         print(f"DEBUG: Full traceback: {traceback.format_exc()}")
         return jsonify({'error': f'Error serving video: {str(e)}'}), 500
 
+
+# Playlist Validation Endpoints
+
+@app.route('/playlist-validation')
+def playlist_validation():
+    """Playlist validation page."""
+    return render_template('playlist_validation.html')
+
+
+@app.route('/api/playlists')
+def get_playlists():
+    """Get list of all playlists."""
+    try:
+        playlists_path = os.path.join(DATA_DIR, 'songLists.json')
+        with open(playlists_path, 'r', encoding='utf-8') as f:
+            playlists = json.load(f)
+        
+        # Return basic playlist info
+        playlist_list = []
+        for i, playlist in enumerate(playlists):
+            playlist_list.append({
+                'index': i,
+                'title': playlist.get('title', 'Unknown Playlist'),
+                'song_count': len(playlist.get('songs', []))
+            })
+        
+        return jsonify(playlist_list)
+    except Exception as e:
+        return jsonify({'error': f'Error loading playlists: {str(e)}'}), 500
+
+
+@app.route('/api/validate-playlist/<int:playlist_index>')
+def validate_playlist(playlist_index):
+    """Validate a specific playlist."""
+    try:
+        # Load configuration
+        config = load_json_file(CONFIG_FILE)
+        if not config:
+            return jsonify({'error': 'Could not load configuration'}), 500
+        
+        # Create validator
+        validator = PlaylistValidator(config, DATA_DIR)
+        
+        # Load playlists
+        playlists_path = os.path.join(DATA_DIR, 'songLists.json')
+        with open(playlists_path, 'r', encoding='utf-8') as f:
+            playlists = json.load(f)
+        
+        if playlist_index >= len(playlists):
+            return jsonify({'error': f'Invalid playlist index: {playlist_index}'}), 400
+        
+        # Validate the playlist
+        result = validator.validate_playlist(playlists[playlist_index], dry_run=True)
+        
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'error': f'Error validating playlist: {str(e)}'}), 500
+
+
+@app.route('/api/validate-all-playlists')
+def validate_all_playlists():
+    """Validate all playlists."""
+    try:
+        # Load configuration
+        config = load_json_file(CONFIG_FILE)
+        if not config:
+            return jsonify({'error': 'Could not load configuration'}), 500
+        
+        # Create validator
+        validator = PlaylistValidator(config, DATA_DIR)
+        
+        # Validate all playlists
+        results = validator.validate_all_playlists(dry_run=True)
+        
+        return jsonify(results)
+    except Exception as e:
+        return jsonify({'error': f'Error validating playlists: {str(e)}'}), 500
+
+
+@app.route('/api/update-playlist-song', methods=['POST'])
+def update_playlist_song():
+    """Update a playlist song with corrected artist/title."""
+    try:
+        data = request.get_json()
+        playlist_index = data.get('playlist_index')
+        song_position = data.get('song_position')
+        new_artist = data.get('new_artist')
+        new_title = data.get('new_title')
+        dry_run = data.get('dry_run', True)
+        
+        if any(x is None for x in [playlist_index, song_position, new_artist, new_title]):
+            return jsonify({'error': 'Missing required parameters'}), 400
+        
+        # Load configuration
+        config = load_json_file(CONFIG_FILE)
+        if not config:
+            return jsonify({'error': 'Could not load configuration'}), 500
+        
+        # Create validator
+        validator = PlaylistValidator(config, DATA_DIR)
+        
+        # Update the song
+        success = validator.update_playlist_song(
+            playlist_index, song_position, new_artist, new_title, dry_run
+        )
+        
+        if success:
+            return jsonify({'success': True, 'message': 'Playlist song updated successfully'})
+        else:
+            return jsonify({'error': 'Failed to update playlist song'}), 500
+            
+    except Exception as e:
+        return jsonify({'error': f'Error updating playlist song: {str(e)}'}), 500
+
+
+@app.route('/api/apply-all-updates', methods=['POST'])
+def apply_all_updates():
+    """Apply all pending playlist updates in batch."""
+    try:
+        data = request.get_json()
+        changes = data.get('changes', [])
+        
+        if not changes:
+            return jsonify({'error': 'No changes to apply'}), 400
+        
+        # Load configuration
+        config = load_json_file(CONFIG_FILE)
+        if not config:
+            return jsonify({'error': 'Could not load configuration'}), 500
+        
+        # Create validator
+        validator = PlaylistValidator(config, DATA_DIR)
+        
+        # Apply all changes
+        success_count = 0
+        failed_count = 0
+        
+        for change in changes:
+            success = validator.update_playlist_song(
+                change['playlistIndex'], 
+                change['songPosition'], 
+                change['newArtist'], 
+                change['newTitle'], 
+                False  # Always apply changes (not dry run)
+            )
+            if success:
+                success_count += 1
+            else:
+                failed_count += 1
+        
+        if failed_count == 0:
+            message = f'Successfully applied {success_count} changes to playlists.'
+        else:
+            message = f'Applied {success_count} changes, {failed_count} failed.'
+        
+        return jsonify({
+            'success': True, 
+            'message': message,
+            'applied': success_count,
+            'failed': failed_count
+        })
+            
+    except Exception as e:
+        return jsonify({'error': f'Error applying updates: {str(e)}'}), 500
+
+
 if __name__ == '__main__':
     app.run(debug=True, host='0.0.0.0', port=5000) 
\ No newline at end of file
diff --git a/web/templates/favorites.html b/web/templates/favorites.html
new file mode 100644
index 0000000..935d9cb
--- /dev/null
+++ b/web/templates/favorites.html
@@ -0,0 +1,1000 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Karaoke Favorites - Web UI</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/sortablejs@1.15.0/Sortable.min.js"></script>
+    <script>
+        // Fallback for Sortable.js if CDN fails
+        if (typeof Sortable === 'undefined') {
+            console.warn('Primary Sortable.js CDN failed, trying fallback...');
+            const script = document.createElement('script');
+            script.src = 'https://cdnjs.cloudflare.com/ajax/libs/Sortable/1.15.0/Sortable.min.js';
+            script.onload = function() {
+                console.log('Sortable.js loaded from fallback CDN');
+            };
+            script.onerror = function() {
+                console.error('Both Sortable.js CDNs failed to load');
+                alert('Warning: Sortable.js library failed to load. Drag and drop functionality will not work.');
+            };
+            document.head.appendChild(script);
+        }
+    </script>
+    <style>
+        .favorite-card {
+            border-left: 4px solid #ffc107;
+            margin-bottom: 1rem;
+        }
+        .current-version {
+            background-color: #d4edda;
+            border-left: 4px solid #28a745;
+        }
+        .alternative-version {
+            background-color: #f8f9fa;
+            border-left: 4px solid #6c757d;
+        }
+        .file-type-badge {
+            font-size: 0.75rem;
+        }
+        .channel-badge {
+            font-size: 0.8rem;
+        }
+        .stats-card {
+            background: linear-gradient(135deg, #ffc107 0%, #fd7e14 100%);
+            color: white;
+        }
+        .file-type-card {
+            transition: transform 0.2s;
+        }
+        .file-type-card:hover {
+            transform: translateY(-2px);
+        }
+        .metric-highlight {
+            font-weight: bold;
+            color: #28a745;
+        }
+        .metric-warning {
+            font-weight: bold;
+            color: #dc3545;
+        }
+        .filter-section {
+            background-color: #f8f9fa;
+            border-radius: 8px;
+            padding: 1rem;
+            margin-bottom: 1rem;
+        }
+        .loading {
+            text-align: center;
+            padding: 2rem;
+        }
+        .pagination-info {
+            font-size: 0.9rem;
+            color: #6c757d;
+        }
+        .path-text {
+            font-family: 'Courier New', monospace;
+            font-size: 0.85rem;
+            word-break: break-all;
+        }
+        
+        /* Drag and Drop Styles */
+        .sortable-list {
+            min-height: 50px;
+        }
+        .sortable-item {
+            cursor: grab;
+            transition: all 0.2s ease;
+        }
+        .sortable-item:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        }
+        .sortable-item:active {
+            cursor: grabbing;
+        }
+        .sortable-ghost {
+            opacity: 0.5;
+            background-color: #e9ecef;
+        }
+        .sortable-chosen {
+            background-color: #fff3cd;
+        }
+        
+        /* Navigation */
+        .nav-link {
+            color: #6c757d;
+        }
+        .nav-link.active {
+            color: #ffc107;
+            font-weight: bold;
+        }
+        
+        /* Video Modal */
+        .video-modal .modal-dialog {
+            max-width: 90vw;
+        }
+        .video-modal .modal-body {
+            padding: 0;
+        }
+        .video-container {
+            position: relative;
+            width: 100%;
+            height: 0;
+            padding-bottom: 56.25%; /* 16:9 aspect ratio */
+        }
+        .video-container video {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+        }
+        
+        /* Inline Editing Styles */
+        .editable-field {
+            cursor: pointer;
+            border: 1px solid transparent;
+            padding: 2px 4px;
+            border-radius: 3px;
+            transition: all 0.2s ease;
+        }
+        .editable-field:hover {
+            border-color: #007bff;
+            background-color: #f8f9fa;
+        }
+        .editable-field.editing {
+            border-color: #007bff;
+            background-color: #fff;
+            box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);
+        }
+        .edit-input {
+            width: 100%;
+            border: 1px solid #007bff;
+            border-radius: 3px;
+            padding: 2px 4px;
+            font-size: inherit;
+            font-family: inherit;
+        }
+        .edit-buttons {
+            display: flex;
+            gap: 5px;
+            margin-top: 5px;
+        }
+        .edit-btn {
+            padding: 2px 8px;
+            font-size: 0.8rem;
+            border-radius: 3px;
+        }
+        .property-label {
+            font-weight: bold;
+            color: #495057;
+            font-size: 0.9rem;
+        }
+        .property-value {
+            font-size: 0.9rem;
+        }
+        .boolean-toggle {
+            cursor: pointer;
+            padding: 2px 8px;
+            border-radius: 3px;
+            font-size: 0.8rem;
+            transition: all 0.2s ease;
+        }
+        .boolean-toggle.true {
+            background-color: #28a745;
+            color: white;
+        }
+        .boolean-toggle.false {
+            background-color: #6c757d;
+            color: white;
+        }
+        .boolean-toggle:hover {
+            opacity: 0.8;
+        }
+    </style>
+</head>
+<body>
+    <!-- Navigation -->
+    <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
+        <div class="container-fluid">
+            <a class="navbar-brand" href="/">
+                <i class="fas fa-music"></i> Karaoke Manager
+            </a>
+            <div class="navbar-nav">
+                <a class="nav-link" href="/">
+                    <i class="fas fa-copy"></i> Duplicates
+                </a>
+                <a class="nav-link active" href="/favorites">
+                    <i class="fas fa-heart"></i> Favorites
+                </a>
+                <a class="nav-link" href="/history">
+                    <i class="fas fa-history"></i> History
+                </a>
+                <a class="nav-link" href="/remaining-songs">
+                    <i class="fas fa-list"></i> Remaining Songs
+                </a>
+            </div>
+        </div>
+    </nav>
+
+    <div class="container-fluid mt-3">
+        <!-- Header -->
+        <div class="row mb-3">
+            <div class="col">
+                <h1><i class="fas fa-heart text-warning"></i> Favorites Management</h1>
+                <p class="text-muted">Review and manage your favorite songs with alternative versions</p>
+            </div>
+        </div>
+
+        <!-- Statistics Cards -->
+        <div class="row mb-3" id="statsRow">
+            <div class="col-md-3">
+                <div class="card stats-card">
+                    <div class="card-body text-center">
+                        <h5 class="card-title">Total Favorites</h5>
+                        <h3 id="totalFavorites">-</h3>
+                    </div>
+                </div>
+            </div>
+            <div class="col-md-3">
+                <div class="card stats-card">
+                    <div class="card-body text-center">
+                        <h5 class="card-title">With Alternatives</h5>
+                        <h3 id="withAlternatives">-</h3>
+                    </div>
+                </div>
+            </div>
+            <div class="col-md-3">
+                <div class="card stats-card">
+                    <div class="card-body text-center">
+                        <h5 class="card-title">MP4 Versions</h5>
+                        <h3 id="mp4Versions">-</h3>
+                    </div>
+                </div>
+            </div>
+            <div class="col-md-3">
+                <div class="card stats-card">
+                    <div class="card-body text-center">
+                        <h5 class="card-title">MP3 Versions</h5>
+                        <h3 id="mp3Versions">-</h3>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Filters -->
+        <div class="filter-section">
+            <div class="row">
+                <div class="col-md-3">
+                    <label for="artistFilter" class="form-label">Artist Filter</label>
+                    <input type="text" class="form-control" id="artistFilter" placeholder="Filter by artist...">
+                </div>
+                <div class="col-md-3">
+                    <label for="titleFilter" class="form-label">Title Filter</label>
+                    <input type="text" class="form-control" id="titleFilter" placeholder="Filter by title...">
+                </div>
+                <div class="col-md-2">
+                    <label for="fileTypeFilter" class="form-label">File Type</label>
+                    <select class="form-select" id="fileTypeFilter">
+                        <option value="">All Types</option>
+                        <option value="MP4">MP4</option>
+                        <option value="MP3">MP3</option>
+                        <option value="MP3-only">MP3 Only (No MP4 Alternative)</option>
+                    </select>
+                </div>
+                <div class="col-md-2">
+                    <label for="channelFilter" class="form-label">Channel</label>
+                    <input type="text" class="form-control" id="channelFilter" placeholder="Filter by channel...">
+                </div>
+                <div class="col-md-2">
+                    <label for="minAlternatives" class="form-label">Min Alternatives</label>
+                    <input type="number" class="form-control" id="minAlternatives" value="0" min="0">
+                </div>
+            </div>
+            <div class="row mt-2">
+                <div class="col">
+                    <button class="btn btn-primary" onclick="applyFilters()">
+                        <i class="fas fa-filter"></i> Apply Filters
+                    </button>
+                    <button class="btn btn-secondary" onclick="clearFilters()">
+                        <i class="fas fa-times"></i> Clear Filters
+                    </button>
+                </div>
+            </div>
+        </div>
+
+        <!-- Loading -->
+        <div id="loading" class="loading">
+            <div class="spinner-border text-primary" role="status">
+                <span class="visually-hidden">Loading...</span>
+            </div>
+            <p class="mt-2">Loading favorites data...</p>
+        </div>
+
+        <!-- Favorites List -->
+        <div id="favoritesList" style="display: none;">
+            <!-- Favorites will be loaded here -->
+        </div>
+
+        <!-- Pagination -->
+        <div class="row mt-3">
+            <div class="col-md-6">
+                <div class="pagination-info" id="paginationInfo">
+                    Showing 0 of 0 favorites
+                </div>
+            </div>
+            <div class="col-md-6">
+                <nav aria-label="Favorites pagination">
+                    <ul class="pagination justify-content-end" id="pagination">
+                        <!-- Pagination will be generated here -->
+                    </ul>
+                </nav>
+            </div>
+        </div>
+    </div>
+
+    <!-- Video Modal -->
+    <div class="modal fade video-modal" id="videoModal" tabindex="-1">
+        <div class="modal-dialog modal-xl">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title" id="videoModalTitle">Video Preview</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <div class="video-container">
+                        <video id="videoPlayer" controls>
+                            Your browser does not support the video tag.
+                        </video>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Bootstrap JS -->
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
+    
+    <script>
+        let allFavorites = [];
+        let filteredFavorites = [];
+        let currentPage = 1;
+        const perPage = 20;
+        let pathChanges = {};
+        let editingField = null;
+
+        // Inline editing functions
+        function startEdit(index, property) {
+            // Cancel any existing edit
+            if (editingField) {
+                cancelEdit();
+            }
+            
+            const field = event.target;
+            const currentValue = field.textContent;
+            const isNumber = property === 'count';
+            
+            // Create input field
+            const input = document.createElement('input');
+            input.type = isNumber ? 'number' : 'text';
+            input.className = 'edit-input';
+            input.value = currentValue;
+            
+            // Create buttons
+            const buttonContainer = document.createElement('div');
+            buttonContainer.className = 'edit-buttons';
+            buttonContainer.innerHTML = `
+                <button class="btn btn-sm btn-success edit-btn" onclick="saveEdit(${index}, '${property}')">
+                    <i class="fas fa-check"></i> Save
+                </button>
+                <button class="btn btn-sm btn-secondary edit-btn" onclick="cancelEdit()">
+                    <i class="fas fa-times"></i> Cancel
+                </button>
+            `;
+            
+            // Replace field content
+            field.innerHTML = '';
+            field.appendChild(input);
+            field.appendChild(buttonContainer);
+            field.classList.add('editing');
+            
+            // Focus input
+            input.focus();
+            input.select();
+            
+            // Store reference
+            editingField = {
+                field: field,
+                input: input,
+                originalValue: currentValue,
+                index: index,
+                property: property
+            };
+            
+            // Handle Enter and Escape keys
+            input.addEventListener('keydown', function(e) {
+                if (e.key === 'Enter') {
+                    saveEdit(index, property);
+                } else if (e.key === 'Escape') {
+                    cancelEdit();
+                }
+            });
+        }
+        
+        function saveEdit(index, property) {
+            if (!editingField) return;
+            
+            const newValue = editingField.input.value;
+            const originalValue = editingField.originalValue;
+            
+            if (newValue === originalValue) {
+                cancelEdit();
+                return;
+            }
+            
+            // Update via API
+            updateFavoriteProperty(index, property, newValue);
+        }
+        
+        function cancelEdit() {
+            if (!editingField) return;
+            
+            const field = editingField.field;
+            const originalValue = editingField.originalValue;
+            
+            field.innerHTML = originalValue;
+            field.classList.remove('editing');
+            
+            editingField = null;
+        }
+        
+        async function updateFavoriteProperty(index, property, value) {
+            try {
+                const response = await fetch('/api/update-favorite-property', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ index, property, value })
+                });
+                
+                const data = await response.json();
+                if (data.success) {
+                    // Update local data
+                    const favorite = allFavorites.find(f => f.index === index);
+                    if (favorite) {
+                        favorite[property] = value;
+                    }
+                    
+                    // Update display
+                    if (editingField) {
+                        editingField.field.innerHTML = escapeHtml(value);
+                        editingField.field.classList.remove('editing');
+                        editingField = null;
+                    }
+                    
+                    showSuccess(`Updated ${property} successfully`);
+                } else {
+                    throw new Error(data.error || 'Failed to update property');
+                }
+            } catch (error) {
+                console.error('Error updating property:', error);
+                showError('Failed to update property: ' + error.message);
+                cancelEdit();
+            }
+        }
+        
+        function toggleBoolean(index, property) {
+            const favorite = allFavorites.find(f => f.index === index);
+            if (!favorite) return;
+            
+            const newValue = !favorite[property];
+            updateFavoriteProperty(index, property, newValue);
+        }
+
+        async function deleteFavorite(index) {
+            const favorite = allFavorites.find(f => f.index === index);
+            if (!favorite) return;
+            
+            const songName = `${favorite.artist} - ${favorite.title}`;
+            if (!confirm(`Are you sure you want to delete "${songName}" from favorites?`)) {
+                return;
+            }
+            
+            try {
+                const response = await fetch('/api/delete-favorite', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ index })
+                });
+                
+                const data = await response.json();
+                if (data.success) {
+                    // Remove from local arrays
+                    allFavorites = allFavorites.filter(f => f.index !== index);
+                    filteredFavorites = filteredFavorites.filter(f => f.index !== index);
+                    
+                    // Update display
+                    updateStats();
+                    displayFavorites();
+                    
+                    showSuccess(data.message || 'Favorite deleted successfully');
+                } else {
+                    throw new Error(data.error || 'Failed to delete favorite');
+                }
+            } catch (error) {
+                console.error('Error deleting favorite:', error);
+                showError('Failed to delete favorite: ' + error.message);
+            }
+        }
+
+        // Helper functions
+        function getFileType(path) {
+            const lower = path.toLowerCase();
+            if (lower.endsWith('.mp4')) return 'MP4';
+            if (lower.endsWith('.mp3')) return 'MP3';
+            if (lower.endsWith('.cdg')) return 'MP3';  // Treat CDG as MP3 since they're paired
+            return 'Unknown';
+        }
+
+        function extractChannel(path) {
+            const lower = path.toLowerCase();
+            const parts = path.split('\\');
+            
+            // Look for specific known channels first
+            const knownChannels = ['Sing King Karaoke', 'KaraFun Karaoke', 'Stingray Karaoke'];
+            for (const channel of knownChannels) {
+                if (lower.includes(channel.toLowerCase())) {
+                    return channel;
+                }
+            }
+            
+            // Look for MP4 folder structure: MP4/ChannelName/song.mp4
+            for (let i = 0; i < parts.length; i++) {
+                if (parts[i].toLowerCase() === 'mp4' && i < parts.length - 1) {
+                    // If MP4 is found, return the next folder (the actual channel)
+                    if (i + 1 < parts.length) {
+                        const nextPart = parts[i + 1];
+                        // Skip if the next part is the filename (no extension means it's a folder)
+                        if (nextPart.indexOf('.') === -1) {
+                            return nextPart;
+                        } else {
+                            return 'MP4 Root';  // File is directly in MP4 folder
+                        }
+                    } else {
+                        return 'MP4 Root';
+                    }
+                }
+            }
+            
+            // Look for any folder that contains 'karaoke' (fallback)
+            for (const part of parts) {
+                if (part.toLowerCase().includes('karaoke')) {
+                    return part;
+                }
+            }
+            
+            // If no specific channel found, return the folder containing the file
+            if (parts.length >= 2) {
+                const parentFolder = parts[parts.length - 2]; // Second to last part (folder containing the file)
+                // If parent folder is MP4, then file is in root
+                if (parentFolder.toLowerCase() === 'mp4') {
+                    return 'MP4 Root';
+                }
+                return parentFolder;
+            }
+            
+            return 'Unknown';
+        }
+
+        // Load favorites data
+        async function loadFavorites() {
+            try {
+                const response = await fetch('/api/favorites');
+                const data = await response.json();
+                
+                if (data.success) {
+                    allFavorites = data.favorites;
+                    filteredFavorites = [...allFavorites];
+                    updateStats();
+                    displayFavorites();
+                    hideLoading();
+                } else {
+                    throw new Error(data.error || 'Failed to load favorites');
+                }
+            } catch (error) {
+                console.error('Error loading favorites:', error);
+                hideLoading();
+                showError('Failed to load favorites: ' + error.message);
+            }
+        }
+
+        // Update statistics
+        function updateStats() {
+            const totalFavorites = allFavorites.length;
+            const withAlternatives = allFavorites.filter(f => f.matching_songs.length > 1).length;
+            const mp4Versions = allFavorites.reduce((count, f) => 
+                count + f.matching_songs.filter(s => s.file_type === 'MP4').length, 0);
+            const mp3Versions = allFavorites.reduce((count, f) => 
+                count + f.matching_songs.filter(s => s.file_type === 'MP3').length, 0);
+
+            document.getElementById('totalFavorites').textContent = totalFavorites;
+            document.getElementById('withAlternatives').textContent = withAlternatives;
+            document.getElementById('mp4Versions').textContent = mp4Versions;
+            document.getElementById('mp3Versions').textContent = mp3Versions;
+        }
+
+        // Display favorites
+        function displayFavorites() {
+            const startIndex = (currentPage - 1) * perPage;
+            const endIndex = startIndex + perPage;
+            const pageFavorites = filteredFavorites.slice(startIndex, endIndex);
+
+            const container = document.getElementById('favoritesList');
+            container.innerHTML = '';
+
+            pageFavorites.forEach(favorite => {
+                const card = createFavoriteCard(favorite);
+                container.appendChild(card);
+            });
+
+            updatePagination();
+            initializeSortable();
+        }
+
+        // Create favorite card
+        function createFavoriteCard(favorite) {
+            const card = document.createElement('div');
+            card.className = 'card favorite-card';
+            card.innerHTML = `
+                <div class="card-header">
+                    <div class="row align-items-center">
+                        <div class="col-md-6">
+                            <h5 class="mb-0">
+                                <i class="fas fa-heart text-warning"></i>
+                                <span class="editable-field" onclick="startEdit(${favorite.index}, 'artist')">${escapeHtml(favorite.artist)}</span> - 
+                                <span class="editable-field" onclick="startEdit(${favorite.index}, 'title')">${escapeHtml(favorite.title)}</span>
+                            </h5>
+                        </div>
+                        <div class="col-md-6 text-end">
+                            <button class="btn btn-sm btn-danger me-2" onclick="deleteFavorite(${favorite.index})" title="Delete this favorite">
+                                <i class="fas fa-trash"></i> Delete
+                            </button>
+                            <span class="badge bg-primary">${favorite.matching_songs.length} versions</span>
+                            <span class="boolean-toggle ${favorite.favorite ? 'true' : 'false'}" onclick="toggleBoolean(${favorite.index}, 'favorite')">
+                                ${favorite.favorite ? 'Favorite' : 'Not Favorite'}
+                            </span>
+                            <span class="boolean-toggle ${favorite.disabled ? 'true' : 'false'}" onclick="toggleBoolean(${favorite.index}, 'disabled')">
+                                ${favorite.disabled ? 'Disabled' : 'Enabled'}
+                            </span>
+                        </div>
+                    </div>
+                </div>
+                <div class="card-body">
+                    <div class="row">
+                        <div class="col-md-6">
+                            <h6>Properties:</h6>
+                            <div class="row">
+                                <div class="col-md-6">
+                                    <div class="mb-2">
+                                        <div class="property-label">Path:</div>
+                                        <div class="editable-field path-text" onclick="startEdit(${favorite.index}, 'path')">${escapeHtml(favorite.path)}</div>
+                                    </div>
+                                    ${favorite.original_path ? `
+                                        <div class="mb-2">
+                                            <div class="property-label">Original Path:</div>
+                                            <div class="editable-field path-text" onclick="startEdit(${favorite.index}, 'original_path')">${escapeHtml(favorite.original_path)}</div>
+                                        </div>
+                                    ` : ''}
+                                    ${favorite.key ? `
+                                        <div class="mb-2">
+                                            <div class="property-label">Key:</div>
+                                            <div class="editable-field" onclick="startEdit(${favorite.index}, 'key')">${escapeHtml(favorite.key)}</div>
+                                        </div>
+                                    ` : ''}
+                                </div>
+                                <div class="col-md-6">
+                                    ${favorite.count ? `
+                                        <div class="mb-2">
+                                            <div class="property-label">Count:</div>
+                                            <div class="editable-field" onclick="startEdit(${favorite.index}, 'count')">${favorite.count}</div>
+                                        </div>
+                                    ` : ''}
+                                    ${favorite.genre ? `
+                                        <div class="mb-2">
+                                            <div class="property-label">Genre:</div>
+                                            <div class="editable-field" onclick="startEdit(${favorite.index}, 'genre')">${escapeHtml(favorite.genre)}</div>
+                                        </div>
+                                    ` : ''}
+                                </div>
+                            </div>
+                        </div>
+                        <div class="col-md-6">
+                            <h6>Available Versions (drag to reorder):</h6>
+                            <div class="sortable-list" data-favorite-index="${favorite.index}">
+                                ${favorite.matching_songs.map((song, songIndex) => `
+                                    <div class="card sortable-item ${song.is_current ? 'current-version' : 'alternative-version'} mb-2" 
+                                         data-song-index="${songIndex}">
+                                        <div class="card-body py-2">
+                                            <div class="row align-items-center">
+                                                <div class="col-md-1">
+                                                    <i class="fas fa-grip-vertical text-muted"></i>
+                                                </div>
+                                                <div class="col-md-2">
+                                                    <span class="badge bg-${song.file_type === 'MP4' ? 'danger' : 'success'} file-type-badge">
+                                                        ${song.file_type}
+                                                    </span>
+                                                    ${song.channel ? `<span class="badge bg-info channel-badge ms-1">${song.channel}</span>` : ''}
+                                                </div>
+                                                <div class="col-md-7">
+                                                    <div class="path-text">${escapeHtml(song.path)}</div>
+                                                </div>
+                                                <div class="col-md-2 text-end">
+                                                    ${song.is_current ? '<span class="badge bg-success">Current</span>' : ''}
+                                                    ${song.file_type === 'MP4' ? 
+                                                        `<button class="btn btn-sm btn-outline-primary" onclick="playVideo('${song.path.replace(/\\/g, '\\\\')}')">
+                                                            <i class="fas fa-play"></i> Play
+                                                        </button>` : ''}
+                                                </div>
+                                            </div>
+                                        </div>
+                                    </div>
+                                `).join('')}
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            `;
+            return card;
+        }
+
+        // Initialize sortable for drag and drop
+        function initializeSortable() {
+            document.querySelectorAll('.sortable-list').forEach(list => {
+                new Sortable(list, {
+                    animation: 150,
+                    ghostClass: 'sortable-ghost',
+                    chosenClass: 'sortable-chosen',
+                    onEnd: function(evt) {
+                        const favoriteIndex = parseInt(evt.target.dataset.favoriteIndex);
+                        const newOrder = Array.from(evt.target.children).map((item, index) => ({
+                            songIndex: parseInt(item.dataset.songIndex),
+                            newIndex: index
+                        }));
+                        
+                        // Update the favorite's path to the first song in the list
+                        const firstSong = newOrder[0];
+                        const favorite = allFavorites.find(f => f.index === favoriteIndex);
+                        if (favorite && favorite.matching_songs[firstSong.songIndex]) {
+                            const newPath = favorite.matching_songs[firstSong.songIndex].path;
+                            updateFavoritePath(favoriteIndex, newPath);
+                        }
+                    }
+                });
+            });
+        }
+
+        // Update favorite path
+        async function updateFavoritePath(index, newPath) {
+            try {
+                const response = await fetch('/api/update-favorite-path', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ index, path: newPath })
+                });
+
+                const data = await response.json();
+                if (data.success) {
+                    // Update local data
+                    const favorite = allFavorites.find(f => f.index === index);
+                    if (favorite) {
+                        favorite.current_path = newPath;
+                        // Update is_current flags
+                        favorite.matching_songs.forEach(song => {
+                            song.is_current = song.path === newPath;
+                        });
+                    }
+                    showSuccess('Favorite path updated successfully');
+                } else {
+                    throw new Error(data.error || 'Failed to update path');
+                }
+            } catch (error) {
+                console.error('Error updating favorite path:', error);
+                showError('Failed to update favorite path: ' + error.message);
+            }
+        }
+
+        // Apply filters
+        function applyFilters() {
+            const artistFilter = document.getElementById('artistFilter').value.toLowerCase();
+            const titleFilter = document.getElementById('titleFilter').value.toLowerCase();
+            const fileTypeFilter = document.getElementById('fileTypeFilter').value.toLowerCase();
+            const channelFilter = document.getElementById('channelFilter').value.toLowerCase();
+            const minAlternatives = parseInt(document.getElementById('minAlternatives').value) || 0;
+
+            filteredFavorites = allFavorites.filter(favorite => {
+                // Artist filter
+                if (artistFilter && !favorite.artist.toLowerCase().includes(artistFilter)) {
+                    return false;
+                }
+
+                // Title filter
+                if (titleFilter && !favorite.title.toLowerCase().includes(titleFilter)) {
+                    return false;
+                }
+
+                // Min alternatives filter
+                if (favorite.matching_songs.length < minAlternatives) {
+                    return false;
+                }
+
+                // File type and channel filters
+                if (fileTypeFilter || channelFilter) {
+                    let hasMatchingSong = false;
+                    
+                    // Special handling for MP3-only filter
+                    if (fileTypeFilter === 'mp3-only') {
+                        // Check if current favorite is MP3 and has no MP4 alternatives
+                        const currentFileType = getFileType(favorite.current_path);
+                        const hasMp4Alternative = favorite.matching_songs.some(song => 
+                            song.file_type.toUpperCase() === 'MP4'
+                        );
+                        
+                        if (currentFileType.toUpperCase() === 'MP3' && !hasMp4Alternative) {
+                            // Apply channel filter if specified
+                            if (channelFilter) {
+                                const currentChannel = extractChannel(favorite.current_path);
+                                hasMatchingSong = currentChannel.toLowerCase().includes(channelFilter);
+                            } else {
+                                hasMatchingSong = true;
+                            }
+                        }
+                    } else if (fileTypeFilter === 'mp3') {
+                        // Special handling for MP3 filter - show songs where primary is MP3 and has alternatives
+                        const currentFileType = getFileType(favorite.current_path);
+                        
+                        // Only show if current favorite is MP3 and has alternatives
+                        if (currentFileType.toUpperCase() === 'MP3' && favorite.matching_songs.length > 0) {
+                            // Apply channel filter if specified
+                            if (channelFilter) {
+                                const currentChannel = extractChannel(favorite.current_path);
+                                hasMatchingSong = currentChannel.toLowerCase().includes(channelFilter);
+                            } else {
+                                hasMatchingSong = true;
+                            }
+                        }
+                    } else {
+                        // Regular file type and channel filtering
+                        hasMatchingSong = favorite.matching_songs.some(song => {
+                            const matchesFileType = !fileTypeFilter || song.file_type.toLowerCase().includes(fileTypeFilter);
+                            const matchesChannel = !channelFilter || (song.channel && song.channel.toLowerCase().includes(channelFilter));
+                            return matchesFileType && matchesChannel;
+                        });
+                    }
+                    
+                    if (!hasMatchingSong) {
+                        return false;
+                    }
+                }
+
+                return true;
+            });
+
+            currentPage = 1;
+            displayFavorites();
+        }
+
+        // Clear filters
+        function clearFilters() {
+            document.getElementById('artistFilter').value = '';
+            document.getElementById('titleFilter').value = '';
+            document.getElementById('fileTypeFilter').value = '';
+            document.getElementById('channelFilter').value = '';
+            document.getElementById('minAlternatives').value = '0';
+            
+            filteredFavorites = [...allFavorites];
+            currentPage = 1;
+            displayFavorites();
+        }
+
+        // Update pagination
+        function updatePagination() {
+            const totalPages = Math.ceil(filteredFavorites.length / perPage);
+            const startItem = (currentPage - 1) * perPage + 1;
+            const endItem = Math.min(currentPage * perPage, filteredFavorites.length);
+
+            document.getElementById('paginationInfo').textContent = 
+                `Showing ${startItem}-${endItem} of ${filteredFavorites.length} favorites`;
+
+            const pagination = document.getElementById('pagination');
+            pagination.innerHTML = '';
+
+            // Previous button
+            const prevLi = document.createElement('li');
+            prevLi.className = `page-item ${currentPage === 1 ? 'disabled' : ''}`;
+            prevLi.innerHTML = `<a class="page-link" href="#" onclick="changePage(${currentPage - 1})">Previous</a>`;
+            pagination.appendChild(prevLi);
+
+            // Page numbers
+            for (let i = 1; i <= totalPages; i++) {
+                if (i === 1 || i === totalPages || (i >= currentPage - 2 && i <= currentPage + 2)) {
+                    const li = document.createElement('li');
+                    li.className = `page-item ${i === currentPage ? 'active' : ''}`;
+                    li.innerHTML = `<a class="page-link" href="#" onclick="changePage(${i})">${i}</a>`;
+                    pagination.appendChild(li);
+                } else if (i === currentPage - 3 || i === currentPage + 3) {
+                    const li = document.createElement('li');
+                    li.className = 'page-item disabled';
+                    li.innerHTML = '<span class="page-link">...</span>';
+                    pagination.appendChild(li);
+                }
+            }
+
+            // Next button
+            const nextLi = document.createElement('li');
+            nextLi.className = `page-item ${currentPage === totalPages ? 'disabled' : ''}`;
+            nextLi.innerHTML = `<a class="page-link" href="#" onclick="changePage(${currentPage + 1})">Next</a>`;
+            pagination.appendChild(nextLi);
+        }
+
+        // Change page
+        function changePage(page) {
+            const totalPages = Math.ceil(filteredFavorites.length / perPage);
+            if (page >= 1 && page <= totalPages) {
+                currentPage = page;
+                displayFavorites();
+            }
+        }
+
+        // Play video
+        function playVideo(path) {
+            const videoPlayer = document.getElementById('videoPlayer');
+            const modal = new bootstrap.Modal(document.getElementById('videoModal'));
+            
+            videoPlayer.src = `/api/video/${encodeURIComponent(path)}`;
+            document.getElementById('videoModalTitle').textContent = `Video Preview: ${path.split('\\').pop()}`;
+            
+            modal.show();
+        }
+
+        // Utility functions
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+
+        function showLoading() {
+            document.getElementById('loading').style.display = 'block';
+            document.getElementById('favoritesList').style.display = 'none';
+        }
+
+        function hideLoading() {
+            document.getElementById('loading').style.display = 'none';
+            document.getElementById('favoritesList').style.display = 'block';
+        }
+
+        function showError(message) {
+            alert('Error: ' + message);
+        }
+
+        function showSuccess(message) {
+            // You could implement a toast notification here
+            console.log('Success: ' + message);
+        }
+
+        // Initialize on page load
+        document.addEventListener('DOMContentLoaded', function() {
+            showLoading();
+            loadFavorites();
+        });
+    </script>
+</body>
+</html> 
\ No newline at end of file
diff --git a/web/templates/history.html b/web/templates/history.html
new file mode 100644
index 0000000..a582e0f
--- /dev/null
+++ b/web/templates/history.html
@@ -0,0 +1,1047 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Karaoke History - Web UI</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/sortablejs@1.15.0/Sortable.min.js"></script>
+    <script>
+        // Fallback for Sortable.js if CDN fails
+        if (typeof Sortable === 'undefined') {
+            console.warn('Primary Sortable.js CDN failed, trying fallback...');
+            const script = document.createElement('script');
+            script.src = 'https://cdnjs.cloudflare.com/ajax/libs/Sortable/1.15.0/Sortable.min.js';
+            script.onload = function() {
+                console.log('Sortable.js loaded from fallback CDN');
+            };
+            script.onerror = function() {
+                console.error('Both Sortable.js CDNs failed to load');
+                alert('Warning: Sortable.js library failed to load. Drag and drop functionality will not work.');
+            };
+            document.head.appendChild(script);
+        }
+    </script>
+    <style>
+        .history-card {
+            border-left: 4px solid #17a2b8;
+            margin-bottom: 1rem;
+        }
+        .current-version {
+            background-color: #d4edda;
+            border-left: 4px solid #28a745;
+        }
+        .alternative-version {
+            background-color: #f8f9fa;
+            border-left: 4px solid #6c757d;
+        }
+        .file-type-badge {
+            font-size: 0.75rem;
+        }
+        .channel-badge {
+            font-size: 0.8rem;
+        }
+        .stats-card {
+            background: linear-gradient(135deg, #17a2b8 0%, #138496 100%);
+            color: white;
+        }
+        .file-type-card {
+            transition: transform 0.2s;
+        }
+        .file-type-card:hover {
+            transform: translateY(-2px);
+        }
+        .metric-highlight {
+            font-weight: bold;
+            color: #28a745;
+        }
+        .metric-warning {
+            font-weight: bold;
+            color: #dc3545;
+        }
+        .filter-section {
+            background-color: #f8f9fa;
+            border-radius: 8px;
+            padding: 1rem;
+            margin-bottom: 1rem;
+        }
+        .loading {
+            text-align: center;
+            padding: 2rem;
+        }
+        .pagination-info {
+            font-size: 0.9rem;
+            color: #6c757d;
+        }
+        .path-text {
+            font-family: 'Courier New', monospace;
+            font-size: 0.85rem;
+            word-break: break-all;
+        }
+        
+        /* Drag and Drop Styles */
+        .sortable-list {
+            min-height: 50px;
+        }
+        .sortable-item {
+            cursor: grab;
+            transition: all 0.2s ease;
+        }
+        .sortable-item:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        }
+        .sortable-item:active {
+            cursor: grabbing;
+        }
+        .sortable-ghost {
+            opacity: 0.5;
+            background-color: #e9ecef;
+        }
+        .sortable-chosen {
+            background-color: #e3f2fd;
+        }
+        
+        /* Navigation */
+        .nav-link {
+            color: #6c757d;
+        }
+        .nav-link.active {
+            color: #17a2b8;
+            font-weight: bold;
+        }
+        
+        /* Video Modal */
+        .video-modal .modal-dialog {
+            max-width: 90vw;
+        }
+        .video-modal .modal-body {
+            padding: 0;
+        }
+        .video-container {
+            position: relative;
+            width: 100%;
+            height: 0;
+            padding-bottom: 56.25%; /* 16:9 aspect ratio */
+        }
+        .video-container video {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+        }
+        
+        /* Inline Editing Styles */
+        .editable-field {
+            cursor: pointer;
+            border: 1px solid transparent;
+            padding: 2px 4px;
+            border-radius: 3px;
+            transition: all 0.2s ease;
+        }
+        .editable-field:hover {
+            border-color: #007bff;
+            background-color: #f8f9fa;
+        }
+        .editable-field.editing {
+            border-color: #007bff;
+            background-color: #fff;
+            box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);
+        }
+        .edit-input {
+            width: 100%;
+            border: 1px solid #007bff;
+            border-radius: 3px;
+            padding: 2px 4px;
+            font-size: inherit;
+            font-family: inherit;
+        }
+        .edit-buttons {
+            display: flex;
+            gap: 5px;
+            margin-top: 5px;
+        }
+        .edit-btn {
+            padding: 2px 8px;
+            font-size: 0.8rem;
+            border-radius: 3px;
+        }
+        .property-label {
+            font-weight: bold;
+            color: #495057;
+            font-size: 0.9rem;
+        }
+        .property-value {
+            font-size: 0.9rem;
+        }
+        .boolean-toggle {
+            cursor: pointer;
+            padding: 2px 8px;
+            border-radius: 3px;
+            font-size: 0.8rem;
+            transition: all 0.2s ease;
+        }
+        .boolean-toggle.true {
+            background-color: #28a745;
+            color: white;
+        }
+        .boolean-toggle.false {
+            background-color: #6c757d;
+            color: white;
+        }
+        .boolean-toggle:hover {
+            opacity: 0.8;
+        }
+    </style>
+</head>
+<body>
+    <!-- Navigation -->
+    <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
+        <div class="container-fluid">
+            <a class="navbar-brand" href="/">
+                <i class="fas fa-music"></i> Karaoke Manager
+            </a>
+            <div class="navbar-nav">
+                <a class="nav-link" href="/">
+                    <i class="fas fa-copy"></i> Duplicates
+                </a>
+                <a class="nav-link" href="/favorites">
+                    <i class="fas fa-heart"></i> Favorites
+                </a>
+                <a class="nav-link active" href="/history">
+                    <i class="fas fa-history"></i> History
+                </a>
+                <a class="nav-link" href="/remaining-songs">
+                    <i class="fas fa-list"></i> Remaining Songs
+                </a>
+            </div>
+        </div>
+    </nav>
+
+    <div class="container-fluid mt-3">
+        <!-- Header -->
+        <div class="row mb-3">
+            <div class="col">
+                <h1><i class="fas fa-history text-info"></i> History Management</h1>
+                <p class="text-muted">Review and manage your song history with alternative versions</p>
+            </div>
+        </div>
+
+        <!-- Statistics Cards -->
+        <div class="row mb-3" id="statsRow">
+            <div class="col-md-3">
+                <div class="card stats-card">
+                    <div class="card-body text-center">
+                        <h5 class="card-title">Total History</h5>
+                        <h3 id="totalHistory">-</h3>
+                    </div>
+                </div>
+            </div>
+            <div class="col-md-3">
+                <div class="card stats-card">
+                    <div class="card-body text-center">
+                        <h5 class="card-title">With Alternatives</h5>
+                        <h3 id="withAlternatives">-</h3>
+                    </div>
+                </div>
+            </div>
+            <div class="col-md-3">
+                <div class="card stats-card">
+                    <div class="card-body text-center">
+                        <h5 class="card-title">MP4 Versions</h5>
+                        <h3 id="mp4Versions">-</h3>
+                    </div>
+                </div>
+            </div>
+            <div class="col-md-3">
+                <div class="card stats-card">
+                    <div class="card-body text-center">
+                        <h5 class="card-title">MP3 Versions</h5>
+                        <h3 id="mp3Versions">-</h3>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Filters -->
+        <div class="filter-section">
+            <div class="row">
+                <div class="col-md-3">
+                    <label for="artistFilter" class="form-label">Artist Filter</label>
+                    <input type="text" class="form-control" id="artistFilter" placeholder="Filter by artist...">
+                </div>
+                <div class="col-md-3">
+                    <label for="titleFilter" class="form-label">Title Filter</label>
+                    <input type="text" class="form-control" id="titleFilter" placeholder="Filter by title...">
+                </div>
+                <div class="col-md-2">
+                    <label for="fileTypeFilter" class="form-label">File Type</label>
+                    <select class="form-select" id="fileTypeFilter">
+                        <option value="">All Types</option>
+                        <option value="MP4">MP4</option>
+                        <option value="MP3">MP3</option>
+                        <option value="MP3-only">MP3 Only (No MP4 Alternative)</option>
+                    </select>
+                </div>
+                <div class="col-md-2">
+                    <label for="channelFilter" class="form-label">Channel</label>
+                    <input type="text" class="form-control" id="channelFilter" placeholder="Filter by channel...">
+                </div>
+                <div class="col-md-2">
+                    <label for="minAlternatives" class="form-label">Min Alternatives</label>
+                    <input type="number" class="form-control" id="minAlternatives" value="0" min="0">
+                </div>
+            </div>
+            <div class="row mt-2">
+                <div class="col">
+                    <button class="btn btn-primary" onclick="applyFilters()">
+                        <i class="fas fa-filter"></i> Apply Filters
+                    </button>
+                    <button class="btn btn-warning me-2" onclick="mergeHistory()" title="Merge duplicate history entries">
+                        <i class="fas fa-compress-alt"></i> Merge Duplicates
+                    </button>
+                    <button class="btn btn-secondary" onclick="clearFilters()">
+                        <i class="fas fa-times"></i> Clear Filters
+                    </button>
+                </div>
+            </div>
+        </div>
+
+        <!-- Loading -->
+        <div id="loading" class="loading">
+            <div class="spinner-border text-primary" role="status">
+                <span class="visually-hidden">Loading...</span>
+            </div>
+            <p class="mt-2">Loading history data...</p>
+        </div>
+
+        <!-- History List -->
+        <div id="historyList" style="display: none;">
+            <!-- History will be loaded here -->
+        </div>
+
+        <!-- Pagination -->
+        <div class="row mt-3">
+            <div class="col-md-6">
+                <div class="pagination-info" id="paginationInfo">
+                    Showing 0 of 0 history items
+                </div>
+            </div>
+            <div class="col-md-6">
+                <nav aria-label="History pagination">
+                    <ul class="pagination justify-content-end" id="pagination">
+                        <!-- Pagination will be generated here -->
+                    </ul>
+                </nav>
+            </div>
+        </div>
+    </div>
+
+    <!-- Video Modal -->
+    <div class="modal fade video-modal" id="videoModal" tabindex="-1">
+        <div class="modal-dialog modal-xl">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title" id="videoModalTitle">Video Preview</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <div class="video-container">
+                        <video id="videoPlayer" controls>
+                            Your browser does not support the video tag.
+                        </video>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Bootstrap JS -->
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
+    
+    <script>
+        let allHistory = [];
+        let filteredHistory = [];
+        let currentPage = 1;
+        const perPage = 20;
+        let pathChanges = {};
+        let editingField = null;
+
+        // Inline editing functions
+        function startEdit(index, property) {
+            // Cancel any existing edit
+            if (editingField) {
+                cancelEdit();
+            }
+            
+            const field = event.target;
+            const currentValue = field.textContent;
+            const isNumber = property === 'count';
+            
+            // Create input field
+            const input = document.createElement('input');
+            input.type = isNumber ? 'number' : 'text';
+            input.className = 'edit-input';
+            input.value = currentValue;
+            
+            // Create buttons
+            const buttonContainer = document.createElement('div');
+            buttonContainer.className = 'edit-buttons';
+            buttonContainer.innerHTML = `
+                <button class="btn btn-sm btn-success edit-btn" onclick="saveEdit(${index}, '${property}')">
+                    <i class="fas fa-check"></i> Save
+                </button>
+                <button class="btn btn-sm btn-secondary edit-btn" onclick="cancelEdit()">
+                    <i class="fas fa-times"></i> Cancel
+                </button>
+            `;
+            
+            // Replace field content
+            field.innerHTML = '';
+            field.appendChild(input);
+            field.appendChild(buttonContainer);
+            field.classList.add('editing');
+            
+            // Focus input
+            input.focus();
+            input.select();
+            
+            // Store reference
+            editingField = {
+                field: field,
+                input: input,
+                originalValue: currentValue,
+                index: index,
+                property: property
+            };
+            
+            // Handle Enter and Escape keys
+            input.addEventListener('keydown', function(e) {
+                if (e.key === 'Enter') {
+                    saveEdit(index, property);
+                } else if (e.key === 'Escape') {
+                    cancelEdit();
+                }
+            });
+        }
+        
+        function saveEdit(index, property) {
+            if (!editingField) return;
+            
+            const newValue = editingField.input.value;
+            const originalValue = editingField.originalValue;
+            
+            if (newValue === originalValue) {
+                cancelEdit();
+                return;
+            }
+            
+            // Update via API
+            updateHistoryProperty(index, property, newValue);
+        }
+        
+        function cancelEdit() {
+            if (!editingField) return;
+            
+            const field = editingField.field;
+            const originalValue = editingField.originalValue;
+            
+            field.innerHTML = originalValue;
+            field.classList.remove('editing');
+            
+            editingField = null;
+        }
+        
+        async function updateHistoryProperty(index, property, value) {
+            try {
+                const response = await fetch('/api/update-history-property', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ index, property, value })
+                });
+                
+                const data = await response.json();
+                if (data.success) {
+                    // Update local data
+                    const historyItem = allHistory.find(h => h.index === index);
+                    if (historyItem) {
+                        historyItem[property] = value;
+                    }
+                    
+                    // Update display
+                    if (editingField) {
+                        editingField.field.innerHTML = escapeHtml(value);
+                        editingField.field.classList.remove('editing');
+                        editingField = null;
+                    }
+                    
+                    showSuccess(`Updated ${property} successfully`);
+                } else {
+                    throw new Error(data.error || 'Failed to update property');
+                }
+            } catch (error) {
+                console.error('Error updating property:', error);
+                showError('Failed to update property: ' + error.message);
+                cancelEdit();
+            }
+        }
+        
+        function toggleBoolean(index, property) {
+            const historyItem = allHistory.find(h => h.index === index);
+            if (!historyItem) return;
+            
+            const newValue = !historyItem[property];
+            updateHistoryProperty(index, property, newValue);
+        }
+
+        async function deleteHistoryItem(index) {
+            const historyItem = allHistory.find(h => h.index === index);
+            if (!historyItem) return;
+            
+            const songName = `${historyItem.artist} - ${historyItem.title}`;
+            if (!confirm(`Are you sure you want to delete "${songName}" from history?`)) {
+                return;
+            }
+            
+            try {
+                const response = await fetch('/api/delete-history', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ index })
+                });
+                
+                const data = await response.json();
+                if (data.success) {
+                    // Remove from local arrays
+                    allHistory = allHistory.filter(h => h.index !== index);
+                    filteredHistory = filteredHistory.filter(h => h.index !== index);
+                    
+                    // Update display
+                    updateStats();
+                    displayHistory();
+                    
+                    showSuccess(data.message || 'History item deleted successfully');
+                } else {
+                    throw new Error(data.error || 'Failed to delete history item');
+                }
+            } catch (error) {
+                console.error('Error deleting history item:', error);
+                showError('Failed to delete history item: ' + error.message);
+            }
+        }
+
+        // Helper functions
+        function getFileType(path) {
+            const lower = path.toLowerCase();
+            if (lower.endsWith('.mp4')) return 'MP4';
+            if (lower.endsWith('.mp3')) return 'MP3';
+            if (lower.endsWith('.cdg')) return 'MP3';  // Treat CDG as MP3 since they're paired
+            return 'Unknown';
+        }
+
+        function extractChannel(path) {
+            const lower = path.toLowerCase();
+            const parts = path.split('\\');
+            
+            // Look for specific known channels first
+            const knownChannels = ['Sing King Karaoke', 'KaraFun Karaoke', 'Stingray Karaoke'];
+            for (const channel of knownChannels) {
+                if (lower.includes(channel.toLowerCase())) {
+                    return channel;
+                }
+            }
+            
+            // Look for MP4 folder structure: MP4/ChannelName/song.mp4
+            for (let i = 0; i < parts.length; i++) {
+                if (parts[i].toLowerCase() === 'mp4' && i < parts.length - 1) {
+                    // If MP4 is found, return the next folder (the actual channel)
+                    if (i + 1 < parts.length) {
+                        const nextPart = parts[i + 1];
+                        // Skip if the next part is the filename (no extension means it's a folder)
+                        if (nextPart.indexOf('.') === -1) {
+                            return nextPart;
+                        } else {
+                            return 'MP4 Root';  // File is directly in MP4 folder
+                        }
+                    } else {
+                        return 'MP4 Root';
+                    }
+                }
+            }
+            
+            // Look for any folder that contains 'karaoke' (fallback)
+            for (const part of parts) {
+                if (part.toLowerCase().includes('karaoke')) {
+                    return part;
+                }
+            }
+            
+            // If no specific channel found, return the folder containing the file
+            if (parts.length >= 2) {
+                const parentFolder = parts[parts.length - 2]; // Second to last part (folder containing the file)
+                // If parent folder is MP4, then file is in root
+                if (parentFolder.toLowerCase() === 'mp4') {
+                    return 'MP4 Root';
+                }
+                return parentFolder;
+            }
+            
+            return 'Unknown';
+        }
+
+        // Load history data
+        async function loadHistory() {
+            try {
+                const response = await fetch('/api/history');
+                const data = await response.json();
+                
+                if (data.success) {
+                    allHistory = data.history;
+                    filteredHistory = [...allHistory];
+                    updateStats();
+                    displayHistory();
+                    hideLoading();
+                } else {
+                    throw new Error(data.error || 'Failed to load history');
+                }
+            } catch (error) {
+                console.error('Error loading history:', error);
+                hideLoading();
+                showError('Failed to load history: ' + error.message);
+            }
+        }
+
+        // Update statistics
+        function updateStats() {
+            const totalHistory = allHistory.length;
+            const withAlternatives = allHistory.filter(h => h.matching_songs.length > 1).length;
+            const mp4Versions = allHistory.reduce((count, h) => 
+                count + h.matching_songs.filter(s => s.file_type === 'MP4').length, 0);
+            const mp3Versions = allHistory.reduce((count, h) => 
+                count + h.matching_songs.filter(s => s.file_type === 'MP3').length, 0);
+
+            document.getElementById('totalHistory').textContent = totalHistory;
+            document.getElementById('withAlternatives').textContent = withAlternatives;
+            document.getElementById('mp4Versions').textContent = mp4Versions;
+            document.getElementById('mp3Versions').textContent = mp3Versions;
+        }
+
+        // Display history
+        function displayHistory() {
+            const startIndex = (currentPage - 1) * perPage;
+            const endIndex = startIndex + perPage;
+            const pageHistory = filteredHistory.slice(startIndex, endIndex);
+
+            const container = document.getElementById('historyList');
+            container.innerHTML = '';
+
+            pageHistory.forEach(historyItem => {
+                const card = createHistoryCard(historyItem);
+                container.appendChild(card);
+            });
+
+            updatePagination();
+            initializeSortable();
+        }
+
+        // Create history card
+        function createHistoryCard(historyItem) {
+            const card = document.createElement('div');
+            card.className = 'card history-card';
+            card.innerHTML = `
+                <div class="card-header">
+                    <div class="row align-items-center">
+                        <div class="col-md-6">
+                            <h5 class="mb-0">
+                                <i class="fas fa-history text-info"></i>
+                                <span class="editable-field" onclick="startEdit(${historyItem.index}, 'artist')">${escapeHtml(historyItem.artist)}</span> - 
+                                <span class="editable-field" onclick="startEdit(${historyItem.index}, 'title')">${escapeHtml(historyItem.title)}</span>
+                            </h5>
+                        </div>
+                        <div class="col-md-6 text-end">
+                            <button class="btn btn-sm btn-danger me-2" onclick="deleteHistoryItem(${historyItem.index})" title="Delete this history item">
+                                <i class="fas fa-trash"></i> Delete
+                            </button>
+                            <span class="badge bg-primary">${historyItem.matching_songs.length} versions</span>
+                        </div>
+                    </div>
+                </div>
+                <div class="card-body">
+                    <div class="row">
+                        <div class="col-md-6">
+                            <h6>All Properties (click to edit):</h6>
+                            <div class="row">
+                                <div class="col-md-6">
+                                    <div class="mb-2">
+                                        <div class="property-label">Artist:</div>
+                                        <div class="editable-field" onclick="startEdit(${historyItem.index}, 'artist')">${escapeHtml(historyItem.artist)}</div>
+                                    </div>
+                                    <div class="mb-2">
+                                        <div class="property-label">Title:</div>
+                                        <div class="editable-field" onclick="startEdit(${historyItem.index}, 'title')">${escapeHtml(historyItem.title)}</div>
+                                    </div>
+                                    <div class="mb-2">
+                                        <div class="property-label">Count:</div>
+                                        <div class="editable-field" onclick="startEdit(${historyItem.index}, 'count')">${historyItem.count}</div>
+                                    </div>
+                                    <div class="mb-2">
+                                        <div class="property-label">Path:</div>
+                                        <div class="editable-field path-text" onclick="startEdit(${historyItem.index}, 'path')">${escapeHtml(historyItem.path)}</div>
+                                    </div>
+                                </div>
+                                <div class="col-md-6">
+                                    <div class="mb-2">
+                                        <div class="property-label">Favorite:</div>
+                                        <span class="boolean-toggle ${historyItem.favorite ? 'true' : 'false'}" onclick="toggleBoolean(${historyItem.index}, 'favorite')">
+                                            ${historyItem.favorite ? 'Yes' : 'No'}
+                                        </span>
+                                    </div>
+                                    <div class="mb-2">
+                                        <div class="property-label">Disabled:</div>
+                                        <span class="boolean-toggle ${historyItem.disabled ? 'true' : 'false'}" onclick="toggleBoolean(${historyItem.index}, 'disabled')">
+                                            ${historyItem.disabled ? 'Yes' : 'No'}
+                                        </span>
+                                    </div>
+                                    ${historyItem.key ? `
+                                        <div class="mb-2">
+                                            <div class="property-label">Key:</div>
+                                            <div class="editable-field" onclick="startEdit(${historyItem.index}, 'key')">${escapeHtml(historyItem.key)}</div>
+                                        </div>
+                                    ` : `
+                                        <div class="mb-2">
+                                            <div class="property-label">Key:</div>
+                                            <div class="editable-field text-muted" onclick="startEdit(${historyItem.index}, 'key')">(click to add)</div>
+                                        </div>
+                                    `}
+                                    ${historyItem.original_path ? `
+                                        <div class="mb-2">
+                                            <div class="property-label">Original Path:</div>
+                                            <div class="editable-field path-text" onclick="startEdit(${historyItem.index}, 'original_path')">${escapeHtml(historyItem.original_path)}</div>
+                                        </div>
+                                    ` : `
+                                        <div class="mb-2">
+                                            <div class="property-label">Original Path:</div>
+                                            <div class="editable-field text-muted" onclick="startEdit(${historyItem.index}, 'original_path')">(click to add)</div>
+                                        </div>
+                                    `}
+                                </div>
+                            </div>
+                        </div>
+                        <div class="col-md-6">
+                            <h6>Available Versions (drag to reorder):</h6>
+                            <div class="sortable-list" data-history-index="${historyItem.index}">
+                                ${historyItem.matching_songs.map((song, songIndex) => `
+                                    <div class="card sortable-item ${song.is_current ? 'current-version' : 'alternative-version'} mb-2" 
+                                         data-song-index="${songIndex}">
+                                        <div class="card-body py-2">
+                                            <div class="row align-items-center">
+                                                <div class="col-md-1">
+                                                    <i class="fas fa-grip-vertical text-muted"></i>
+                                                </div>
+                                                <div class="col-md-2">
+                                                    <span class="badge bg-${song.file_type === 'MP4' ? 'danger' : 'success'} file-type-badge">
+                                                        ${song.file_type}
+                                                    </span>
+                                                    ${song.channel ? `<span class="badge bg-info channel-badge ms-1">${song.channel}</span>` : ''}
+                                                </div>
+                                                <div class="col-md-7">
+                                                    <div class="path-text">${escapeHtml(song.path)}</div>
+                                                </div>
+                                                <div class="col-md-2 text-end">
+                                                    ${song.is_current ? '<span class="badge bg-success">Current</span>' : ''}
+                                                    ${song.file_type === 'MP4' ? 
+                                                        `<button class="btn btn-sm btn-outline-primary" onclick="playVideo('${song.path.replace(/\\/g, '\\\\')}')">
+                                                            <i class="fas fa-play"></i> Play
+                                                        </button>` : ''}
+                                                </div>
+                                            </div>
+                                        </div>
+                                    </div>
+                                `).join('')}
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            `;
+            return card;
+        }
+
+        // Initialize sortable for drag and drop
+        function initializeSortable() {
+            document.querySelectorAll('.sortable-list').forEach(list => {
+                new Sortable(list, {
+                    animation: 150,
+                    ghostClass: 'sortable-ghost',
+                    chosenClass: 'sortable-chosen',
+                    onEnd: function(evt) {
+                        const historyIndex = parseInt(evt.target.dataset.historyIndex);
+                        const newOrder = Array.from(evt.target.children).map((item, index) => ({
+                            songIndex: parseInt(item.dataset.songIndex),
+                            newIndex: index
+                        }));
+                        
+                        // Update the history item's path to the first song in the list
+                        const firstSong = newOrder[0];
+                        const historyItem = allHistory.find(h => h.index === historyIndex);
+                        if (historyItem && historyItem.matching_songs[firstSong.songIndex]) {
+                            const newPath = historyItem.matching_songs[firstSong.songIndex].path;
+                            updateHistoryPath(historyIndex, newPath);
+                        }
+                    }
+                });
+            });
+        }
+
+        // Update history path
+        async function updateHistoryPath(index, newPath) {
+            try {
+                const response = await fetch('/api/update-history-path', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ index, path: newPath })
+                });
+
+                const data = await response.json();
+                if (data.success) {
+                    // Update local data
+                    const historyItem = allHistory.find(h => h.index === index);
+                    if (historyItem) {
+                        historyItem.current_path = newPath;
+                        // Update is_current flags
+                        historyItem.matching_songs.forEach(song => {
+                            song.is_current = song.path === newPath;
+                        });
+                    }
+                    showSuccess('History path updated successfully');
+                } else {
+                    throw new Error(data.error || 'Failed to update path');
+                }
+            } catch (error) {
+                console.error('Error updating history path:', error);
+                showError('Failed to update history path: ' + error.message);
+            }
+        }
+
+        // Apply filters
+        function applyFilters() {
+            const artistFilter = document.getElementById('artistFilter').value.toLowerCase();
+            const titleFilter = document.getElementById('titleFilter').value.toLowerCase();
+            const fileTypeFilter = document.getElementById('fileTypeFilter').value.toLowerCase();
+            const channelFilter = document.getElementById('channelFilter').value.toLowerCase();
+            const minAlternatives = parseInt(document.getElementById('minAlternatives').value) || 0;
+
+            filteredHistory = allHistory.filter(historyItem => {
+                // Artist filter
+                if (artistFilter && !historyItem.artist.toLowerCase().includes(artistFilter)) {
+                    return false;
+                }
+
+                // Title filter
+                if (titleFilter && !historyItem.title.toLowerCase().includes(titleFilter)) {
+                    return false;
+                }
+
+                // Min alternatives filter
+                if (historyItem.matching_songs.length < minAlternatives) {
+                    return false;
+                }
+
+                // File type and channel filters
+                if (fileTypeFilter || channelFilter) {
+                    let hasMatchingSong = false;
+                    
+                    // Special handling for MP3-only filter
+                    if (fileTypeFilter === 'mp3-only') {
+                        // Check if current history item is MP3 and has no MP4 alternatives
+                        const currentFileType = getFileType(historyItem.current_path);
+                        const hasMp4Alternative = historyItem.matching_songs.some(song => 
+                            song.file_type.toUpperCase() === 'MP4'
+                        );
+                        
+                        if (currentFileType.toUpperCase() === 'MP3' && !hasMp4Alternative) {
+                            // Apply channel filter if specified
+                            if (channelFilter) {
+                                const currentChannel = extractChannel(historyItem.current_path);
+                                hasMatchingSong = currentChannel.toLowerCase().includes(channelFilter);
+                            } else {
+                                hasMatchingSong = true;
+                            }
+                        }
+                    } else if (fileTypeFilter === 'mp3') {
+                        // Special handling for MP3 filter - show songs where primary is MP3 and has alternatives
+                        const currentFileType = getFileType(historyItem.current_path);
+                        
+                        // Only show if current history item is MP3 and has alternatives
+                        if (currentFileType.toUpperCase() === 'MP3' && historyItem.matching_songs.length > 0) {
+                            // Apply channel filter if specified
+                            if (channelFilter) {
+                                const currentChannel = extractChannel(historyItem.current_path);
+                                hasMatchingSong = currentChannel.toLowerCase().includes(channelFilter);
+                            } else {
+                                hasMatchingSong = true;
+                            }
+                        }
+                    } else {
+                        // Regular file type and channel filtering
+                        hasMatchingSong = historyItem.matching_songs.some(song => {
+                            const matchesFileType = !fileTypeFilter || song.file_type.toLowerCase().includes(fileTypeFilter);
+                            const matchesChannel = !channelFilter || (song.channel && song.channel.toLowerCase().includes(channelFilter));
+                            return matchesFileType && matchesChannel;
+                        });
+                    }
+                    
+                    if (!hasMatchingSong) {
+                        return false;
+                    }
+                }
+
+                return true;
+            });
+
+            currentPage = 1;
+            displayHistory();
+        }
+
+        // Clear filters
+        function clearFilters() {
+            document.getElementById('artistFilter').value = '';
+            document.getElementById('titleFilter').value = '';
+            document.getElementById('fileTypeFilter').value = '';
+            document.getElementById('channelFilter').value = '';
+            document.getElementById('minAlternatives').value = '0';
+            
+            filteredHistory = [...allHistory];
+            currentPage = 1;
+            displayHistory();
+        }
+
+        // Update pagination
+        function updatePagination() {
+            const totalPages = Math.ceil(filteredHistory.length / perPage);
+            const startItem = (currentPage - 1) * perPage + 1;
+            const endItem = Math.min(currentPage * perPage, filteredHistory.length);
+
+            document.getElementById('paginationInfo').textContent = 
+                `Showing ${startItem}-${endItem} of ${filteredHistory.length} history items`;
+
+            const pagination = document.getElementById('pagination');
+            pagination.innerHTML = '';
+
+            // Previous button
+            const prevLi = document.createElement('li');
+            prevLi.className = `page-item ${currentPage === 1 ? 'disabled' : ''}`;
+            prevLi.innerHTML = `<a class="page-link" href="#" onclick="changePage(${currentPage - 1})">Previous</a>`;
+            pagination.appendChild(prevLi);
+
+            // Page numbers
+            for (let i = 1; i <= totalPages; i++) {
+                if (i === 1 || i === totalPages || (i >= currentPage - 2 && i <= currentPage + 2)) {
+                    const li = document.createElement('li');
+                    li.className = `page-item ${i === currentPage ? 'active' : ''}`;
+                    li.innerHTML = `<a class="page-link" href="#" onclick="changePage(${i})">${i}</a>`;
+                    pagination.appendChild(li);
+                } else if (i === currentPage - 3 || i === currentPage + 3) {
+                    const li = document.createElement('li');
+                    li.className = 'page-item disabled';
+                    li.innerHTML = '<span class="page-link">...</span>';
+                    pagination.appendChild(li);
+                }
+            }
+
+            // Next button
+            const nextLi = document.createElement('li');
+            nextLi.className = `page-item ${currentPage === totalPages ? 'disabled' : ''}`;
+            nextLi.innerHTML = `<a class="page-link" href="#" onclick="changePage(${currentPage + 1})">Next</a>`;
+            pagination.appendChild(nextLi);
+        }
+
+        // Change page
+        function changePage(page) {
+            const totalPages = Math.ceil(filteredHistory.length / perPage);
+            if (page >= 1 && page <= totalPages) {
+                currentPage = page;
+                displayHistory();
+            }
+        }
+
+        // Play video
+        function playVideo(path) {
+            const videoPlayer = document.getElementById('videoPlayer');
+            const modal = new bootstrap.Modal(document.getElementById('videoModal'));
+            
+            videoPlayer.src = `/api/video/${encodeURIComponent(path)}`;
+            document.getElementById('videoModalTitle').textContent = `Video Preview: ${path.split('\\').pop()}`;
+            
+            modal.show();
+        }
+
+        // Merge history duplicates
+        async function mergeHistory() {
+            if (!confirm('Are you sure you want to merge duplicate history entries? This will combine entries with the same artist, title, and path, summing their count values.')) {
+                return;
+            }
+            
+            try {
+                const response = await fetch('/api/merge-history', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                });
+                
+                const data = await response.json();
+                if (data.success) {
+                    showSuccess(data.message);
+                    // Reload the history data to reflect the changes
+                    loadHistory();
+                } else {
+                    throw new Error(data.error || 'Failed to merge history');
+                }
+            } catch (error) {
+                console.error('Error merging history:', error);
+                showError('Failed to merge history: ' + error.message);
+            }
+        }
+
+        // Utility functions
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+
+        function showLoading() {
+            document.getElementById('loading').style.display = 'block';
+            document.getElementById('historyList').style.display = 'none';
+        }
+
+        function hideLoading() {
+            document.getElementById('loading').style.display = 'none';
+            document.getElementById('historyList').style.display = 'block';
+        }
+
+        function showError(message) {
+            alert('Error: ' + message);
+        }
+
+        function showSuccess(message) {
+            // You could implement a toast notification here
+            console.log('Success: ' + message);
+        }
+
+        // Initialize on page load
+        document.addEventListener('DOMContentLoaded', function() {
+            showLoading();
+            loadHistory();
+        });
+    </script>
+</body>
+</html> 
\ No newline at end of file
diff --git a/web/templates/index.html b/web/templates/index.html
index 6823548..4153f92 100644
--- a/web/templates/index.html
+++ b/web/templates/index.html
@@ -245,9 +245,44 @@
             margin-top: 4px;
             word-break: break-all;
         }
+        
+        /* Navigation */
+        .nav-link {
+            color: #6c757d;
+        }
+        .nav-link.active {
+            color: #007bff;
+            font-weight: bold;
+        }
     </style>
 </head>
 <body>
+    <!-- Navigation -->
+    <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
+        <div class="container-fluid">
+            <a class="navbar-brand" href="/">
+                <i class="fas fa-music"></i> Karaoke Manager
+            </a>
+            <div class="navbar-nav">
+                <a class="nav-link active" href="/">
+                    <i class="fas fa-copy"></i> Duplicates
+                </a>
+                <a class="nav-link" href="/favorites">
+                    <i class="fas fa-heart"></i> Favorites
+                </a>
+                <a class="nav-link" href="/history">
+                    <i class="fas fa-history"></i> History
+                </a>
+                <a class="nav-link" href="/remaining-songs">
+                    <i class="fas fa-list"></i> Remaining Songs
+                </a>
+                <a class="nav-link" href="/playlist-validation">
+                    <i class="fas fa-list-check"></i> Playlist Validation
+                </a>
+            </div>
+        </div>
+    </nav>
+
     <div class="container-fluid">
         <!-- Header -->
         <div class="row bg-primary text-white p-3 mb-4">
@@ -450,7 +485,7 @@
                                 <option value="">All Types</option>
                                 <option value="mp4">MP4</option>
                                 <option value="mp3">MP3</option>
-                                
+                                <option value="mp3-only">MP3 Only (No MP4 Alternative)</option>
                             </select>
                         </div>
                         <div class="col-md-2">
diff --git a/web/templates/playlist_validation.html b/web/templates/playlist_validation.html
new file mode 100644
index 0000000..919b207
--- /dev/null
+++ b/web/templates/playlist_validation.html
@@ -0,0 +1,1002 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Playlist Validation - Karaoke Library Cleanup</title>
+    
+    <!-- Bootstrap CSS -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+    <!-- Font Awesome -->
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
+    
+    <style>
+        .playlist-card {
+            transition: all 0.3s ease;
+            cursor: pointer;
+        }
+        
+        .playlist-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        }
+        
+        .playlist-card.selected {
+            border-color: #0d6efd;
+            background-color: #f8f9ff;
+        }
+        
+        .status-badge {
+            font-size: 0.8em;
+        }
+        
+        .exact-match {
+            background-color: #d4edda;
+            border-color: #c3e6cb;
+        }
+        
+        .fuzzy-match {
+            background-color: #fff3cd;
+            border-color: #ffeaa7;
+        }
+        
+        .missing-song {
+            background-color: #f8d7da;
+            border-color: #f5c6cb;
+        }
+        
+        .song-item {
+            transition: all 0.2s ease;
+        }
+        
+        .song-item:hover {
+            background-color: #f8f9fa;
+        }
+        
+        .similarity-bar {
+            height: 4px;
+            background-color: #e9ecef;
+            border-radius: 2px;
+            overflow: hidden;
+        }
+        
+        .similarity-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #dc3545, #ffc107, #28a745);
+            transition: width 0.3s ease;
+        }
+        
+        .loading {
+            opacity: 0.6;
+            pointer-events: none;
+        }
+        
+        .btn-update-song {
+            font-size: 0.8em;
+            padding: 0.25rem 0.5rem;
+        }
+        
+        .video-preview {
+            max-width: 100%;
+            height: auto;
+        }
+        
+        .stats-card {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+        }
+        
+        .progress-ring {
+            width: 60px;
+            height: 60px;
+        }
+        
+        .progress-ring circle {
+            fill: none;
+            stroke-width: 4;
+        }
+        
+        .progress-ring .bg {
+            stroke: rgba(255,255,255,0.2);
+        }
+        
+        .progress-ring .progress {
+            stroke: white;
+            stroke-linecap: round;
+            transform: rotate(-90deg);
+            transform-origin: 50% 50%;
+        }
+
+        .batch-update-panel {
+            position: fixed;
+            bottom: 0;
+            left: 0;
+            right: 0;
+            background: #f8f9fa;
+            border-top: 2px solid #dee2e6;
+            padding: 12px 15px;
+            z-index: 1000;
+            transform: translateY(100%);
+            transition: transform 0.3s ease;
+            max-height: 280px;
+            display: flex;
+            flex-direction: column;
+            box-shadow: 0 -2px 10px rgba(0,0,0,0.1);
+        }
+
+        .batch-update-panel.show {
+            transform: translateY(0);
+        }
+
+        .batch-update-panel h5 {
+            margin: 0 0 10px 0;
+            font-size: 1.1rem;
+        }
+
+        .queued-changes-container {
+            flex: 1;
+            overflow-y: auto;
+            max-height: 180px;
+            border: 1px solid #dee2e6;
+            border-radius: 4px;
+            background: white;
+        }
+
+        .queued-item {
+            background: white;
+            border-bottom: 1px solid #dee2e6;
+            padding: 8px 12px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .queued-item:last-child {
+            border-bottom: none;
+        }
+
+        .queued-item .change-info {
+            flex: 1;
+            font-size: 0.9rem;
+        }
+
+        .queued-item .remove-btn {
+            margin-left: 10px;
+            flex-shrink: 0;
+        }
+
+        .queued-song {
+            background-color: #e3f2fd;
+            border-left: 4px solid #2196f3;
+        }
+
+        .queued-song.duplicate {
+            background-color: #fff3cd;
+            border-left: 4px solid #ffc107;
+        }
+
+        .main-content {
+            margin-bottom: 100px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container-fluid">
+        <!-- Header -->
+        <div class="row bg-primary text-white p-3 mb-4">
+            <div class="col">
+                <h1><i class="fas fa-list-check"></i> Playlist Validation</h1>
+                <p class="mb-0">Validate playlists against your song library and fix fuzzy matches</p>
+            </div>
+        </div>
+
+        <!-- Navigation -->
+        <div class="row mb-4">
+            <div class="col">
+                <nav aria-label="breadcrumb">
+                    <ol class="breadcrumb">
+                        <li class="breadcrumb-item"><a href="/"><i class="fas fa-home"></i> Home</a></li>
+                        <li class="breadcrumb-item active">Playlist Validation</li>
+                    </ol>
+                </nav>
+            </div>
+        </div>
+
+        <!-- Main Content -->
+        <div class="row main-content">
+            <!-- Playlist Selection -->
+            <div class="col-md-4">
+                <div class="card">
+                    <div class="card-header">
+                        <h5><i class="fas fa-music"></i> Playlists</h5>
+                    </div>
+                    <div class="card-body">
+                        <div class="mb-3">
+                            <button id="validateAllBtn" class="btn btn-primary w-100 mb-2">
+                                <i class="fas fa-play"></i> Validate All Playlists
+                            </button>
+                            <button id="refreshPlaylistsBtn" class="btn btn-outline-secondary w-100">
+                                <i class="fas fa-sync-alt"></i> Refresh Playlists
+                            </button>
+                        </div>
+                        
+                        <div id="playlistsList" class="list-group">
+                            <!-- Playlists will be loaded here -->
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Validation Results -->
+            <div class="col-md-8">
+                <div id="validationResults" style="display: none;">
+                    <!-- Overall Stats -->
+                    <div class="row mb-4">
+                        <div class="col-12">
+                            <div class="card stats-card">
+                                <div class="card-body">
+                                    <div class="row text-center">
+                                        <div class="col-md-3">
+                                            <div class="d-flex align-items-center justify-content-center">
+                                                <div class="progress-ring me-3">
+                                                    <svg viewBox="0 0 36 36">
+                                                        <circle class="bg" cx="18" cy="18" r="16"></circle>
+                                                        <circle class="progress" cx="18" cy="18" r="16" 
+                                                                stroke-dasharray="100" stroke-dashoffset="0"></circle>
+                                                    </svg>
+                                                </div>
+                                                <div>
+                                                    <h4 id="totalSongs">0</h4>
+                                                    <small>Total Songs</small>
+                                                </div>
+                                            </div>
+                                        </div>
+                                        <div class="col-md-3">
+                                            <h4 id="exactMatches" class="text-success">0</h4>
+                                            <small>Exact Matches</small>
+                                        </div>
+                                        <div class="col-md-3">
+                                            <h4 id="fuzzyMatches" class="text-warning">0</h4>
+                                            <small>Fuzzy Matches</small>
+                                        </div>
+                                        <div class="col-md-3">
+                                            <h4 id="missingSongs" class="text-danger">0</h4>
+                                            <small>Missing Songs</small>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Playlist Details -->
+                    <div class="card">
+                        <div class="card-header">
+                            <h5 id="currentPlaylistTitle">Playlist Validation Results</h5>
+                        </div>
+                        <div class="card-body">
+                            <!-- Tabs -->
+                            <ul class="nav nav-tabs" id="validationTabs" role="tablist">
+                                <li class="nav-item" role="presentation">
+                                    <button class="nav-link active" id="fuzzy-tab" data-bs-toggle="tab" 
+                                            data-bs-target="#fuzzy" type="button" role="tab">
+                                        <i class="fas fa-search"></i> Fuzzy Matches
+                                        <span id="fuzzyCount" class="badge bg-warning ms-1">0</span>
+                                    </button>
+                                </li>
+                                <li class="nav-item" role="presentation">
+                                    <button class="nav-link" id="missing-tab" data-bs-toggle="tab" 
+                                            data-bs-target="#missing" type="button" role="tab">
+                                        <i class="fas fa-times-circle"></i> Missing Songs
+                                        <span id="missingCount" class="badge bg-danger ms-1">0</span>
+                                    </button>
+                                </li>
+                                <li class="nav-item" role="presentation">
+                                    <button class="nav-link" id="exact-tab" data-bs-toggle="tab" 
+                                            data-bs-target="#exact" type="button" role="tab">
+                                        <i class="fas fa-check-circle"></i> Exact Matches
+                                        <span id="exactCount" class="badge bg-success ms-1">0</span>
+                                    </button>
+                                </li>
+                            </ul>
+
+                            <!-- Tab Content -->
+                            <div class="tab-content mt-3" id="validationTabContent">
+                                <!-- Fuzzy Matches Tab -->
+                                <div class="tab-pane fade show active" id="fuzzy" role="tabpanel">
+                                    <div id="fuzzyMatchesList">
+                                        <!-- Fuzzy matches will be loaded here -->
+                                    </div>
+                                </div>
+
+                                <!-- Missing Songs Tab -->
+                                <div class="tab-pane fade" id="missing" role="tabpanel">
+                                    <div id="missingSongsList">
+                                        <!-- Missing songs will be loaded here -->
+                                    </div>
+                                </div>
+
+                                <!-- Exact Matches Tab -->
+                                <div class="tab-pane fade" id="exact" role="tabpanel">
+                                    <div id="exactMatchesList">
+                                        <!-- Exact matches will be loaded here -->
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Loading State -->
+                <div id="loadingState" class="text-center py-5" style="display: none;">
+                    <div class="spinner-border text-primary" role="status">
+                        <span class="visually-hidden">Loading...</span>
+                    </div>
+                    <p class="mt-3">Validating playlists...</p>
+                </div>
+
+                <!-- Welcome State -->
+                <div id="welcomeState" class="text-center py-5">
+                    <i class="fas fa-list-check fa-3x text-muted mb-3"></i>
+                    <h3>Select a Playlist</h3>
+                    <p class="text-muted">Choose a playlist from the left panel to start validation, or validate all playlists at once.</p>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Video Preview Modal -->
+    <div class="modal fade" id="videoModal" tabindex="-1">
+        <div class="modal-dialog modal-lg">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Video Preview</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <video id="videoPlayer" class="video-preview w-100" controls>
+                        Your browser does not support the video tag.
+                    </video>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Update Song Modal -->
+    <div class="modal fade" id="updateSongModal" tabindex="-1">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Update Playlist Song</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <form id="updateSongForm">
+                        <input type="hidden" id="updatePlaylistIndex">
+                        <input type="hidden" id="updateSongPosition">
+                        
+                        <div class="mb-3">
+                            <label class="form-label">Current Playlist Song:</label>
+                            <div class="form-control-plaintext" id="currentPlaylistSong"></div>
+                        </div>
+                        
+                        <div class="mb-3">
+                            <label class="form-label">Found Song:</label>
+                            <div class="form-control-plaintext" id="foundSongInfo"></div>
+                        </div>
+                        
+                        <div class="mb-3">
+                            <label for="newArtist" class="form-label">New Artist:</label>
+                            <input type="text" class="form-control" id="newArtist" required>
+                        </div>
+                        
+                        <div class="mb-3">
+                            <label for="newTitle" class="form-label">New Title:</label>
+                            <input type="text" class="form-control" id="newTitle" required>
+                        </div>
+                        
+                        <div class="form-check mb-3">
+                            <input class="form-check-input" type="checkbox" id="dryRunCheck" checked>
+                            <label class="form-check-label" for="dryRunCheck">
+                                Dry Run (preview changes only)
+                            </label>
+                        </div>
+                    </form>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancel</button>
+                    <button type="button" class="btn btn-primary" id="confirmUpdateBtn">
+                        <i class="fas fa-save"></i> Update Song
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Batch Update Panel -->
+    <div class="batch-update-panel" id="batchUpdatePanel">
+        <h5><i class="fas fa-wrench"></i> Batch Updates (<span id="pendingCount">0</span>)</h5>
+        <div class="queued-changes-container" id="queuedChangesList">
+            <!-- Changes will be queued here -->
+        </div>
+        <div class="mt-2">
+            <button class="btn btn-sm btn-primary w-100" id="applyAllChangesBtn">
+                <i class="fas fa-save"></i> Apply All Changes
+            </button>
+        </div>
+    </div>
+
+    <!-- Bootstrap JS -->
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+    
+    <script>
+        // Global variables
+        let currentPlaylistIndex = null;
+        let currentValidationResults = null;
+        let allPlaylists = [];
+        let pendingChanges = []; // New: Queue for batch updates
+
+        // Initialize the page
+        document.addEventListener('DOMContentLoaded', function() {
+            loadPlaylists();
+            setupEventListeners();
+            // Show batch update panel on load
+            showBatchUpdatePanel(false);
+        });
+
+        function setupEventListeners() {
+            // Button event listeners
+            document.getElementById('validateAllBtn').addEventListener('click', validateAllPlaylists);
+            document.getElementById('refreshPlaylistsBtn').addEventListener('click', loadPlaylists);
+            document.getElementById('confirmUpdateBtn').addEventListener('click', updatePlaylistSong);
+            document.getElementById('applyAllChangesBtn').addEventListener('click', applyAllPendingChanges);
+        }
+
+        async function loadPlaylists() {
+            try {
+                const response = await fetch('/api/playlists');
+                if (!response.ok) throw new Error('Failed to load playlists');
+                
+                allPlaylists = await response.json();
+                displayPlaylists(allPlaylists);
+            } catch (error) {
+                console.error('Error loading playlists:', error);
+                showAlert('Error loading playlists: ' + error.message, 'danger');
+            }
+        }
+
+        function displayPlaylists(playlists) {
+            const container = document.getElementById('playlistsList');
+            container.innerHTML = '';
+
+            playlists.forEach((playlist, index) => {
+                const playlistCard = document.createElement('div');
+                playlistCard.className = 'list-group-item list-group-item-action playlist-card';
+                playlistCard.innerHTML = `
+                    <div class="d-flex justify-content-between align-items-center">
+                        <div>
+                            <h6 class="mb-1">${playlist.title}</h6>
+                            <small class="text-muted">${playlist.song_count} songs</small>
+                        </div>
+                        <button class="btn btn-sm btn-outline-primary validate-playlist-btn" 
+                                data-playlist-index="${playlist.index}">
+                            <i class="fas fa-search"></i>
+                        </button>
+                    </div>
+                `;
+                
+                playlistCard.addEventListener('click', () => validatePlaylist(playlist.index));
+                container.appendChild(playlistCard);
+            });
+        }
+
+        async function validatePlaylist(playlistIndex) {
+            showLoading(true);
+            currentPlaylistIndex = playlistIndex;
+            
+            try {
+                const response = await fetch(`/api/validate-playlist/${playlistIndex}`);
+                if (!response.ok) throw new Error('Failed to validate playlist');
+                
+                const results = await response.json();
+                currentValidationResults = results;
+                displayValidationResults(results);
+            } catch (error) {
+                console.error('Error validating playlist:', error);
+                showAlert('Error validating playlist: ' + error.message, 'danger');
+            } finally {
+                showLoading(false);
+            }
+        }
+
+        async function validateAllPlaylists() {
+            showLoading(true);
+            
+            try {
+                const response = await fetch('/api/validate-all-playlists');
+                if (!response.ok) throw new Error('Failed to validate all playlists');
+                
+                const results = await response.json();
+                displayAllPlaylistsResults(results);
+            } catch (error) {
+                console.error('Error validating all playlists:', error);
+                showAlert('Error validating all playlists: ' + error.message, 'danger');
+            } finally {
+                showLoading(false);
+            }
+        }
+
+        function displayValidationResults(results) {
+            // Update stats
+            document.getElementById('totalSongs').textContent = results.total_songs;
+            document.getElementById('exactMatches').textContent = results.summary.exact_match_count;
+            document.getElementById('fuzzyMatches').textContent = results.summary.fuzzy_match_count;
+            document.getElementById('missingSongs').textContent = results.summary.missing_count;
+            
+            // Update tab badges
+            document.getElementById('exactCount').textContent = results.summary.exact_match_count;
+            document.getElementById('fuzzyCount').textContent = results.summary.fuzzy_match_count;
+            document.getElementById('missingCount').textContent = results.summary.missing_count;
+            
+            // Update playlist title
+            document.getElementById('currentPlaylistTitle').textContent = results.playlist_title;
+            
+            // Display results in tabs
+            displayExactMatches(results.exact_matches);
+            displayFuzzyMatches(results.fuzzy_matches);
+            displayMissingSongs(results.missing_songs);
+            
+            // Show results section
+            document.getElementById('validationResults').style.display = 'block';
+            document.getElementById('welcomeState').style.display = 'none';
+        }
+
+        function displayExactMatches(exactMatches) {
+            const container = document.getElementById('exactMatchesList');
+            container.innerHTML = '';
+
+            if (exactMatches.length === 0) {
+                container.innerHTML = '<p class="text-muted">No exact matches found.</p>';
+                return;
+            }
+
+            exactMatches.forEach(match => {
+                const songItem = createSongItem(match, 'exact');
+                container.appendChild(songItem);
+            });
+        }
+
+        function displayFuzzyMatches(fuzzyMatches) {
+            const container = document.getElementById('fuzzyMatchesList');
+            container.innerHTML = '';
+
+            if (fuzzyMatches.length === 0) {
+                container.innerHTML = '<p class="text-muted">No fuzzy matches found.</p>';
+                return;
+            }
+
+            fuzzyMatches.forEach(match => {
+                const songItem = createSongItem(match, 'fuzzy');
+                container.appendChild(songItem);
+            });
+        }
+
+        function displayMissingSongs(missingSongs) {
+            const container = document.getElementById('missingSongsList');
+            container.innerHTML = '';
+
+            if (missingSongs.length === 0) {
+                container.innerHTML = '<p class="text-muted">No missing songs found.</p>';
+                return;
+            }
+
+            missingSongs.forEach(song => {
+                const songItem = createSongItem(song, 'missing');
+                container.appendChild(songItem);
+            });
+        }
+
+        function createSongItem(match, type) {
+            const songItem = document.createElement('div');
+            songItem.className = `card mb-2 song-item ${type}-match`;
+            
+            if (type === 'exact') {
+                songItem.innerHTML = `
+                    <div class="card-body">
+                        <div class="row align-items-center">
+                            <div class="col-md-8">
+                                <h6 class="mb-1">${match.playlist_artist} - ${match.playlist_title}</h6>
+                                <small class="text-muted">Position: ${match.position}</small>
+                                <div class="mt-2">
+                                    <span class="badge bg-success">Exact Match</span>
+                                    <span class="badge bg-secondary">${getFileType(match.found_song.path)}</span>
+                                    ${match.found_song.path.includes('favorites') ? '<span class="badge bg-warning">Favorites</span>' : ''}
+                                    ${match.found_song.path.includes('history') ? '<span class="badge bg-info">History</span>' : ''}
+                                </div>
+                            </div>
+                            <div class="col-md-4 text-end">
+                                <button class="btn btn-sm btn-outline-primary" onclick="previewVideo('${match.found_song.path.replace(/\\/g, '\\\\')}')">
+                                    <i class="fas fa-play"></i> Preview
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                `;
+            } else if (type === 'fuzzy') {
+                const similarityPercent = Math.round(match.similarity * 100);
+                
+                // Check if this song is already in pending changes
+                const isQueued = pendingChanges.some(change => 
+                    change.playlistIndex === currentPlaylistIndex && 
+                    change.songPosition === match.position
+                );
+                
+                let updateButton;
+                if (isQueued) {
+                    updateButton = `
+                        <button class="btn btn-sm btn-secondary" disabled title="Already queued for update">
+                            <i class="fas fa-clock"></i> Queued
+                        </button>
+                    `;
+                } else {
+                    updateButton = `
+                        <button class="btn btn-sm btn-success" onclick="showUpdateModal(${match.position}, '${match.found_song.artist}', '${match.found_song.title}')">
+                            <i class="fas fa-save"></i> Update
+                        </button>
+                    `;
+                }
+                
+                songItem.innerHTML = `
+                    <div class="card-body">
+                        <div class="row align-items-center">
+                            <div class="col-md-8">
+                                <h6 class="mb-1">${match.playlist_artist} - ${match.playlist_title}</h6>
+                                <small class="text-muted">Position: ${match.position}</small>
+                                <div class="mt-2">
+                                    <span class="badge bg-warning">Fuzzy Match (${similarityPercent}%)</span>
+                                    <span class="badge bg-secondary">${getFileType(match.found_song.path)}</span>
+                                    ${match.found_song.path.includes('favorites') ? '<span class="badge bg-warning">Favorites</span>' : ''}
+                                    ${match.found_song.path.includes('history') ? '<span class="badge bg-info">History</span>' : ''}
+                                </div>
+                                <div class="similarity-bar mt-2">
+                                    <div class="similarity-fill" style="width: ${similarityPercent}%"></div>
+                                </div>
+                                <div class="mt-2">
+                                    <small class="text-muted">Found: ${match.found_song.artist} - ${match.found_song.title}</small>
+                                </div>
+                            </div>
+                            <div class="col-md-4 text-end">
+                                <button class="btn btn-sm btn-outline-primary me-1" onclick="previewVideo('${match.found_song.path.replace(/\\/g, '\\\\')}')">
+                                    <i class="fas fa-play"></i> Preview
+                                </button>
+                                ${updateButton}
+                            </div>
+                        </div>
+                    </div>
+                `;
+            } else if (type === 'missing') {
+                songItem.innerHTML = `
+                    <div class="card-body">
+                        <div class="row align-items-center">
+                            <div class="col-md-8">
+                                <h6 class="mb-1">${match.artist} - ${match.title}</h6>
+                                <small class="text-muted">Position: ${match.position}</small>
+                                <div class="mt-2">
+                                    <span class="badge bg-danger">Missing</span>
+                                    <small class="text-muted">${match.reason}</small>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                `;
+            }
+            
+            return songItem;
+        }
+
+        function getFileType(path) {
+            const ext = path.split('.').pop().toLowerCase();
+            if (ext === 'mp4') return 'MP4';
+            if (ext === 'mp3') return 'MP3';
+            if (ext === 'cdg') return 'CDG';
+            return 'Unknown';
+        }
+
+        function previewVideo(filePath) {
+            const videoPlayer = document.getElementById('videoPlayer');
+            const videoUrl = `/api/video/${encodeURIComponent(filePath)}`;
+            videoPlayer.src = videoUrl;
+            
+            const modal = new bootstrap.Modal(document.getElementById('videoModal'));
+            modal.show();
+        }
+
+        function showUpdateModal(songPosition, foundArtist, foundTitle) {
+            document.getElementById('updatePlaylistIndex').value = currentPlaylistIndex;
+            document.getElementById('updateSongPosition').value = songPosition;
+            document.getElementById('currentPlaylistSong').textContent = 
+                currentValidationResults.fuzzy_matches.find(m => m.position === songPosition)?.playlist_artist + 
+                ' - ' + 
+                currentValidationResults.fuzzy_matches.find(m => m.position === songPosition)?.playlist_title;
+            document.getElementById('foundSongInfo').textContent = foundArtist + ' - ' + foundTitle;
+            document.getElementById('newArtist').value = foundArtist;
+            document.getElementById('newTitle').value = foundTitle;
+            
+            const modal = new bootstrap.Modal(document.getElementById('updateSongModal'));
+            modal.show();
+        }
+
+        async function updatePlaylistSong() {
+            const playlistIndex = document.getElementById('updatePlaylistIndex').value;
+            const songPosition = document.getElementById('updateSongPosition').value;
+            const newArtist = document.getElementById('newArtist').value;
+            const newTitle = document.getElementById('newTitle').value;
+            const dryRun = document.getElementById('dryRunCheck').checked;
+
+            if (!newArtist || !newTitle) {
+                showAlert('Please fill in both artist and title fields.', 'warning');
+                return;
+            }
+
+            // Close the modal immediately to unblock the UI
+            const modal = bootstrap.Modal.getInstance(document.getElementById('updateSongModal'));
+            modal.hide();
+
+            if (dryRun) {
+                // For dry run, just show a preview message
+                showAlert(`Preview: Would update playlist ${parseInt(playlistIndex) + 1} song ${songPosition} to "${newArtist} - ${newTitle}"`, 'info');
+            } else {
+                // Check if this song is already in the pending changes
+                const isDuplicate = pendingChanges.some(change => 
+                    change.playlistIndex === parseInt(playlistIndex) && 
+                    change.songPosition === parseInt(songPosition)
+                );
+                
+                if (isDuplicate) {
+                    showAlert(`Song ${songPosition} is already queued for update. Remove it from the batch panel first.`, 'warning');
+                    return;
+                }
+                
+                // Add to pending changes queue
+                pendingChanges.push({
+                    playlistIndex: parseInt(playlistIndex),
+                    songPosition: parseInt(songPosition),
+                    newArtist: newArtist,
+                    newTitle: newTitle,
+                    dryRun: dryRun
+                });
+                displayPendingChanges();
+                
+                // Refresh the current validation results to update button states
+                if (currentValidationResults) {
+                    displayValidationResults(currentValidationResults);
+                }
+                
+                showAlert(`Queued: ${newArtist} - ${newTitle} for batch update`, 'success');
+            }
+        }
+
+        function updateSongInUI(playlistIndex, songPosition, newArtist, newTitle) {
+            // Find and update the song item in the current validation results
+            if (currentValidationResults) {
+                // Update fuzzy matches
+                const fuzzyMatch = currentValidationResults.fuzzy_matches.find(
+                    match => match.position === parseInt(songPosition)
+                );
+                if (fuzzyMatch) {
+                    // Move from fuzzy matches to exact matches
+                    fuzzyMatch.playlist_artist = newArtist;
+                    fuzzyMatch.playlist_title = newTitle;
+                    fuzzyMatch.match_type = 'exact';
+                    fuzzyMatch.needs_manual_review = false;
+                    
+                    // Remove from fuzzy matches and add to exact matches
+                    currentValidationResults.fuzzy_matches = currentValidationResults.fuzzy_matches.filter(
+                        match => match.position !== parseInt(songPosition)
+                    );
+                    currentValidationResults.exact_matches.push(fuzzyMatch);
+                    
+                    // Update summary counts
+                    currentValidationResults.summary.fuzzy_match_count--;
+                    currentValidationResults.summary.exact_match_count++;
+                    currentValidationResults.summary.needs_manual_review--;
+                    
+                    // Refresh the display
+                    displayValidationResults(currentValidationResults);
+                }
+            }
+        }
+
+        function displayAllPlaylistsResults(results) {
+            // Create a summary view for all playlists
+            const container = document.getElementById('validationResults');
+            container.innerHTML = `
+                <div class="card">
+                    <div class="card-header">
+                        <h5>All Playlists Validation Results</h5>
+                    </div>
+                    <div class="card-body">
+                        <div class="row text-center mb-4">
+                            <div class="col-md-3">
+                                <h4 class="text-primary">${results.total_playlists}</h4>
+                                <small>Total Playlists</small>
+                            </div>
+                            <div class="col-md-3">
+                                <h4 class="text-success">${results.overall_summary.exact_matches}</h4>
+                                <small>Exact Matches</small>
+                            </div>
+                            <div class="col-md-3">
+                                <h4 class="text-warning">${results.overall_summary.fuzzy_matches}</h4>
+                                <small>Fuzzy Matches</small>
+                            </div>
+                            <div class="col-md-3">
+                                <h4 class="text-danger">${results.overall_summary.missing_songs}</h4>
+                                <small>Missing Songs</small>
+                            </div>
+                        </div>
+                        
+                        <div class="table-responsive">
+                            <table class="table table-striped">
+                                <thead>
+                                    <tr>
+                                        <th>Playlist</th>
+                                        <th>Total Songs</th>
+                                        <th>Exact</th>
+                                        <th>Fuzzy</th>
+                                        <th>Missing</th>
+                                        <th>Action</th>
+                                    </tr>
+                                </thead>
+                                <tbody>
+                                    ${results.playlist_results.map((playlist, index) => `
+                                        <tr>
+                                            <td>${playlist.playlist_title}</td>
+                                            <td>${playlist.total_songs}</td>
+                                            <td><span class="badge bg-success">${playlist.summary.exact_match_count}</span></td>
+                                            <td><span class="badge bg-warning">${playlist.summary.fuzzy_match_count}</span></td>
+                                            <td><span class="badge bg-danger">${playlist.summary.missing_count}</span></td>
+                                            <td>
+                                                <button class="btn btn-sm btn-outline-primary" onclick="validatePlaylist(${index})">
+                                                    <i class="fas fa-search"></i> Details
+                                                </button>
+                                            </td>
+                                        </tr>
+                                    `).join('')}
+                                </tbody>
+                            </table>
+                        </div>
+                    </div>
+                </div>
+            `;
+            
+            container.style.display = 'block';
+            document.getElementById('welcomeState').style.display = 'none';
+        }
+
+        function showLoading(show) {
+            document.getElementById('loadingState').style.display = show ? 'block' : 'none';
+            document.getElementById('validationResults').style.display = show ? 'none' : 'block';
+            document.getElementById('welcomeState').style.display = show ? 'none' : 'block';
+        }
+
+        function showAlert(message, type) {
+            // Create alert element
+            const alertDiv = document.createElement('div');
+            alertDiv.className = `alert alert-${type} alert-dismissible fade show position-fixed`;
+            alertDiv.style.cssText = 'top: 20px; right: 20px; z-index: 9999; min-width: 300px;';
+            alertDiv.innerHTML = `
+                ${message}
+                <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
+            `;
+            
+            document.body.appendChild(alertDiv);
+            
+            // Auto-remove after 5 seconds
+            setTimeout(() => {
+                if (alertDiv.parentNode) {
+                    alertDiv.remove();
+                }
+            }, 5000);
+        }
+
+        function showBatchUpdatePanel(show) {
+            const panel = document.getElementById('batchUpdatePanel');
+            panel.classList.toggle('show', show);
+        }
+
+        function displayPendingChanges() {
+            const container = document.getElementById('queuedChangesList');
+            const countElement = document.getElementById('pendingCount');
+            container.innerHTML = '';
+
+            if (pendingChanges.length === 0) {
+                container.innerHTML = '<p class="text-muted p-3">No pending changes.</p>';
+                countElement.textContent = '0';
+                showBatchUpdatePanel(false);
+                return;
+            }
+
+            // Show the batch update panel when there are changes
+            showBatchUpdatePanel(true);
+            countElement.textContent = pendingChanges.length;
+
+            pendingChanges.forEach((change, index) => {
+                const changeItem = document.createElement('div');
+                changeItem.className = `queued-item queued-song`;
+                
+                // Find the original song info
+                const originalSong = currentValidationResults?.fuzzy_matches.find(m => m.position === change.songPosition);
+                const originalArtist = originalSong?.playlist_artist || 'Unknown';
+                const originalTitle = originalSong?.playlist_title || 'Unknown';
+                
+                changeItem.innerHTML = `
+                    <div class="change-info">
+                        <strong>Playlist ${change.playlistIndex + 1}</strong> - Song ${change.songPosition}
+                        <br>
+                        <small class="text-muted">From: ${originalArtist} - ${originalTitle}</small>
+                        <br>
+                        <small class="text-success">To: ${change.newArtist} - ${change.newTitle}</small>
+                    </div>
+                    <button class="btn btn-sm btn-danger remove-btn" onclick="removePendingChange(${index})" title="Remove from queue">
+                        <i class="fas fa-times"></i>
+                    </button>
+                `;
+                container.appendChild(changeItem);
+            });
+        }
+
+        function removePendingChange(index) {
+            pendingChanges.splice(index, 1);
+            displayPendingChanges();
+            
+            // Refresh the current validation results to update button states
+            if (currentValidationResults) {
+                displayValidationResults(currentValidationResults);
+            }
+        }
+
+        async function applyAllPendingChanges() {
+            if (pendingChanges.length === 0) {
+                showAlert('No pending changes to apply.', 'info');
+                return;
+            }
+
+            showLoading(true);
+            showBatchUpdatePanel(false); // Hide panel while applying
+
+            try {
+                const response = await fetch('/api/apply-all-updates', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        changes: pendingChanges
+                    })
+                });
+
+                if (!response.ok) throw new Error('Failed to apply all updates');
+                
+                const result = await response.json();
+                
+                if (result.success) {
+                    showAlert(result.message, 'success');
+                    // Refresh playlists to show updated results
+                    loadPlaylists();
+                    // Clear pending changes
+                    pendingChanges = [];
+                    displayPendingChanges();
+                } else {
+                    showAlert(result.error || 'Failed to apply all updates', 'danger');
+                }
+            } catch (error) {
+                console.error('Error applying all updates:', error);
+                showAlert('Error applying all updates: ' + error.message, 'danger');
+            } finally {
+                showLoading(false);
+                showBatchUpdatePanel(true); // Show panel after applying
+            }
+        }
+    </script>
+</body>
+</html> 
\ No newline at end of file
diff --git a/web/templates/remaining_songs.html b/web/templates/remaining_songs.html
index 4896444..e714ac2 100644
--- a/web/templates/remaining_songs.html
+++ b/web/templates/remaining_songs.html
@@ -48,9 +48,41 @@
         .back-button {
             margin-bottom: 1rem;
         }
+        
+        /* Navigation */
+        .nav-link {
+            color: #6c757d;
+        }
+        .nav-link.active {
+            color: #28a745;
+            font-weight: bold;
+        }
     </style>
 </head>
 <body>
+    <!-- Navigation -->
+    <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
+        <div class="container-fluid">
+            <a class="navbar-brand" href="/">
+                <i class="fas fa-music"></i> Karaoke Manager
+            </a>
+            <div class="navbar-nav">
+                <a class="nav-link" href="/">
+                    <i class="fas fa-copy"></i> Duplicates
+                </a>
+                <a class="nav-link" href="/favorites">
+                    <i class="fas fa-heart"></i> Favorites
+                </a>
+                <a class="nav-link" href="/history">
+                    <i class="fas fa-history"></i> History
+                </a>
+                <a class="nav-link active" href="/remaining-songs">
+                    <i class="fas fa-list"></i> Remaining Songs
+                </a>
+            </div>
+        </div>
+    </nav>
+
     <div class="container-fluid">
         <!-- Header -->
         <div class="row mt-3">