1. 모델 (Models)

// Song 모델
struct Song: Identifiable {
    let id: UUID = UUID()
    let title: String
    let artist: String
    let albumName: String
    let duration: TimeInterval
    let artworkURL: URL?
    var isFavorite: Bool = false
}

// Album 모델
struct Album: Identifiable {
    let id: UUID = UUID()
    let title: String
    let artist: String
    let releaseYear: Int
    let artworkURL: URL?
    var songs: [Song]
}

// Artist 모델
struct Artist: Identifiable {
    let id: UUID = UUID()
    let name: String
    let bio: String?
    let imageURL: URL?
    var albums: [Album]
}

// Playlist 모델
class Playlist: Identifiable, ObservableObject {
    let id: UUID = UUID()
    let name: String
    let createdBy: String
    let createdDate: Date
    @Published var songs: [Song]
    
    init(name: String, createdBy: String, songs: [Song] = []) {
        self.name = name
        self.createdBy = createdBy
        self.createdDate = Date()
        self.songs = songs
    }
    
    func addSong(_ song: Song) {
        songs.append(song)
    }
    
    func removeSong(at index: Int) {
        guard index >= 0 && index < songs.count else { return }
        songs.remove(at: index)
    }
}

2. 서비스 (Services)

// 음악 플레이어 서비스 프로토콜
protocol MusicPlayerServiceProtocol {
    var currentSong: Song? { get }
    var isPlaying: Bool { get }
    var currentTime: TimeInterval { get }
    
    func play(_ song: Song)
    func pause()
    func resume()
    func stop()
    func next()
    func previous()
}

// 음악 플레이어 서비스 구현
class MusicPlayerService: MusicPlayerServiceProtocol, ObservableObject {
    @Published private(set) var currentSong: Song?
    @Published private(set) var isPlaying: Bool = false
    @Published private(set) var currentTime: TimeInterval = 0
    
    private var timer: Timer?
    private var queue: [Song] = []
    private var currentIndex: Int = 0
    
    func play(_ song: Song) {
        currentSong = song
        isPlaying = true
        currentTime = 0
        startTimer()
        print("재생 중: \(song.title) - \(song.artist)")
    }
    
    func pause() {
        isPlaying = false
        stopTimer()
        print("일시정지됨")
    }
    
    func resume() {
        if currentSong != nil {
            isPlaying = true
            startTimer()
            print("재생 재개")
        }
    }
    
    func stop() {
        isPlaying = false
        currentSong = nil
        currentTime = 0
        stopTimer()
        print("정지됨")
    }
    
    func next() {
        guard !queue.isEmpty else { return }
        currentIndex = (currentIndex + 1) % queue.count
        play(queue[currentIndex])
    }
    
    func previous() {
        guard !queue.isEmpty else { return }
        currentIndex = (currentIndex - 1 + queue.count) % queue.count
        play(queue[currentIndex])
    }
    
    func setQueue(_ songs: [Song]) {
        queue = songs
        currentIndex = 0
    }
    
    private func startTimer() {
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            guard let self = self, self.isPlaying, let song = self.currentSong else { return }
            self.currentTime += 1
            
            // 노래가 끝나면 다음 곡으로
            if self.currentTime >= song.duration {
                self.next()
            }
        }
    }
    
    private func stopTimer() {
        timer?.invalidate()
        timer = nil
    }
    
    deinit {
        stopTimer()
    }
}

// 음악 라이브러리 서비스
class MusicLibraryService {
    private(set) var songs: [Song] = []
    private(set) var albums: [Album] = []
    private(set) var artists: [Artist] = []
    private(set) var playlists: [Playlist] = []
    
    func fetchLibrary() async throws {
        // 실제로는 API나 로컬 DB에서 데이터를 가져오는 로직
        // 여기서는 더미 데이터로 대체
        try await Task.sleep(nanoseconds: 1_000_000_000) // 1초 지연
        
        // 더미 데이터 생성
        let dummySongs = createDummySongs()
        let dummyAlbums = createDummyAlbums(with: dummySongs)
        let dummyArtists = createDummyArtists(with: dummyAlbums)
        
        // 메인 스레드에서 UI 업데이트
        await MainActor.run {
            self.songs = dummySongs
            self.albums = dummyAlbums
            self.artists = dummyArtists
            self.playlists = [
                Playlist(name: "내가 좋아하는 노래", createdBy: "나", songs: Array(dummySongs.prefix(5))),
                Playlist(name: "드라이브 음악", createdBy: "나", songs: Array(dummySongs.suffix(3)))
            ]
        }
    }
    
    // 더미 데이터 생성 메서드들...
    private func createDummySongs() -> [Song] {
        // 더미 Song 객체들 생성
        return []
    }
    
    private func createDummyAlbums(with songs: [Song]) -> [Album] {
        // 더미 Album 객체들 생성
        return []
    }
    
    private func createDummyArtists(with albums: [Album]) -> [Artist] {
        // 더미 Artist 객체들 생성
        return []
    }
}

3. 뷰모델 (ViewModels)

// 플레이어 뷰모델
class PlayerViewModel: ObservableObject {
    @Published var currentSongTitle: String = ""
    @Published var currentArtist: String = ""
    @Published var currentAlbum: String = ""
    @Published var isPlaying: Bool = false
    @Published var currentTime: TimeInterval = 0
    @Published var duration: TimeInterval = 0
    @Published var progress: Float = 0
    
    private let playerService: MusicPlayerServiceProtocol
    private var cancellables = Set<anycancellable>()
    
    init(playerService: MusicPlayerServiceProtocol) {
        self.playerService = playerService
        
        // 서비스의 상태 변화 관찰
        if let service = playerService as? MusicPlayerService {
            service.$currentSong
                .sink { [weak self] song in
                    guard let song = song else {
                        self?.resetUI()
                        return
                    }
                    self?.updateUI(with: song)
                }
                .store(in: &cancellables)
            
            service.$isPlaying
                .assign(to: &$isPlaying)
            
            service.$currentTime
                .sink { [weak self] time in
                    guard let self = self else { return }
                    self.currentTime = time
                    if self.duration > 0 {
                        self.progress = Float(time / self.duration)
                    }
                }
                .store(in: &cancellables)
        }
    }
    
    func playSong(_ song: Song) {
        playerService.play(song)
    }
    
    func togglePlayPause() {
        if isPlaying {
            playerService.pause()
        } else {
            playerService.resume()
        }
    }
    
    func nextSong() {
        playerService.next()
    }
    
    func previousSong() {
        playerService.previous()
    }
    
    private func updateUI(with song: Song) {
        currentSongTitle = song.title
        currentArtist = song.artist
        currentAlbum = song.albumName
        duration = song.duration
    }
    
    private func resetUI() {
        currentSongTitle = ""
        currentArtist = ""
        currentAlbum = ""
        duration = 0
        progress = 0
    }
}</anycancellable>

4. SwiftUI 뷰 (간단한 예시)

import SwiftUI

struct PlayerView: View {
    @ObservedObject var viewModel: PlayerViewModel
    
    var body: some View {
        VStack(spacing: 20) {
            // 앨범 아트워크
            RoundedRectangle(cornerRadius: 12)
                .fill(Color.gray.opacity(0.3))
                .frame(width: 300, height: 300)
                .overlay(
                    Text("앨범 아트")
                        .font(.title)
                        .foregroundColor(.gray)
                )
            
            // 곡 정보
            VStack(spacing: 8) {
                Text(viewModel.currentSongTitle.isEmpty ? "재생 중인 곡 없음" : viewModel.currentSongTitle)
                    .font(.title)
                    .fontWeight(.bold)
                
                Text(viewModel.currentArtist.isEmpty ? "-" : viewModel.currentArtist)
                    .font(.title3)
                    .foregroundColor(.secondary)
                
                Text(viewModel.currentAlbum.isEmpty ? "-" : viewModel.currentAlbum)
                    .font(.subheadline)
                    .foregroundColor(.secondary)
            }
            .padding()
            
            // 진행 상태 바
            ProgressView(value: viewModel.progress)
                .padding(.horizontal)
            
            // 시간 표시
            HStack {
                Text(formatTime(viewModel.currentTime))
                Spacer()
                Text(formatTime(viewModel.duration))
            }
            .font(.caption)
            .padding(.horizontal)
            
            // 컨트롤 버튼
            HStack(spacing: 40) {
                Button(action: viewModel.previousSong) {
                    Image(systemName: "backward.fill")
                        .font(.title)
                }
                
                Button(action: viewModel.togglePlayPause) {
                    Image(systemName: viewModel.isPlaying ? "pause.circle.fill" : "play.circle.fill")
                        .font(.system(size: 60))
                }
                
                Button(action: viewModel.nextSong) {
                    Image(systemName: "forward.fill")
                        .font(.title)
                }
            }
            .padding()
        }
        .padding()
    }
    
    private func formatTime(_ timeInterval: TimeInterval) -> String {
        let minutes = Int(timeInterval) / 60
        let seconds = Int(timeInterval) % 60
        return String(format: "%d:%02d", minutes, seconds)
    }
}