struct Song {
    let id: Int
    let title: String
    let artist: String
    let album: String
    let duration: Int // in seconds
    let artwork: String // image name or URL
    let fileURL: URL // URL to audio file
    var isPlaying: Bool = false
}

import AVFoundation

class AudioPlayer {
    static let shared = AudioPlayer()
    private var player: AVPlayer?
    private var currentSong: Song?
    
    func play(song: Song) {
        if currentSong?.id == song.id {
            // If the same song is already playing, toggle play/pause
            if player?.rate == 0 {
                player?.play()
            } else {
                player?.pause()
            }
        } else {
            // Play a new song
            currentSong = song
            player = AVPlayer(url: song.fileURL)
            player?.play()
            
            // Update the isPlaying state of the song
            song.isPlaying = true
        }
    }
    
    func pause() {
        player?.pause()
        if let song = currentSong {
            song.isPlaying = false
        }
    }
    
    func stop() {
        player?.pause()
        player = nil
        if let song = currentSong {
            song.isPlaying = false
        }
    }
    
    func seek(to time: TimeInterval) {
        player?.seek(to: CMTime(seconds: time, preferredTimescale: 1))
    }
}

import SwiftUI
import AVFoundation

struct ContentView: View {
    @State private var songs: [Song] = [
        Song(id: 1, title: "Song 1", artist: "Artist A", album: "Album X", duration: 180, artwork: "song1", fileURL: Bundle.main.url(forResource: "song1", withExtension: "mp3")!),
        Song(id: 2, title: "Song 2", artist: "Artist B", album: "Album Y", duration: 200, artwork: "song2", fileURL: Bundle.main.url(forResource: "song2", withExtension: "mp3")!)
        // Add more songs as needed
    ]
    
    @State private var isPlaying = false
    @State private var currentSong: Song?
    @State private var currentTime: TimeInterval = 0
    @State private var duration: TimeInterval = 0
    
    var body: some View {
        NavigationView {
            VStack {
                if let song = currentSong {
                    VStack {
                        Image(song.artwork)
                            .resizable()
                            .aspectRatio(contentMode: .fit)
                            .frame(width: 200, height: 200)
                        
                        Text(song.title)
                            .font(.title)
                            .padding(.top, 8)
                        
                        Text(song.artist)
                            .font(.headline)
                            .foregroundColor(.gray)
                            .padding(.bottom, 8)
                        
                        Text(timeToString(time: currentTime) + " / " + timeToString(time: duration))
                            .font(.caption)
                            .foregroundColor(.gray)
                            .padding(.bottom, 16)
                        
                        HStack {
                            Button(action: {
                                self.previous()
                            }) {
                                Image(systemName: "backward.fill")
                                    .font(.title)
                                    .foregroundColor(.blue)
                            }
                            .padding(.trailing, 40)
                            
                            Button(action: {
                                self.playPause()
                            }) {
                                Image(systemName: isPlaying ? "pause.circle.fill" : "play.circle.fill")
                                    .font(.system(size: 80))
                                    .foregroundColor(.blue)
                            }
                            
                            Button(action: {
                                self.next()
                            }) {
                                Image(systemName: "forward.fill")
                                    .font(.title)
                                    .foregroundColor(.blue)
                            }
                            .padding(.leading, 40)
                        }
                        .padding(.top, 32)
                        
                        Slider(value: Binding(
                            get: { self.currentTime },
                            set: { newValue in
                                self.seek(to: newValue)
                            }
                        ), in: 0...duration)
                        .padding(.horizontal)
                    }
                    .onAppear {
                        self.play(song: song)
                    }
                } else {
                    Text("Select a song to play")
                        .font(.title)
                        .foregroundColor(.gray)
                }
                
                List(songs, id: \.id) { song in
                    SongRow(song: song, isSelected: song.id == self.currentSong?.id)
                        .onTapGesture {
                            self.currentSong = song
                        }
                }
                .navigationBarTitle("Music Player")
            }
        }
        .onReceive(Timer.publish(every: 1, on: .main, in: .common).autoconnect()) { _ in
            if self.isPlaying, let player = AudioPlayer.shared.player {
                self.currentTime = player.currentTime().seconds
                self.duration = player.currentItem?.duration.seconds ?? 0
            }
        }
    }
    
    private func play(song: Song) {
        AudioPlayer.shared.play(song: song)
        isPlaying = true
    }
    
    private func playPause() {
        if let song = currentSong {
            if isPlaying {
                AudioPlayer.shared.pause()
            } else {
                play(song: song)
            }
            isPlaying.toggle()
        }
    }
    
    private func seek(to time: TimeInterval) {
        AudioPlayer.shared.seek(to: time)
    }
    
    private func next() {
        guard let currentIndex = songs.firstIndex(where: { $0.id == currentSong?.id }), currentIndex < songs.count - 1 else {
            return
        }
        currentSong = songs[currentIndex + 1]
    }
    
    private func previous() {
        guard let currentIndex = songs.firstIndex(where: { $0.id == currentSong?.id }), currentIndex > 0 else {
            return
        }
        currentSong = songs[currentIndex - 1]
    }
    
    private func timeToString(time: TimeInterval) -> String {
        let minutes = Int(time) / 60
        let seconds = Int(time) % 60
        return String(format: "%02d:%02d", minutes, seconds)
    }
}

struct SongRow: View {
    let song: Song
    let isSelected: Bool
    
    var body: some View {
        HStack {
            Image(song.artwork)
                .resizable()
                .aspectRatio(contentMode: .fit)
                .frame(width: 50, height: 50)
            
            VStack(alignment: .leading) {
                Text(song.title)
                    .font(.headline)
                Text(song.artist)
                    .font(.subheadline)
            }
            
            Spacer()
            
            if isSelected {
                Image(systemName: "speaker.fill")
                    .foregroundColor(.blue)
                    .padding(.trailing, 20)
            }
        }
        .padding(8)
    }
}