import tkinter as tk
from tkinter import ttk, messagebox, simpledialog
import threading
import time
import os
import json
import datetime
from pathlib import Path
import subprocess
import sys
import requests  # Required for server communication
import queue
import vlc  # For video playback with hardware acceleration

# Try importing PIL but provide fallback
try:
    from PIL import Image, ImageTk
    PIL_AVAILABLE = True
except ImportError:
    PIL_AVAILABLE = False
    print("WARNING: PIL not available. Image display functionality will be limited.")

# Import existing functions
from python_functions import (
    load_local_playlist, download_media_files, clean_unused_files,
    save_local_playlist, update_config_playlist_version, fetch_server_playlist,
    load_config
)
from logging_config import Logger

# Import virtual keyboard components
from virtual_keyboard import VirtualKeyboard, TouchOptimizedEntry, TouchOptimizedButton

# Update the config file path to use the resources directory
CONFIG_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'resources', 'app_config.txt')

from player_app import SimpleMediaPlayerApp
        
    def setup_window(self):
        """Configure the main window"""
        self.root.title("Simple Signage Player")
        self.root.configure(bg='black')
        
        # Load window size from config
        try:
            config = load_config()
            width = int(config.get('screen_w', 1920))
            height = int(config.get('screen_h', 1080))
            # Load scaling mode preference
            self.scaling_mode = config.get('scaling_mode', 'fit')
        except:
            width, height = 800, 600  # Fallback size if config fails
            self.scaling_mode = 'fit'  # Default scaling mode
        
        self.root.geometry(f"{width}x{height}")
        self.root.attributes('-fullscreen', True)
        
        # Bind events
        self.root.bind('<Key>', self.on_key_press)
        self.root.bind('<Button-1>', self.on_mouse_click)
        self.root.bind('<Motion>', self.on_mouse_motion)
        self.root.focus_set()
        
    def setup_ui(self):
        """Create the user interface"""
        # Main content area - make sure it's black and fill the entire window
        self.content_frame = tk.Frame(self.root, bg='black')
        self.content_frame.pack(fill=tk.BOTH, expand=True)
        
        # Image display - expand to fill the entire window
        self.image_label = tk.Label(self.content_frame, bg='black')
        self.image_label.pack(fill=tk.BOTH, expand=True)
        
        # Status label - hidden by default
        self.status_label = tk.Label(
            self.content_frame, 
            bg='black', 
            fg='white', 
            font=('Arial', 24),
            text=""
        )
        # Don't place the status label by default to keep it hidden
        
        # Control panel
        self.create_control_panel()
        self.show_controls()
        self.schedule_hide_controls()
        
    def create_control_panel(self):
        """Create touch-optimized control panel with larger buttons"""
        # Create control frame with larger size for touch
        self.control_frame = tk.Frame(
            self.root,
            bg='#1a1a1a',  # Dark background
            bd=2,
            relief=tk.RAISED,
            padx=15,
            pady=15
        )
        self.control_frame.place(relx=0.98, rely=0.98, anchor='se')
        
        # Touch-optimized button configuration
        button_config = {
            'bg': '#333333',
            'fg': 'white',
            'activebackground': '#555555',
            'activeforeground': 'white',
            'relief': tk.FLAT,
            'borderwidth': 0,
            'width': 10,  # Larger for touch
            'height': 3,  # Larger for touch
            'font': ('Segoe UI', 10, 'bold'),  # Larger font
            'cursor': 'hand2'
        }
        
        # Previous button
        self.prev_btn = tk.Button(
            self.control_frame,
            text="⏮ Prev",
            command=self.previous_media,
            **button_config
        )
        self.prev_btn.grid(row=0, column=0, padx=5)
        
        # Play/Pause button
        self.play_pause_btn = tk.Button(
            self.control_frame,
            text="⏸ Pause" if not self.is_paused else "▶ Play",
            command=self.toggle_play_pause,
            bg='#27ae60',  # Green for play/pause
            activebackground='#35d974',
            **{k: v for k, v in button_config.items() if k not in ['bg', 'activebackground']}
        )
        self.play_pause_btn.grid(row=0, column=1, padx=5)
        
        # Next button
        self.next_btn = tk.Button(
            self.control_frame,
            text="Next ⏭",
            command=self.next_media,
            **button_config
        )
        self.next_btn.grid(row=0, column=2, padx=5)
        
        # Settings button
        self.settings_btn = tk.Button(
            self.control_frame,
            text="⚙️ Settings",
            command=self.open_settings,
            bg='#9b59b6',  # Purple for settings
            activebackground='#bb8fce',
            **{k: v for k, v in button_config.items() if k not in ['bg', 'activebackground']}
        )
        self.settings_btn.grid(row=0, column=3, padx=5)
        
        # Exit button with special styling
        self.exit_btn = tk.Button(
            self.control_frame,
            text="❌ EXIT",
            command=self.show_exit_dialog,
            bg='#e74c3c',  # Red background
            fg='white',
            activebackground='#ec7063',
            activeforeground='white',
            relief=tk.FLAT,
            borderwidth=0,
            width=8,
            height=3,
            font=('Segoe UI', 10, 'bold'),
            cursor='hand2'
        )
        self.exit_btn.grid(row=0, column=4, padx=5)
        
        # Add touch feedback to all buttons
        for button in [self.prev_btn, self.play_pause_btn, self.next_btn, 
                      self.settings_btn, self.exit_btn]:
            self.add_touch_feedback_to_control_button(button)
    
    def scale_image_to_screen(self, img, screen_width, screen_height, mode='fit'):
        """
        Scale image to screen with different modes:
        - 'fit': Maintain aspect ratio, add black bars if needed (letterbox/pillarbox)
        - 'fill': Maintain aspect ratio, crop if needed to fill entire screen
        - 'stretch': Ignore aspect ratio, stretch to fill entire screen
        """
        img_width, img_height = img.size
        
        if mode == 'stretch':
            # Stretch to fill entire screen, ignoring aspect ratio
            return img.resize((screen_width, screen_height), Image.LANCZOS), (0, 0)
            
        elif mode == 'fill':
            # Maintain aspect ratio, crop to fill entire screen
            screen_ratio = screen_width / screen_height
            img_ratio = img_width / img_height
            
            if img_ratio > screen_ratio:
                # Image is wider - scale by height and crop width
                new_height = screen_height
                new_width = int(screen_height * img_ratio)
                x_offset = (screen_width - new_width) // 2
                y_offset = 0
            else:
                # Image is taller - scale by width and crop height
                new_width = screen_width
                new_height = int(screen_width / img_ratio)
                x_offset = 0
                y_offset = (screen_height - new_height) // 2
            
            # Resize and crop
            img_resized = img.resize((new_width, new_height), Image.LANCZOS)
            
            # Create final image and paste (this will crop automatically)
            final_img = Image.new('RGB', (screen_width, screen_height), 'black')
            
            # Calculate crop area if image is larger than screen
            if new_width > screen_width:
                crop_x = (new_width - screen_width) // 2
                img_resized = img_resized.crop((crop_x, 0, crop_x + screen_width, new_height))
                x_offset = 0
            if new_height > screen_height:
                crop_y = (new_height - screen_height) // 2
                img_resized = img_resized.crop((0, crop_y, new_width, crop_y + screen_height))
                y_offset = 0
                
            final_img.paste(img_resized, (x_offset, y_offset))
            return final_img, (x_offset, y_offset)
            
        else:  # mode == 'fit' (default)
            # Maintain aspect ratio, add black bars if needed
            screen_ratio = screen_width / screen_height
            img_ratio = img_width / img_height
            
            if img_ratio > screen_ratio:
                # Image is wider than screen - fit to width
                new_width = screen_width
                new_height = int(screen_width / img_ratio)
            else:
                # Image is taller than screen - fit to height
                new_height = screen_height
                new_width = int(screen_height * img_ratio)
            
            # Resize image
            img_resized = img.resize((new_width, new_height), Image.LANCZOS)
            
            # Create black background and center the image
            final_img = Image.new('RGB', (screen_width, screen_height), 'black')
            x_offset = (screen_width - new_width) // 2
            y_offset = (screen_height - new_height) // 2
            final_img.paste(img_resized, (x_offset, y_offset))
            
            return final_img, (x_offset, y_offset)
    
    def add_touch_feedback_to_control_button(self, button):
        """Add touch feedback effects to control panel buttons"""
        original_bg = button.cget('bg')
        
        def on_press(e):
            button.configure(relief=tk.SUNKEN)
            
        def on_release(e):
            button.configure(relief=tk.FLAT)
            
        def on_enter(e):
            button.configure(relief=tk.RAISED)
            
        def on_leave(e):
            button.configure(relief=tk.FLAT)

        button.bind("<Button-1>", on_press)
        button.bind("<ButtonRelease-1>", on_release)
        button.bind("<Enter>", on_enter)
        button.bind("<Leave>", on_leave)

    def initialize_playlist_from_server(self):
        """Initialize the playlist from the server on startup with fallback to local playlist"""
        # First try to load any existing local playlist as fallback
        fallback_playlist = None
        try:
            local_playlist_data = load_local_playlist()
            fallback_playlist = local_playlist_data.get('playlist', [])
            if fallback_playlist:
                Logger.info(f"Found fallback playlist with {len(fallback_playlist)} items")
        except Exception as e:
            Logger.warning(f"No fallback playlist available: {e}")

        # Show connection status
        self.status_label.config(text="Connecting to server...\nPlease wait")
        self.status_label.place(relx=0.5, rely=0.5, anchor='center')
        self.root.update()
        
        # Load configuration
        config = load_config()
        server = config.get("server_ip", "")
        host = config.get("screen_name", "")
        quick = config.get("quickconnect_key", "")
        port = config.get("port", "")
        
        Logger.info(f"Initializing with settings: server={server}, host={host}, port={port}")
        
        if not server or not host or not quick or not port:
            Logger.warning("Missing server configuration, using fallback playlist")
            self.status_label.place_forget()
            self.load_fallback_playlist(fallback_playlist)
            return
        
        # Attempt to fetch server playlist with timeout
        server_connection_successful = False
        try:
            # Add connection timeout and retry logic
            Logger.info("Attempting to connect to server...")
            self.status_label.config(text="Connecting to server...\nAttempting connection")
            self.root.update()
            
            server_playlist_data = fetch_server_playlist()
            server_playlist = server_playlist_data.get('playlist', [])
            server_version = server_playlist_data.get('version', 0)
            
            if server_playlist:
                Logger.info(f"Server playlist found with {len(server_playlist)} items, version {server_version}")
                server_connection_successful = True
                
                # Download media files and update local playlist
                self.status_label.config(text="Downloading media files...\nPlease wait")
                self.root.update()
                
                download_media_files(server_playlist, server_version)
                update_config_playlist_version(server_version)
                
                # Load the updated local playlist
                local_playlist_data = load_local_playlist()
                self.playlist = local_playlist_data.get('playlist', [])
                
                if self.playlist:
                    Logger.info(f"Successfully loaded {len(self.playlist)} items from server")
                    self.status_label.place_forget()
                    self.play_current_media()
                    return
                else:
                    Logger.warning("Server playlist was empty, falling back to local playlist")
            else:
                Logger.warning("Server returned empty playlist, falling back to local playlist")
                
        except requests.exceptions.ConnectTimeout:
            Logger.error("Server connection timeout, using fallback playlist")
        except requests.exceptions.ConnectionError:
            Logger.error("Cannot connect to server, using fallback playlist")
        except requests.exceptions.Timeout:
            Logger.error("Server request timeout, using fallback playlist")
        except Exception as e:
            Logger.error(f"Failed to fetch playlist from server: {e}, using fallback playlist")
        
        # If we reach here, server connection failed - use fallback
        if not server_connection_successful:
            self.status_label.config(text="Server unavailable\nLoading last playlist...")
            self.root.update()
            time.sleep(1)  # Brief pause to show message
            
        self.status_label.place_forget()
        self.load_fallback_playlist(fallback_playlist)
        
    def load_fallback_playlist(self, fallback_playlist):
        """Load fallback playlist when server is unavailable"""
        if fallback_playlist and len(fallback_playlist) > 0:
            self.playlist = fallback_playlist
            Logger.info(f"Loaded fallback playlist with {len(self.playlist)} items")
            self.play_current_media()
        else:
            Logger.warning("No fallback playlist available, loading demo content")
            self.load_demo_or_local_playlist()
            
    def load_demo_or_local_playlist(self):
        """Load either the existing local playlist or demo content"""
        # First try to load the local playlist
        local_playlist_data = load_local_playlist()
        self.playlist = local_playlist_data.get('playlist', [])
        
        if self.playlist:
            Logger.info(f"Loaded existing local playlist with {len(self.playlist)} items")
            self.play_current_media()
            return
            
        # If no local playlist, try loading demo content
        Logger.info("No local playlist found, loading demo content")
        self.create_demo_content()
        
        if self.playlist:
            self.play_current_media()
        else:
            self.show_no_content_message()
            
    def create_demo_content(self):
        """Create demo content for testing"""
        demo_images = []
        
        # First check static/resurse folder for any media
        static_dir = os.path.join(os.path.dirname(__file__), 'static', 'resurse')
        if os.path.exists(static_dir):
            for file in os.listdir(static_dir):
                if file.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
                    full_path = os.path.join(static_dir, file)
                    demo_images.append({
                        'file_name': file,
                        'url': full_path,
                        'duration': 5
                    })
        
        # If no files found in static/resurse, look in Resurse folder
        if not demo_images:
            demo_dir = './Resurse'
            if os.path.exists(demo_dir):
                for file in os.listdir(demo_dir):
                    if file.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
                        demo_images.append({
                            'file_name': file,
                            'url': os.path.join(demo_dir, file),
                            'duration': 5
                        })
        
        if demo_images:
            self.playlist = demo_images
            Logger.info(f"Created demo playlist with {len(demo_images)} images")
        else:
            # Create a text-only demo if no images found
            self.playlist = [{
                'file_name': 'Demo Text',
                'url': 'text://Welcome to Tkinter Media Player!\n\nPlease configure server settings',
                'duration': 5
            }]
            
    def show_no_content_message(self):
        """Show message when no content is available"""
        self.image_label.config(image='')
        self.status_label.config(
            text="No media content available.\nPress Settings to configure server connection."
        )
        self.status_label.place(relx=0.5, rely=0.5, anchor='center')
        
    def show_error_message(self, message):
        """Show error message"""
        self.image_label.config(image='')
        self.status_label.config(text=f"Error: {message}")
        self.status_label.place(relx=0.5, rely=0.5, anchor='center')
        
    def play_current_media(self):
        """Play the current media item"""
        if not self.playlist or self.current_index >= len(self.playlist):
            self.show_no_content_message()
            return
            
        media = self.playlist[self.current_index]
        file_path = media.get('url', '')
        file_name = media.get('file_name', '')
        duration = media.get('duration', 10)
        
        # Handle relative paths by converting to absolute paths
        if file_path.startswith('static/resurse/'):
            # Convert relative path to absolute
            absolute_path = os.path.join(os.path.dirname(__file__), file_path)
            file_path = absolute_path
        
        Logger.info(f"Playing media: {file_name} from {file_path}")
        
        # Log media start
        self.log_event(file_name, "STARTED")
        
        # Cancel existing timers
        self.cancel_timers()
        
        # Handle different media types
        if file_path.startswith('text://'):
            self.show_text_content(file_path[7:], duration)
        elif file_path.lower().endswith(('.mp4', '.avi', '.mov', '.mkv')):
            self.play_video(file_path)
        elif os.path.exists(file_path) and file_path.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.bmp')):
            self.show_image(file_path, duration)
        else:
            Logger.error(f"Unsupported or missing media: {file_path}")
            self.status_label.config(text=f"Missing or unsupported media:\n{file_name}")
            # Schedule next media after short delay
            self.auto_advance_timer = self.root.after(5000, self.next_media)
            
    def play_video(self, file_path):
        """Play video file using system VLC as a subprocess for robust hardware acceleration and stability."""
        self.status_label.place_forget()
        def run_vlc_subprocess():
            try:
                Logger.info(f"Starting system VLC subprocess for video: {file_path}")
                # Build VLC command
                vlc_cmd = [
                    'cvlc',
                    '--fullscreen',
                    '--no-osd',
                    '--no-video-title-show',
                    '--play-and-exit',
                    '--quiet',
                    file_path
                ]
                proc = subprocess.Popen(vlc_cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                proc.wait()
                Logger.info(f"VLC subprocess finished: {file_path}")
            except Exception as e:
                Logger.error(f"VLC subprocess error: {e}")
            finally:
                self.root.after_idle(lambda: setattr(self, 'auto_advance_timer', self.root.after(1000, self.next_media)))
        threading.Thread(target=run_vlc_subprocess, daemon=True).start()
        
    def _update_video_frame(self, photo):
        """Update video frame from main thread"""
        try:
            self.image_label.config(image=photo)
            self.image_label.image = photo  # Keep reference
        except Exception as e:
            Logger.error(f"Error updating video frame: {e}")
            
    def _show_video_error(self, error_msg):
        """Show video error from main thread"""
        try:
            self.status_label.config(text=f"Video Error:\n{error_msg}")
            self.status_label.place(relx=0.5, rely=0.5, anchor='center')
            self.auto_advance_timer = self.root.after(5000, self.next_media)
        except Exception as e:
            Logger.error(f"Error showing video error: {e}")
            self.auto_advance_timer = self.root.after(5000, self.next_media)
        
    def show_text_content(self, text, duration):
        """Display text content"""
        self.image_label.config(image='')
        self.status_label.config(text=text)
        
        # Schedule next media
        self.auto_advance_timer = self.root.after(
            int(duration * 1000),
            self.next_media
        )
        
    def show_image(self, file_path, duration):
        """Display an image in full screen, properly fitted to screen size"""
        try:
            # Hide status label and clear any previous text
            self.status_label.place_forget()
            self.status_label.config(text="")
            
            if PIL_AVAILABLE:
                # Use PIL for better image handling
                img = Image.open(file_path)
                original_size = img.size
                
                # Get actual screen dimensions
                screen_width = self.root.winfo_width()
                screen_height = self.root.winfo_height()
                
                # Ensure we have valid screen dimensions
                if screen_width <= 1 or screen_height <= 1:
                    screen_width = 1920  # Default fallback
                    screen_height = 1080
                
                # Scale image using the scaling helper
                final_img, offset = self.scale_image_to_screen(img, screen_width, screen_height, self.scaling_mode)
                
                # Convert to PhotoImage
                photo = ImageTk.PhotoImage(final_img)
                
                # Clear previous image and display new one
                self.image_label.config(image=photo)
                self.image_label.image = photo  # Keep reference
                
                Logger.info(f"Successfully displayed image: {os.path.basename(file_path)} "
                           f"(Original: {original_size}, Screen: {screen_width}x{screen_height}, "
                           f"Mode: {self.scaling_mode}, Offset: {offset})")
            else:
                # Fall back to basic text display if PIL not available
                self.image_label.config(image='')
                self.status_label.config(text=f"IMAGE: {os.path.basename(file_path)}\n\n(Install PIL for image display)")
                self.status_label.place(relx=0.5, rely=0.5, anchor='center')
                Logger.warning("PIL not available - showing text placeholder for image")
            
            # Schedule next media
            self.auto_advance_timer = self.root.after(
                int(duration * 1000),
                self.next_media
            )
            
        except Exception as e:
            Logger.error(f"Failed to show image {file_path}: {e}")
            self.image_label.config(image='')
            self.status_label.config(text=f"Image Error:\n{os.path.basename(file_path)}\n{str(e)}")
            self.status_label.place(relx=0.5, rely=0.5, anchor='center')
            self.auto_advance_timer = self.root.after(5000, self.next_media)
            
    def next_media(self):
        """Move to next media"""
        self.cancel_timers()
        
        if not self.playlist:
            return
            
        self.current_index = (self.current_index + 1) % len(self.playlist)
        
        # Check for playlist updates at end of cycle
        if self.current_index == 0:
            threading.Thread(target=self.check_playlist_updates, daemon=True).start()
            
        self.play_current_media()
        
    def previous_media(self):
        """Move to previous media"""
        self.cancel_timers()
        
        if not self.playlist:
            return
            
        self.current_index = (self.current_index - 1) % len(self.playlist)
        self.play_current_media()
        
    def toggle_play_pause(self):
        """Toggle play/pause state"""
        self.is_paused = not self.is_paused
        
        if self.is_paused:
            self.play_pause_btn.config(text="▶ Play")
            self.cancel_timers()
        else:
            self.play_pause_btn.config(text="⏸ Pause")
            # Resume current media
            self.play_current_media()
                
        Logger.info(f"Media {'paused' if self.is_paused else 'resumed'}")
        
    def cancel_timers(self):
        """Cancel all active timers"""
        if self.auto_advance_timer:
            self.root.after_cancel(self.auto_advance_timer)
            self.auto_advance_timer = None
            
    def show_controls(self):
        """Show control panel"""
        if self.control_frame:
            self.control_frame.place(relx=0.98, rely=0.98, anchor='se')
            
    def hide_controls(self):
        """Hide control panel"""
        if self.control_frame:
            self.control_frame.place_forget()
            
    def schedule_hide_controls(self):
        """Schedule hiding controls after delay"""
        if self.hide_controls_timer:
            self.root.after_cancel(self.hide_controls_timer)
        self.hide_controls_timer = self.root.after(10000, self.hide_controls)
        
    def on_mouse_click(self, event):
        """Handle mouse clicks"""
        self.show_controls()
        self.schedule_hide_controls()
        
    def on_mouse_motion(self, event):
        """Handle mouse motion"""
        self.show_controls()
        self.schedule_hide_controls()
        
    def on_key_press(self, event):
        """Handle keyboard events"""
        key = event.keysym.lower()
        
        if key == 'f':
            self.toggle_fullscreen()
        elif key == 'space':
            self.toggle_play_pause()
        elif key == 'left':
            self.previous_media()
        elif key == 'right':
            self.next_media()
        elif key == 'escape':
            self.show_exit_dialog()
        elif key == '1':
            self.set_scaling_mode('fit')
        elif key == '2':
            self.set_scaling_mode('fill')
        elif key == '3':
            self.set_scaling_mode('stretch')
        elif event.state & 0x4:  # Ctrl key pressed
            if key == 's':
                self.open_settings()
            
        self.show_controls()
        self.schedule_hide_controls()
        
    def set_scaling_mode(self, mode):
        """Change the scaling mode and refresh current media"""
        old_mode = self.scaling_mode
        self.scaling_mode = mode
        Logger.info(f"Scaling mode changed from '{old_mode}' to '{mode}'")
        
        # Show temporary notification
        self.status_label.config(text=f"Scaling Mode: {mode.title()}\n"
                                     f"1=Fit  2=Fill  3=Stretch")
        self.status_label.place(relx=0.5, rely=0.05, anchor='center')
        
        # Hide notification after 2 seconds
        self.root.after(2000, lambda: self.status_label.place_forget())
        
        # Refresh current media with new scaling
        if self.playlist and 0 <= self.current_index < len(self.playlist):
            self.cancel_timers()
            self.play_current_media()
        
    def toggle_fullscreen(self):
        """Toggle fullscreen mode"""
        self.is_fullscreen = not self.is_fullscreen
        self.root.attributes('-fullscreen', self.is_fullscreen)
        
    def open_settings(self):
        """Open settings window"""
        if hasattr(self, 'settings_window') and self.settings_window and self.settings_window.winfo_exists():
            self.settings_window.lift()
            return

        # Pause media playback when opening settings
        if not self.is_paused:
            self.toggle_play_pause()

        self.settings_window = SettingsWindow(self.root, self)

        # Add a callback to resume playback when the settings window is closed
        def on_settings_close():
            if self.is_paused:
                self.toggle_play_pause()

        self.settings_window.protocol("WM_DELETE_WINDOW", on_settings_close)
        
    def show_exit_dialog(self):
        """Show modern password-protected exit dialog"""
        try:
            config = load_config()
            quickconnect_key = config.get('quickconnect_key', '')
        except:
            quickconnect_key = ''
        
        # Create modern exit dialog
        exit_dialog = tk.Toplevel(self.root)
        exit_dialog.title("Exit Application")
        exit_dialog.geometry("400x200")
        exit_dialog.configure(bg='#2d2d2d')
        exit_dialog.transient(self.root)
        exit_dialog.grab_set()
        exit_dialog.resizable(False, False)
        
        # Center the dialog using helper method
        self.center_dialog_on_screen(exit_dialog, 400, 200)
        
        # Header with icon
        header_frame = tk.Frame(exit_dialog, bg='#cc0000', height=60)
        header_frame.pack(fill=tk.X)
        header_frame.pack_propagate(False)
        
        icon_label = tk.Label(header_frame, text="⚠", font=('Arial', 20, 'bold'), 
                             fg='white', bg='#cc0000')
        icon_label.pack(side=tk.LEFT, padx=15, pady=15)
        
        title_label = tk.Label(header_frame, text="Exit Application", 
                              font=('Arial', 14, 'bold'), fg='white', bg='#cc0000')
        title_label.pack(side=tk.LEFT, pady=15)
        
        # Content frame
        content_frame = tk.Frame(exit_dialog, bg='#2d2d2d', padx=20, pady=20)
        content_frame.pack(fill=tk.BOTH, expand=True)
        
        # Password prompt
        prompt_label = tk.Label(content_frame, text="Enter password to exit:", 
                               font=('Arial', 11), fg='white', bg='#2d2d2d')
        prompt_label.pack(pady=(0, 10))
        
        # Password entry
        password_var = tk.StringVar()
        password_entry = tk.Entry(content_frame, textvariable=password_var, 
                                 font=('Arial', 11), show='*', width=25,
                                 bg='#404040', fg='white', insertbackground='white',
                                 relief=tk.FLAT, bd=5)
        password_entry.pack(pady=(0, 15))
        password_entry.focus_set()
        
        # Button frame
        button_frame = tk.Frame(content_frame, bg='#2d2d2d')
        button_frame.pack(fill=tk.X)
        
        def check_password():
            if password_var.get() == quickconnect_key:
                exit_dialog.destroy()
                self.exit_application()
            elif password_var.get():  # Only show error if password was entered
                # Show error in red
                error_label.config(text="✗ Incorrect password", fg='#ff4444')
                password_entry.delete(0, tk.END)
                password_entry.focus_set()
        
        def cancel_exit():
            exit_dialog.destroy()
        
        # Error label (hidden initially)
        error_label = tk.Label(content_frame, text="", font=('Arial', 9), 
                              bg='#2d2d2d')
        error_label.pack()
        
        # Buttons
        cancel_btn = tk.Button(button_frame, text="Cancel", command=cancel_exit,
                              bg='#555555', fg='white', font=('Arial', 10, 'bold'),
                              relief=tk.FLAT, padx=20, pady=8, width=10)
        cancel_btn.pack(side=tk.RIGHT, padx=(10, 0))
        
        exit_btn = tk.Button(button_frame, text="Exit", command=check_password,
                            bg='#cc0000', fg='white', font=('Arial', 10, 'bold'),
                            relief=tk.FLAT, padx=20, pady=8, width=10)
        exit_btn.pack(side=tk.RIGHT)
        
        # Bind Enter key to check password
        password_entry.bind('<Return>', lambda e: check_password())
        exit_dialog.bind('<Escape>', lambda e: cancel_exit())
        
    def exit_application(self):
        """Exit the application"""
        Logger.info("Application exit requested")
        self.running = False
        self.root.quit()
        self.root.destroy()
        
    def center_dialog_on_screen(self, dialog, width, height):
        """Center a dialog window on screen regardless of screen size"""
        dialog.update_idletasks()  # Ensure geometry is calculated
        screen_width = dialog.winfo_screenwidth()
        screen_height = dialog.winfo_screenheight()
        
        # Calculate center position
        center_x = int((screen_width - width) / 2)
        center_y = int((screen_height - height) / 2)
        
        # Ensure the dialog doesn't go off-screen on smaller displays
        center_x = max(0, min(center_x, screen_width - width))
        center_y = max(0, min(center_y, screen_height - height))
        
        dialog.geometry(f"{width}x{height}+{center_x}+{center_y}")
        
        # Bring to front and focus
        dialog.lift()
        dialog.focus_force()
        
        return center_x, center_y
        
    def check_playlist_updates(self):
        """Check for playlist updates from server with fallback protection"""
        try:
            config = load_config()
            local_version = config.get('playlist_version', 0)
            
            server_playlist_data = fetch_server_playlist()
            server_version = server_playlist_data.get('version', 0)
            
            if server_version > local_version:
                Logger.info(f"Updating playlist: {local_version} -> {server_version}")
                
                # Clean old files
                local_playlist_data = load_local_playlist()
                clean_unused_files(local_playlist_data.get('playlist', []))
                
                # Download new content
                download_media_files(
                    server_playlist_data.get('playlist', []),
                    server_version
                )
                
                # Update local playlist
                local_playlist_data = load_local_playlist()
                self.playlist = local_playlist_data.get('playlist', [])
                
                # Reset to beginning of playlist
                self.current_index = 0
                
                Logger.info("Playlist updated successfully")
                
                # Continue with current media after update
                self.play_current_media()
            else:
                Logger.info("No playlist updates available")
                
        except requests.exceptions.ConnectTimeout:
            Logger.warning("Server connection timeout during update check - continuing with current playlist")
        except requests.exceptions.ConnectionError:
            Logger.warning("Cannot connect to server during update check - continuing with current playlist")
        except requests.exceptions.Timeout:
            Logger.warning("Server request timeout during update check - continuing with current playlist")
        except Exception as e:
            Logger.warning(f"Failed to check playlist updates: {e} - continuing with current playlist")
            
    def log_event(self, file_name, event):
        """Log media events"""
        try:
            timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            log_message = f"{timestamp} - {event}: {file_name}\n"
            
            # Update the log file path to the resources directory
            log_file = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'resources', 'log.txt')
            with open(log_file, 'a') as f:
                f.write(log_message)
                
        except Exception as e:
            Logger.error(f"Failed to log event: {e}")
            
    def start_periodic_checks(self):
        """Start periodic playlist checks"""
        def check_loop():
            """Background thread for periodic checks"""
            while self.running:
                try:
                    time.sleep(300)  # Check every 5 minutes
                    if self.running:
                        self.check_playlist_updates()
                except Exception as e:
                    Logger.error(f"Error in periodic check: {e}")
        
        # Start background thread
        threading.Thread(target=check_loop, daemon=True).start()
        
    def run(self):
        """Start the application"""
        Logger.info("Starting Simple Tkinter Media Player")
        try:
            self.root.mainloop()
        except KeyboardInterrupt:
            self.exit_application()
        except Exception as e:
            Logger.error(f"Application error: {e}")
            print(f"Error: {e}")