musicPlayer

from tkinter import *
from tkinter import filedialog
from tkinter import ttk
import customtkinter as ctk
from pygame import mixer
from mutagen.mp3 import MP3
import numpy as np
import threading
import time
import random
import os
from PIL import Image, ImageTk

# Set appearance mode and default theme
ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")


class ModernPlayer:
    def __init__(self, window):
        self.window = window
        window.geometry('900x650')
        window.title('🎵 Modern MP3 Player')
        window.minsize(800, 600)

        # Initialize mixer with a higher buffer for audio analysis
        mixer.init(frequency=44100, size=-16, channels=2, buffer=4096)

        # Main frame
        self.main_frame = ctk.CTkFrame(window)
        self.main_frame.pack(fill=BOTH, expand=True, padx=20, pady=20)

        # Create sidebar for playlist
        self.create_sidebar()

        # Create player controls area
        self.create_player_controls()

        # Create visualization area
        self.create_visualization_area()

        # Variables initialization
        self.music_file = None
        self.playing_state = False
        self.song_length = 0
        self.current_pos = 0
        self.visualization_running = False
        self.current_vis_style = "Bars"
        self.playlist = []
        self.current_song_index = -1
        self.audio_data = np.zeros(40)  # Initialize audio data array
        self.seeking = False  # Flag to prevent progress updates during seeking

        # Track song position for better seeking
        self.song_start_time = 0
        self.paused_position = 0
        self.is_paused = False

        # Progress update timer
        self.update_progress()

        # Create initial visualization items
        self.visualization_items = []
        self.initialize_visualization()

        # Setup audio analysis
        self.setup_audio_analysis()

    def setup_audio_analysis(self):
        # Create a separate thread for audio analysis
        self.analysis_running = False
        self.audio_thread = threading.Thread(target=self.analyze_audio)
        self.audio_thread.daemon = True  # Thread will close when app closes

    def analyze_audio(self):
        """Analyze the currently playing audio to extract intensity data"""
        self.analysis_running = True

        # We'll use pygame's mixer to analyze the current sound buffer
        while self.analysis_running:
            if self.playing_state and mixer.music.get_busy():
                try:
                    # Calculate a more complex intensity based on current position and song characteristics
                    current_time = time.time()
                    if self.is_paused:
                        position = self.paused_position
                    else:
                        position = current_time - self.song_start_time + self.paused_position

                    # Generate and store frequency data (40 bands)
                    for i in range(40):
                        # More complex frequency simulation with beat detection
                        # Add a beat every 0.5 seconds (120 BPM) with varying intensity
                        beat_phase = (position * 2) % 1  # Normalized phase for beat (0-1)
                        beat_intensity = max(0, 1 - beat_phase * 4) if beat_phase < 0.25 else 0

                        # Basic frequency intensity (different for each frequency band)
                        freq_intensity = 0.3 + 0.5 * abs(np.sin(position + i * 0.1) *
                                                         np.sin(position * 1.5 + i * 0.2))

                        # Combine beat and frequency intensity
                        intensity = freq_intensity + beat_intensity * (0.8 if i < 8 else 0.2)

                        # Add some randomness to simulate actual audio
                        intensity += random.uniform(-0.05, 0.05)
                        intensity = max(0.05, min(1.0, intensity))  # Clamp values

                        # Apply smoothing
                        self.audio_data[i] = self.audio_data[i] * 0.7 + intensity * 0.3

                except Exception as e:
                    print(f"Audio analysis error: {e}")
                    # Reset audio data if there's an error
                    self.audio_data = np.zeros(40)
            else:
                # When not playing, slowly fade the visualization
                self.audio_data = self.audio_data * 0.95
                if all(x < 0.05 for x in self.audio_data):
                    self.audio_data = np.zeros(40)

            # Sleep to prevent high CPU usage
            time.sleep(0.05)

    def create_sidebar(self):
        # Sidebar frame
        self.sidebar = ctk.CTkFrame(self.main_frame, width=250)
        self.sidebar.pack(side=LEFT, fill=Y, padx=(0, 20), pady=0)

        # Playlist label
        playlist_label = ctk.CTkLabel(self.sidebar, text="PLAYLIST", font=("Arial", 16, "bold"))
        playlist_label.pack(pady=(20, 10), padx=10)

        # Add button
        self.add_button = ctk.CTkButton(self.sidebar, text="+ Add Songs", command=self.add_to_playlist)
        self.add_button.pack(pady=(0, 10), padx=20, fill=X)

        # Clear button
        self.clear_button = ctk.CTkButton(self.sidebar, text="Clear Playlist",
                                          command=self.clear_playlist, fg_color="#FF5555", hover_color="#FF3333")
        self.clear_button.pack(pady=(0, 20), padx=20, fill=X)

        # Playlist container with scrollbar
        playlist_container = ctk.CTkFrame(self.sidebar)
        playlist_container.pack(fill=BOTH, expand=True, padx=10, pady=(0, 10))

        # Scrollable frame for playlist items
        self.playlist_frame = ctk.CTkScrollableFrame(playlist_container)
        self.playlist_frame.pack(fill=BOTH, expand=True)

    def create_player_controls(self):
        # Right side (player) container
        self.player_frame = ctk.CTkFrame(self.main_frame)
        self.player_frame.pack(side=RIGHT, fill=BOTH, expand=True)

        # Now playing area
        self.now_playing_frame = ctk.CTkFrame(self.player_frame)
        self.now_playing_frame.pack(fill=X, padx=20, pady=20)

        # Song label
        self.song_label = ctk.CTkLabel(self.now_playing_frame, text="No song loaded",
                                       font=("Arial", 18, "bold"))
        self.song_label.pack(pady=10)

        # Artist label (placeholder for ID3 tag support)
        self.artist_label = ctk.CTkLabel(self.now_playing_frame, text="", font=("Arial", 14))
        self.artist_label.pack(pady=(0, 10))

        # Progress bar and time labels
        self.progress_frame = ctk.CTkFrame(self.player_frame)
        self.progress_frame.pack(fill=X, padx=20, pady=(0, 20))

        # Time labels
        self.time_frame = ctk.CTkFrame(self.progress_frame, fg_color="transparent")
        self.time_frame.pack(fill=X, pady=(0, 5))

        self.current_time_label = ctk.CTkLabel(self.time_frame, text="0:00")
        self.current_time_label.pack(side=LEFT)

        self.total_time_label = ctk.CTkLabel(self.time_frame, text="0:00")
        self.total_time_label.pack(side=RIGHT)

        # Progress slider with improved interaction
        self.progress_slider = ctk.CTkSlider(self.progress_frame, from_=0, to=100)
        self.progress_slider.pack(fill=X, pady=(0, 10))
        self.progress_slider.set(0)

        # Bind events for better seeking experience
        self.progress_slider.bind("<Button-1>", self.start_seek)
        self.progress_slider.bind("<ButtonRelease-1>", self.end_seek)

        # Controls frame
        self.controls_frame = ctk.CTkFrame(self.player_frame)
        self.controls_frame.pack(fill=X, padx=20, pady=(0, 20))

        # Button styles
        button_width = 40
        button_height = 40

        # Button row
        self.button_row = ctk.CTkFrame(self.controls_frame, fg_color="transparent")
        self.button_row.pack(pady=10)

        # Previous button
        self.prev_btn = ctk.CTkButton(self.button_row, text="⏮", width=button_width, height=button_height,
                                      command=self.previous_song, font=("Arial", 16))
        self.prev_btn.grid(row=0, column=0, padx=10)

        # Play button
        self.play_btn = ctk.CTkButton(self.button_row, text="▶", width=button_width * 1.5, height=button_height * 1.5,
                                      command=self.play, font=("Arial", 20))
        self.play_btn.grid(row=0, column=1, padx=10)

        # Pause button
        self.pause_btn = ctk.CTkButton(self.button_row, text="⏸", width=button_width, height=button_height,
                                       command=self.pause, font=("Arial", 16))
        self.pause_btn.grid(row=0, column=2, padx=10)

        # Stop button
        self.stop_btn = ctk.CTkButton(self.button_row, text="⏹", width=button_width, height=button_height,
                                      command=self.stop, font=("Arial", 16))
        self.stop_btn.grid(row=0, column=3, padx=10)

        # Next button
        self.next_btn = ctk.CTkButton(self.button_row, text="⏭", width=button_width, height=button_height,
                                      command=self.next_song, font=("Arial", 16))
        self.next_btn.grid(row=0, column=4, padx=10)

        # Volume and visualization control row
        self.controls_bottom = ctk.CTkFrame(self.controls_frame, fg_color="transparent")
        self.controls_bottom.pack(pady=(10, 0), fill=X)

        # Volume icon (placeholder - normally an image would be better)
        self.volume_icon = ctk.CTkLabel(self.controls_bottom, text="🔊", font=("Arial", 14))
        self.volume_icon.pack(side=LEFT, padx=(0, 10))

        # Volume slider
        self.volume_slider = ctk.CTkSlider(self.controls_bottom, from_=0, to=100, command=self.set_volume)
        self.volume_slider.pack(side=LEFT, fill=X, expand=True, padx=(0, 20))
        self.volume_slider.set(50)  # Default volume

        # Visualization style selector
        vis_label = ctk.CTkLabel(self.controls_bottom, text="Visualization:", font=("Arial", 14))
        vis_label.pack(side=LEFT, padx=(0, 10))

        self.vis_styles = ["Bars", "Circles", "Wave", "Particles"]
        self.vis_style_var = StringVar(value=self.vis_styles[0])

        self.vis_style_menu = ctk.CTkOptionMenu(self.controls_bottom, values=self.vis_styles,
                                                variable=self.vis_style_var, command=self.update_visualization_style)
        self.vis_style_menu.pack(side=LEFT)

    def create_visualization_area(self):
        # Visualization frame
        self.vis_container = ctk.CTkFrame(self.player_frame)
        self.vis_container.pack(fill=BOTH, expand=True, padx=20, pady=(0, 20))

        # Canvas for visualization
        self.canvas = Canvas(self.vis_container, bg="#111111", highlightthickness=0)
        self.canvas.pack(fill=BOTH, expand=True, padx=2, pady=2)

    def add_to_playlist(self):
        files = filedialog.askopenfilenames(filetypes=[("MP3 Files", "*.mp3")])
        for file in files:
            self.playlist.append(file)
            # Get just the filename without the path
            filename = os.path.basename(file)

            # Create a frame for this playlist item
            item_frame = ctk.CTkFrame(self.playlist_frame)
            item_frame.pack(fill=X, pady=2)

            # Add song name label
            song_label = ctk.CTkLabel(item_frame, text=filename, anchor="w",
                                      font=("Arial", 12))
            song_label.pack(side=LEFT, padx=10, pady=8, fill=X, expand=True)

            # Add index to the list
            index = len(self.playlist) - 1

            # Add play button for this item
            play_btn = ctk.CTkButton(item_frame, text="▶", width=30, height=30,
                                     command=lambda idx=index: self.play_from_playlist(idx))
            play_btn.pack(side=RIGHT, padx=5)

        # If this is the first song added, select it
        if len(self.playlist) == 1:
            self.current_song_index = 0
            self.load_current_song()

        # Start audio analysis thread if not already running
        if not self.analysis_running and not self.audio_thread.is_alive():
            self.audio_thread.start()

    def clear_playlist(self):
        self.playlist = []
        self.current_song_index = -1

        # Clear the playlist frame
        for widget in self.playlist_frame.winfo_children():
            widget.destroy()

        # Reset player
        self.stop()
        self.song_label.configure(text="No song loaded")
        self.artist_label.configure(text="")

    def play_from_playlist(self, index):
        self.current_song_index = index
        self.load_current_song()
        self.play()

    def load_current_song(self):
        if 0 <= self.current_song_index < len(self.playlist):
            self.music_file = self.playlist[self.current_song_index]
            if self.music_file:
                # Extract just the filename without path or extension
                filename = os.path.basename(self.music_file)
                self.song_label.configure(text=filename)

                try:
                    # Get song duration
                    audio = MP3(self.music_file)
                    self.song_length = audio.info.length

                    # Format total time
                    mins, secs = divmod(int(self.song_length), 60)
                    self.total_time_label.configure(text=f"{mins}:{secs:02d}")

                    # Try to get ID3 tag info
                    if hasattr(audio, 'tags') and audio.tags:
                        if 'TPE1' in audio.tags:  # Artist
                            self.artist_label.configure(text=str(audio.tags['TPE1']))
                        else:
                            self.artist_label.configure(text="Unknown Artist")
                    else:
                        self.artist_label.configure(text="Unknown Artist")
                except Exception as e:
                    print(f"Error loading MP3 metadata: {e}")
                    self.song_length = 0
                    self.total_time_label.configure(text="0:00")

    def next_song(self):
        if self.playlist:
            self.current_song_index = (self.current_song_index + 1) % len(self.playlist)
            self.load_current_song()
            if self.playing_state:
                self.play()

    def previous_song(self):
        if self.playlist:
            self.current_song_index = (self.current_song_index - 1) % len(self.playlist)
            self.load_current_song()
            if self.playing_state:
                self.play()

    def start_seek(self, event):
        """Called when the user clicks on the progress slider"""
        self.seeking = True

    def end_seek(self, event):
        """Called when the user releases the progress slider"""
        if self.song_length > 0 and self.music_file:
            # Get slider position
            position_percent = self.progress_slider.get()
            position_seconds = (position_percent / 100) * self.song_length

            # Update display
            self.current_pos = position_seconds
            mins, secs = divmod(int(position_seconds), 60)
            self.current_time_label.configure(text=f"{mins}:{secs:02d}")

            # Actually seek in the song if playing
            if self.playing_state:
                # Stop the current playback
                mixer.music.stop()
                # Reload and play from new position
                mixer.music.load(self.music_file)
                mixer.music.play(start=position_seconds)

                # Update our tracking variables for position
                self.paused_position = position_seconds
                self.song_start_time = time.time()

        # Resume progress updates
        self.seeking = False

    def update_progress(self):
        # Update current position if playing and not seeking
        if self.playing_state and not self.seeking:
            if self.is_paused:
                current_time = self.paused_position
            else:
                current_time = time.time() - self.song_start_time + self.paused_position

            if current_time >= 0:
                # Update the current position
                self.current_pos = current_time

                # Update progress slider
                if self.song_length > 0:
                    progress_percent = (self.current_pos / self.song_length) * 100
                    self.progress_slider.set(min(100, progress_percent))  # Ensure we don't exceed 100%

                # Update time label
                mins, secs = divmod(int(self.current_pos), 60)
                self.current_time_label.configure(text=f"{mins}:{secs:02d}")

                # Check if song ended based on our time tracking
                if self.current_pos >= self.song_length and not mixer.music.get_busy():
                    # Song ended, play next song
                    self.next_song()

        # Schedule next update
        self.window.after(1000, self.update_progress)

    def initialize_visualization(self):
        # Clear any existing visualization
        for item in self.visualization_items:
            self.canvas.delete(item)
        self.visualization_items = []

        width = self.canvas.winfo_width() or 750
        height = self.canvas.winfo_height() or 200

        # Initial setup based on visualization style
        if self.current_vis_style == "Bars":
            # Create 40 bars
            bar_width = width / 50
            for i in range(40):
                x = i * (bar_width + 2) + 10
                bar = self.canvas.create_rectangle(x, height, x + bar_width, height, fill="#0077ff", outline="")
                self.visualization_items.append(bar)

        elif self.current_vis_style == "Circles":
            # Create 20 circles
            for i in range(20):
                x = width / 2
                y = height / 2
                circle = self.canvas.create_oval(x - 5, y - 5, x + 5, y + 5, fill="#00ff77", outline="")
                self.visualization_items.append(circle)

        elif self.current_vis_style == "Wave":
            # Create a single line with 100 points
            points = [10, height / 2] * 100  # Initial flat line
            wave = self.canvas.create_line(points, fill="#ff5500", width=2, smooth=True)
            self.visualization_items.append(wave)

        elif self.current_vis_style == "Particles":
            # Create 80 small particles
            for i in range(80):
                x = random.randint(10, width - 10)
                y = random.randint(10, height - 10)
                particle = self.canvas.create_oval(x - 2, y - 2, x + 2, y + 2, fill="#ffff00", outline="")
                self.visualization_items.append(particle)

        # Start visualization if not already running
        if not self.visualization_running:
            self.visualization_running = True
            self.animate_visualization()

    def update_visualization_style(self, new_style):
        self.current_vis_style = new_style
        self.initialize_visualization()

    def animate_visualization(self):
        if not self.visualization_running:
            return

        width = self.canvas.winfo_width() or 750
        height = self.canvas.winfo_height() or 200

        # Use the audio data from our analyzer
        values = self.audio_data

        # Update visualization based on style
        if self.current_vis_style == "Bars":
            for i, item in enumerate(self.visualization_items):
                if i < len(values):
                    val = values[i % len(values)]
                    bar_height = val * height * 0.8
                    self.canvas.coords(item,
                                       self.canvas.coords(item)[0],
                                       height - bar_height,
                                       self.canvas.coords(item)[2],
                                       height)
                    # Change color based on height
                    r = int(min(255, val * 255 * 2))
                    g = int(min(255, (1 - val) * 255 * 2))
                    b = int(min(255, val * val * 255 * 3))
                    color = f'#{r:02x}{g:02x}{b:02x}'
                    self.canvas.itemconfig(item, fill=color)

        elif self.current_vis_style == "Circles":
            center_x = width / 2
            center_y = height / 2
            for i, item in enumerate(self.visualization_items):
                if i < len(values):
                    # Calculate position on a circle with varying radius
                    angle = (i / len(self.visualization_items)) * 2 * np.pi
                    radius = values[i % len(values)] * height * 0.4
                    x = center_x + np.cos(angle + time.time()) * radius
                    y = center_y + np.sin(angle + time.time()) * radius
                    size = values[i % len(values)] * 15
                    self.canvas.coords(item, x - size, y - size, x + size, y + size)

                    # Change color based on audio intensity
                    intensity = values[i % len(values)]
                    hue = (i / len(self.visualization_items) * 360 + time.time() * 20) % 360
                    # Convert HSV to RGB (simplified)
                    h = hue / 60
                    c = intensity * 0.8 + 0.2  # Keep some color even at low intensities
                    x_val = c * (1 - abs(h % 2 - 1))

                    r, g, b = 0, 0, 0
                    if 0 <= h < 1:
                        r, g, b = c, x_val, 0
                    elif 1 <= h < 2:
                        r, g, b = x_val, c, 0
                    elif 2 <= h < 3:
                        r, g, b = 0, c, x_val
                    elif 3 <= h < 4:
                        r, g, b = 0, x_val, c
                    elif 4 <= h < 5:
                        r, g, b = x_val, 0, c
                    elif 5 <= h < 6:
                        r, g, b = c, 0, x_val

                    color = f'#{int(r * 255):02x}{int(g * 255):02x}{int(b * 255):02x}'
                    self.canvas.itemconfig(item, fill=color)

        elif self.current_vis_style == "Wave":
            if self.visualization_items:
                points = []
                for i in range(100):
                    x = i * width / 99
                    # Create wave with intensity from audio
                    t = time.time()

                    # Use audio data to influence wave height
                    segment_idx = min(int(i / 100 * len(values)), len(values) - 1)
                    intensity = values[segment_idx]

                    y1 = np.sin(i / 10 + t * 5) * intensity * height * 0.3
                    y2 = np.sin(i / 5 - t * 3) * intensity * height * 0.2
                    y = height / 2 + y1 + y2
                    points.extend([x, y])

                self.canvas.coords(self.visualization_items[0], points)

                # Change color based on overall intensity
                avg_intensity = np.mean(values)
                r = int(255 * avg_intensity)
                g = int(128 + 127 * np.sin(time.time()))
                b = int(255 * (1 - avg_intensity))
                color = f'#{r:02x}{g:02x}{b:02x}'
                self.canvas.itemconfig(self.visualization_items[0], fill=color, width=1 + avg_intensity * 5)

        elif self.current_vis_style == "Particles":
            avg_intensity = np.mean(values)
            for i, item in enumerate(self.visualization_items):
                if i < len(values):
                    # Get current position
                    coords = self.canvas.coords(item)
                    if coords:
                        x = (coords[0] + coords[2]) / 2
                        y = (coords[1] + coords[3]) / 2

                        # Calculate new position with audio reactivity
                        center_x, center_y = width / 2, height / 2

                        # More energetic movement with higher audio intensity
                        intensity_factor = values[i % len(values)] * 2

                        dx = (center_x - x) * 0.01 + (random.random() - 0.5) * 10 * intensity_factor
                        dy = (center_y - y) * 0.01 + (random.random() - 0.5) * 10 * intensity_factor

                        x += dx
                        y += dy

                        # Keep particles within bounds
                        x = max(5, min(width - 5, x))
                        y = max(5, min(height - 5, y))

                        # Size based on value and overall intensity
                        size = 2 + values[i % len(values)] * 8 * (0.5 + avg_intensity)

                        self.canvas.coords(item, x - size / 2, y - size / 2, x + size / 2, y + size / 2)

                        # Color based on position, value, and intensity
                        r = int(min(255, avg_intensity * 255))
                        g = int(min(255, values[i % len(values)] * 255))
                        b = int(min(255, (1 - avg_intensity) * 255))
                        color = f'#{r:02x}{g:02x}{b:02x}'
                        self.canvas.itemconfig(item, fill=color)

        # Schedule the next update
        if self.visualization_running:
            self.canvas.after(50, self.animate_visualization)

    def set_volume(self, volume):
        mixer.music.set_volume(float(volume) / 100)

    def play(self):
        if self.music_file:
            if self.is_paused:
                # Resume from paused position
                mixer.music.unpause()
                self.is_paused = False
                self.song_start_time = time.time() - self.paused_position
            else:
                # Start playing from the beginning or from a specific position
                mixer.music.load(self.music_file)
                start_pos = self.paused_position if self.paused_position > 0 else 0
                mixer.music.play(start=start_pos)
                self.song_start_time = time.time() - start_pos

            self.playing_state = True
            self.play_btn.configure(fg_color="#44BB44")  # Change button color
            self.play_btn.configure(text="⏸", command=self.pause)  # Update button

    def pause(self):
        if self.playing_state:
            if not self.is_paused:
                mixer.music.pause()
                self.is_paused = True
                self.paused_position = time.time() - self.song_start_time

                self.playing_state = False
                self.play_btn.configure(fg_color="#3B8ED0")  # Reset button color
                self.play_btn.configure(text="▶", command=self.play)  # Update button
            else:
                # Resume from paused position
                self.play()

    def stop(self):
        mixer.music.stop()
        self.playing_state = False
        self.is_paused = False
        self.paused_position = 0
        self.play_btn.configure(text="▶", fg_color="#3B8ED0", command=self.play)  # Reset button
        self.current_pos = 0
        self.progress_slider.set(0)
        self.current_time_label.configure(text="0:00")


# Run the application
if __name__ == "__main__":
    root = ctk.CTk()
    app = ModernPlayer(root)
    root.mainloop()