🎵 MusicKit

import MusicKit
import SwiftUI

@Observable
class MusicAuthManager {
    var authorizationStatus: MusicAuthorization.Status = .notDetermined
    var isSubscriptionActive = false

    // 권한 요청
    func requestAuthorization() async {
        let status = await MusicAuthorization.request()
        authorizationStatus = status

        switch status {
        case .authorized:
            print("✅ Apple Music 권한 승인됨")
            await checkSubscriptionStatus()
        case .denied:
            print("❌ Apple Music 권한 거부됨")
        case .restricted:
            print("⚠️ Apple Music 권한 제한됨")
        case .notDetermined:
            print("🤔 Apple Music 권한 미결정")
        @unknown default:
            break
        }
    }

    // 구독 상태 확인
    func checkSubscriptionStatus() async {
        let subscription = MusicSubscription.current
        isSubscriptionActive = subscription?.canPlayCatalogContent ?? false

        if isSubscriptionActive {
            print("🎵 Apple Music 구독 활성")
        } else {
            print("📱 Apple Music 구독 필요")
        }
    }

    // 현재 권한 상태 확인
    func checkCurrentStatus() {
        authorizationStatus = MusicAuthorization.currentStatus
    }
}

import MusicKit

@Observable
class MusicPlayerManager {
    let player = ApplicationMusicPlayer.shared
    var currentSong: Song?
    var isPlaying = false
    var playbackTime: TimeInterval = 0

    // 단일 곡 재생
    func play(song: Song) async {
        do {
            player.queue = [song]
            try await player.play()
            currentSong = song
            isPlaying = true
            print("▶️ 재생: \(song.title)")
        } catch {
            print("❌ 재생 실패: \(error)")
        }
    }

    // 앨범 재생
    func play(album: Album) async {
        do {
            // 앨범의 모든 트랙 가져오기
            let detailedAlbum = try await album.with([.tracks])
            guard let tracks = detailedAlbum.tracks else { return }

            player.queue = ApplicationMusicPlayer.Queue(tracks)
            try await player.play()
            isPlaying = true
        } catch {
            print("❌ 앨범 재생 실패: \(error)")
        }
    }

    // 재생/일시정지 토글
    func togglePlayPause() async {
        if player.state.playbackStatus == .playing {
            player.pause()
            isPlaying = false
        } else {
            do {
                try await player.play()
                isPlaying = true
            } catch {
                print("❌ 재생 실패: \(error)")
            }
        }
    }

    // 다음 곡
    func skipToNext() async {
        do {
            try await player.skipToNextEntry()
        } catch {
            print("❌ 다음 곡 이동 실패")
        }
    }

    // 이전 곡
    func skipToPrevious() async {
        do {
            try await player.skipToPreviousEntry()
        } catch {
            print("❌ 이전 곡 이동 실패")
        }
    }

    // 재생 위치 변경
    func seek(to time: TimeInterval) {
        player.playbackTime = time
    }

    // 셔플 모드 토글
    func toggleShuffle() {
        player.state.shuffleMode = player.state.shuffleMode == .off ? .songs : .off
    }

    // 반복 모드 변경
    func cycleRepeatMode() {
        switch player.state.repeatMode {
        case .none:
            player.state.repeatMode = .all
        case .all:
            player.state.repeatMode = .one
        case .one:
            player.state.repeatMode = .none
        @unknown default:
            player.state.repeatMode = .none
        }
    }
}

import MusicKit

@Observable
class MusicSearchManager {
    var searchResults: MusicCatalogSearchResponse?
    var songs: [Song] = []
    var albums: [Album] = []
    var artists: [Artist] = []
    var playlists: [Playlist] = []

    // 통합 검색
    func search(term: String) async {
        do {
            var request = MusicCatalogSearchRequest(
                term: term,
                types: [Song.self, Album.self, Artist.self, Playlist.self]
            )
            request.limit = 25

            let response = try await request.response()
            searchResults = response

            songs = Array(response.songs)
            albums = Array(response.albums)
            artists = Array(response.artists)
            playlists = Array(response.playlists)

            print("🔍 검색 결과: 노래 \(songs.count), 앨범 \(albums.count)")
        } catch {
            print("❌ 검색 실패: \(error)")
        }
    }

    // 노래만 검색
    func searchSongs(term: String) async {
        do {
            var request = MusicCatalogSearchRequest(term: term, types: [Song.self])
            request.limit = 50

            let response = try await request.response()
            songs = Array(response.songs)
        } catch {
            print("❌ 노래 검색 실패: \(error)")
        }
    }

    // 아티스트 검색
    func searchArtists(term: String) async {
        do {
            var request = MusicCatalogSearchRequest(term: term, types: [Artist.self])
            request.limit = 25

            let response = try await request.response()
            artists = Array(response.artists)
        } catch {
            print("❌ 아티스트 검색 실패: \(error)")
        }
    }

    // 특정 ID로 노래 가져오기
    func fetchSong(id: MusicItemID) async -> Song? {
        do {
            let request = MusicCatalogResourceRequest<Song>(matching: \.id, equalTo: id)
            let response = try await request.response()
            return response.items.first
        } catch {
            print("❌ 노래 가져오기 실패: \(error)")
            return nil
        }
    }
}

import MusicKit

@Observable
class MusicLibraryManager {
    var librarySongs: [Song] = []
    var libraryPlaylists: [Playlist] = []
    var recentlyPlayed: [RecentlyPlayedMusicItem] = []

    // 라이브러리의 모든 노래 가져오기
    func fetchLibrarySongs() async {
        do {
            let request = MusicLibraryRequest<Song>()
            let response = try await request.response()
            librarySongs = Array(response.items)
            print("📚 라이브러리 노래: \(librarySongs.count)개")
        } catch {
            print("❌ 라이브러리 노래 가져오기 실패: \(error)")
        }
    }

    // 라이브러리 플레이리스트 가져오기
    func fetchLibraryPlaylists() async {
        do {
            let request = MusicLibraryRequest<Playlist>()
            let response = try await request.response()
            libraryPlaylists = Array(response.items)
            print("📚 라이브러리 플레이리스트: \(libraryPlaylists.count)개")
        } catch {
            print("❌ 플레이리스트 가져오기 실패: \(error)")
        }
    }

    // 최근 재생 목록
    func fetchRecentlyPlayed() async {
        do {
            let request = MusicRecentlyPlayedRequest<RecentlyPlayedMusicItem>()
            let response = try await request.response()
            recentlyPlayed = Array(response.items)
            print("🕐 최근 재생: \(recentlyPlayed.count)개")
        } catch {
            print("❌ 최근 재생 가져오기 실패: \(error)")
        }
    }

    // 라이브러리에 노래 추가
    func addToLibrary(song: Song) async {
        do {
            try await MusicLibrary.shared.add(song)
            print("➕ 라이브러리에 추가: \(song.title)")
        } catch {
            print("❌ 라이브러리 추가 실패: \(error)")
        }
    }

    // 라이브러리에 앨범 추가
    func addToLibrary(album: Album) async {
        do {
            try await MusicLibrary.shared.add(album)
            print("➕ 라이브러리에 앨범 추가: \(album.title)")
        } catch {
            print("❌ 앨범 추가 실패: \(error)")
        }
    }
}

import MusicKit

@Observable
class PlaylistManager {
    var playlists: [Playlist] = []

    // 플레이리스트 생성
    func createPlaylist(name: String, description: String, songs: [Song]) async {
        do {
            let playlist = try await MusicLibrary.shared.createPlaylist(
                name: name,
                description: description,
                items: songs
            )
            print("✅ 플레이리스트 생성: \(playlist.name)")
        } catch {
            print("❌ 플레이리스트 생성 실패: \(error)")
        }
    }

    // 플레이리스트에 곡 추가
    func addSongs(to playlist: Playlist, songs: [Song]) async {
        do {
            try await MusicLibrary.shared.add(songs, to: playlist)
            print("➕ \(songs.count)곡 추가됨")
        } catch {
            print("❌ 곡 추가 실패: \(error)")
        }
    }

    // 플레이리스트 상세 정보 가져오기
    func fetchPlaylistDetails(playlist: Playlist) async -> Playlist? {
        do {
            let detailed = try await playlist.with([.tracks, .curator])
            return detailed
        } catch {
            print("❌ 플레이리스트 상세 정보 실패: \(error)")
            return nil
        }
    }
}