812 lines
34 KiB
Swift
812 lines
34 KiB
Swift
import SwiftUI
|
|
|
|
// MARK: - MusicBrainz Models
|
|
|
|
struct MBRecording: Identifiable {
|
|
let id: String
|
|
let title: String
|
|
let artist: String
|
|
let album: String
|
|
let albumArtist: String
|
|
let year: String
|
|
let trackNumber: String
|
|
let discNumber: String
|
|
let genre: String
|
|
let country: String
|
|
let label: String
|
|
}
|
|
|
|
// MARK: - MusicBrainz Service
|
|
|
|
struct MusicBrainzService {
|
|
static let baseURL = "https://musicbrainz.org/ws/2"
|
|
static let userAgent = "NavidromePlayer/1.0 (ca.dallasgroot.navidromeplayer.app)"
|
|
|
|
static func search(title: String, artist: String) async -> [MBRecording] {
|
|
let query = "recording:\"\(title)\" AND artist:\"\(artist)\""
|
|
guard let encoded = query.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
|
|
let url = URL(string: "\(baseURL)/recording?query=\(encoded)&limit=10&fmt=json") else {
|
|
return []
|
|
}
|
|
var req = URLRequest(url: url)
|
|
req.setValue(userAgent, forHTTPHeaderField: "User-Agent")
|
|
req.timeoutInterval = 10
|
|
|
|
guard let (data, _) = try? await URLSession.shared.data(for: req),
|
|
let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
|
|
let recordings = json["recordings"] as? [[String: Any]] else {
|
|
return []
|
|
}
|
|
|
|
var results: [MBRecording] = []
|
|
for rec in recordings {
|
|
let id = rec["id"] as? String ?? UUID().uuidString
|
|
let recTitle = rec["title"] as? String ?? ""
|
|
|
|
// Artist credit
|
|
let credits = rec["artist-credit"] as? [[String: Any]] ?? []
|
|
let artistName = credits.compactMap {
|
|
($0["artist"] as? [String: Any])?["name"] as? String
|
|
}.joined(separator: ", ")
|
|
|
|
// First release
|
|
let releases = rec["releases"] as? [[String: Any]] ?? []
|
|
let release = releases.first
|
|
let albumTitle = release?["title"] as? String ?? ""
|
|
let country = release?["country"] as? String ?? ""
|
|
let releaseDate = release?["date"] as? String ?? ""
|
|
let year = String(releaseDate.prefix(4))
|
|
|
|
// Label
|
|
let labelInfo = (release?["label-info"] as? [[String: Any]])?.first
|
|
let labelName = (labelInfo?["label"] as? [String: Any])?["name"] as? String ?? ""
|
|
|
|
// Track number within release
|
|
let media = release?["media"] as? [[String: Any]]
|
|
let track = (media?.first?["tracks"] as? [[String: Any]])?.first
|
|
let trackPos = (track?["number"] as? String) ?? (track?["position"].map { "\($0)" } ?? "")
|
|
let discPos = media?.first?["position"].map { "\($0)" } ?? ""
|
|
|
|
// Album artist from release artist-credit
|
|
let releaseCredits = release?["artist-credit"] as? [[String: Any]] ?? []
|
|
let releaseArtist = releaseCredits.compactMap {
|
|
($0["artist"] as? [String: Any])?["name"] as? String
|
|
}.joined(separator: ", ")
|
|
|
|
results.append(MBRecording(
|
|
id: id, title: recTitle,
|
|
artist: artistName,
|
|
album: albumTitle,
|
|
albumArtist: releaseArtist.isEmpty ? artistName : releaseArtist,
|
|
year: year,
|
|
trackNumber: trackPos,
|
|
discNumber: discPos == "1" ? "" : discPos,
|
|
genre: "",
|
|
country: country,
|
|
label: labelName
|
|
))
|
|
}
|
|
return results
|
|
}
|
|
|
|
/// Search MusicBrainz by album/release name — used by batch editor.
|
|
static func searchAlbum(album: String, artist: String) async -> [MBRecording] {
|
|
let query = "release:\"\(album)\" AND artist:\"\(artist)\""
|
|
guard let encoded = query.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
|
|
let url = URL(string: "\(baseURL)/release?query=\(encoded)&limit=10&fmt=json") else {
|
|
return []
|
|
}
|
|
var req = URLRequest(url: url)
|
|
req.setValue(userAgent, forHTTPHeaderField: "User-Agent")
|
|
req.timeoutInterval = 10
|
|
|
|
guard let (data, _) = try? await URLSession.shared.data(for: req),
|
|
let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
|
|
let releases = json["releases"] as? [[String: Any]] else {
|
|
return []
|
|
}
|
|
|
|
var results: [MBRecording] = []
|
|
for rel in releases {
|
|
let id = rel["id"] as? String ?? UUID().uuidString
|
|
let title = rel["title"] as? String ?? ""
|
|
let date = rel["date"] as? String ?? ""
|
|
let year = String(date.prefix(4))
|
|
let country = rel["country"] as? String ?? ""
|
|
|
|
let credits = rel["artist-credit"] as? [[String: Any]] ?? []
|
|
let artistName = credits.compactMap {
|
|
($0["artist"] as? [String: Any])?["name"] as? String
|
|
}.joined(separator: ", ")
|
|
|
|
let labelInfo = (rel["label-info"] as? [[String: Any]])?.first
|
|
let labelName = (labelInfo?["label"] as? [String: Any])?["name"] as? String ?? ""
|
|
|
|
// Get track count from media
|
|
let media = rel["media"] as? [[String: Any]] ?? []
|
|
let trackCount = media.compactMap { $0["track-count"] as? Int }.reduce(0, +)
|
|
|
|
results.append(MBRecording(
|
|
id: id, title: title,
|
|
artist: artistName,
|
|
album: title,
|
|
albumArtist: artistName,
|
|
year: year,
|
|
trackNumber: trackCount > 0 ? "\(trackCount) tracks" : "",
|
|
discNumber: media.count > 1 ? "\(media.count) discs" : "",
|
|
genre: "",
|
|
country: country,
|
|
label: labelName
|
|
))
|
|
}
|
|
return results
|
|
}
|
|
}
|
|
|
|
// MARK: - TrackEditorView
|
|
|
|
struct TrackEditorView: View {
|
|
let song: Song
|
|
@Environment(\.dismiss) private var dismiss
|
|
|
|
// Field values
|
|
@State private var title: String
|
|
@State private var artist: String
|
|
@State private var album: String
|
|
@State private var albumArtist: String
|
|
@State private var genre: String
|
|
@State private var year: String
|
|
@State private var trackNumber: String
|
|
@State private var discNumber: String
|
|
|
|
// Checkmarks — only checked fields get sent to the API
|
|
@State private var editTitle = false
|
|
@State private var editArtist = false
|
|
@State private var editAlbum = false
|
|
@State private var editAlbumArtist = false
|
|
@State private var editGenre = false
|
|
@State private var editYear = false
|
|
@State private var editTrackNumber = false
|
|
@State private var editDiscNumber = false
|
|
|
|
// MusicBrainz
|
|
@State private var isSearchingMB = false
|
|
@State private var mbResults: [MBRecording] = []
|
|
@State private var selectedMB: MBRecording?
|
|
@State private var showMBPicker = false
|
|
@State private var mbError: String?
|
|
|
|
// Cover art
|
|
@State private var pendingCoverImage: UIImage? = nil
|
|
@State private var removeCoverArt = false
|
|
@State private var showImagePicker = false
|
|
|
|
@State private var isSaving = false
|
|
@State private var errorMessage: String?
|
|
@State private var showSuccess = false
|
|
|
|
@ObservedObject private var settings = CompanionSettings.shared
|
|
|
|
private let api = CompanionAPIService.shared
|
|
private let accentPink = Color(red: 1.0, green: 0.176, blue: 0.333)
|
|
|
|
private var hasSelection: Bool {
|
|
editTitle || editArtist || editAlbum || editAlbumArtist ||
|
|
editGenre || editYear || editTrackNumber || editDiscNumber ||
|
|
pendingCoverImage != nil || removeCoverArt
|
|
}
|
|
|
|
private var coverArtChanged: Bool { pendingCoverImage != nil || removeCoverArt }
|
|
|
|
/// Live preview of where the file will end up after restructure.
|
|
private var pathPreview: String {
|
|
let aa = albumArtist
|
|
let alb = album
|
|
let t = title
|
|
let tn = Int(trackNumber) ?? (song.track ?? 0)
|
|
let dn = Int(discNumber) ?? (song.discNumber ?? 0)
|
|
let ext = (song.suffix ?? "").isEmpty ? "flac" : (song.suffix ?? "flac")
|
|
|
|
let prefix: String
|
|
if dn > 1 {
|
|
prefix = String(format: "%02d-%02d", dn, tn)
|
|
} else if tn > 0 {
|
|
prefix = String(format: "%02d", tn)
|
|
} else {
|
|
prefix = ""
|
|
}
|
|
|
|
let sanitized = { (s: String) -> String in
|
|
s.replacingOccurrences(of: "[/\\\\:*?\"<>|]", with: "",
|
|
options: .regularExpression).trimmingCharacters(in: .whitespaces)
|
|
}
|
|
|
|
let folder = "\(sanitized(aa.isEmpty ? "Unknown Artist" : aa))/\(sanitized(alb.isEmpty ? "Unknown Album" : alb))"
|
|
let file = prefix.isEmpty ? "\(sanitized(t)).\(ext)" : "\(prefix) \(sanitized(t)).\(ext)"
|
|
return "\(folder)/\(file)"
|
|
}
|
|
|
|
init(song: Song) {
|
|
self.song = song
|
|
_title = State(initialValue: song.title)
|
|
_artist = State(initialValue: song.artist ?? "")
|
|
_album = State(initialValue: song.album ?? "")
|
|
_genre = State(initialValue: song.genre ?? "")
|
|
_year = State(initialValue: song.year.map { "\($0)" } ?? "")
|
|
_trackNumber = State(initialValue: song.track.map { "\($0)" } ?? "")
|
|
_discNumber = State(initialValue: song.discNumber.map { "\($0)" } ?? "")
|
|
_albumArtist = State(initialValue: song.albumArtist ?? song.artist ?? "")
|
|
}
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
List {
|
|
if !settings.isEnabled {
|
|
Section {
|
|
VStack(spacing: 8) {
|
|
Image(systemName: "exclamationmark.triangle")
|
|
.font(.system(size: 28))
|
|
.foregroundColor(.yellow)
|
|
Text("Companion API Required")
|
|
.font(.system(size: 15, weight: .medium))
|
|
Text("Configure the Companion API in Settings to edit track metadata.")
|
|
.font(.system(size: 13))
|
|
.foregroundColor(.gray)
|
|
.multilineTextAlignment(.center)
|
|
}
|
|
.frame(maxWidth: .infinity)
|
|
.padding(.vertical, 12)
|
|
}
|
|
} else {
|
|
// File info + cover art
|
|
Section {
|
|
HStack(alignment: .top, spacing: 12) {
|
|
// File details
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
infoRow("File", song.path ?? song.id)
|
|
if let suffix = song.suffix {
|
|
infoRow("Format", suffix.uppercased())
|
|
}
|
|
if let bitRate = song.bitRate {
|
|
infoRow("Bit Rate", "\(bitRate) kbps")
|
|
}
|
|
}
|
|
Spacer()
|
|
// Cover art thumbnail — top right
|
|
coverArtWidget(songId: song.coverArt)
|
|
}
|
|
} header: {
|
|
Text("File Info")
|
|
}
|
|
|
|
// MusicBrainz suggestion banner
|
|
if let mb = selectedMB {
|
|
Section {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
HStack {
|
|
Image(systemName: "checkmark.seal.fill")
|
|
.foregroundColor(.green)
|
|
.font(.system(size: 13))
|
|
Text("MusicBrainz: \(mb.album)")
|
|
.font(.system(size: 13, weight: .medium))
|
|
.foregroundColor(.white)
|
|
Spacer()
|
|
Button("Change") { showMBPicker = true }
|
|
.font(.system(size: 12))
|
|
.foregroundColor(accentPink)
|
|
}
|
|
if !mb.label.isEmpty {
|
|
Text("\(mb.country) · \(mb.label)")
|
|
.font(.system(size: 11))
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
.padding(.vertical, 2)
|
|
} header: {
|
|
Text("MusicBrainz Match")
|
|
} footer: {
|
|
Text("Tap ↓ next to any field to apply the suggestion.")
|
|
}
|
|
}
|
|
|
|
// Editable fields
|
|
Section {
|
|
mbCheckField("Title", text: $title, isEnabled: $editTitle, mbValue: selectedMB?.title)
|
|
mbCheckField("Artist", text: $artist, isEnabled: $editArtist, mbValue: selectedMB?.artist)
|
|
mbCheckField("Album", text: $album, isEnabled: $editAlbum, mbValue: selectedMB?.album)
|
|
mbCheckField("Album Artist", text: $albumArtist, isEnabled: $editAlbumArtist, mbValue: selectedMB?.albumArtist)
|
|
} header: {
|
|
Text("Basic Info")
|
|
} footer: {
|
|
Text("Check fields you want to change. Only checked fields are updated.")
|
|
}
|
|
|
|
Section {
|
|
mbCheckField("Genre", text: $genre, isEnabled: $editGenre, mbValue: selectedMB?.genre.isEmpty == false ? selectedMB?.genre : nil)
|
|
mbCheckField("Year", text: $year, isEnabled: $editYear, mbValue: selectedMB?.year, keyboard: .numberPad)
|
|
mbCheckField("Track #", text: $trackNumber, isEnabled: $editTrackNumber, mbValue: selectedMB?.trackNumber, keyboard: .numberPad)
|
|
mbCheckField("Disc #", text: $discNumber, isEnabled: $editDiscNumber, mbValue: selectedMB?.discNumber.isEmpty == false ? selectedMB?.discNumber : nil, keyboard: .numberPad)
|
|
} header: {
|
|
Text("Details")
|
|
}
|
|
|
|
// Path preview
|
|
Section {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text("New path")
|
|
.font(.system(size: 11))
|
|
.foregroundColor(.gray)
|
|
Text(pathPreview)
|
|
.font(.system(size: 12, design: .monospaced))
|
|
.foregroundColor(.white.opacity(0.7))
|
|
.lineLimit(3)
|
|
}
|
|
.padding(.vertical, 4)
|
|
} header: {
|
|
Text("After Save")
|
|
} footer: {
|
|
Text("The file will be moved to this path on the server after tags are saved.")
|
|
}
|
|
|
|
if let error = errorMessage {
|
|
Section {
|
|
Text(error)
|
|
.font(.system(size: 13))
|
|
.foregroundColor(.red)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.navigationTitle("Edit Tags")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
.toolbar {
|
|
ToolbarItem(placement: .navigationBarLeading) {
|
|
Button("Cancel") { dismiss() }
|
|
.foregroundColor(.gray)
|
|
}
|
|
ToolbarItem(placement: .navigationBarTrailing) {
|
|
HStack(spacing: 14) {
|
|
// MusicBrainz search button
|
|
Button(action: searchMusicBrainz) {
|
|
if isSearchingMB {
|
|
ProgressView().tint(.white).scaleEffect(0.8)
|
|
} else {
|
|
Image(systemName: "magnifyingglass")
|
|
.foregroundColor(selectedMB != nil ? .green : .white)
|
|
}
|
|
}
|
|
.disabled(isSearchingMB)
|
|
|
|
if settings.isEnabled {
|
|
Button(action: save) {
|
|
if isSaving {
|
|
ProgressView().tint(accentPink)
|
|
} else {
|
|
Text("Save")
|
|
.fontWeight(.semibold)
|
|
.foregroundColor(hasSelection ? accentPink : .gray)
|
|
}
|
|
}
|
|
.disabled(isSaving || !hasSelection || song.path == nil)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.sheet(isPresented: $showMBPicker) {
|
|
MusicBrainzPickerSheet(
|
|
results: mbResults,
|
|
onSelect: { rec in
|
|
selectedMB = rec
|
|
showMBPicker = false
|
|
}
|
|
)
|
|
}
|
|
.sheet(isPresented: $showImagePicker) {
|
|
ImagePickerView { image in
|
|
pendingCoverImage = image
|
|
removeCoverArt = false
|
|
}
|
|
}
|
|
.overlay {
|
|
if showSuccess {
|
|
VStack(spacing: 12) {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.font(.system(size: 44))
|
|
.foregroundColor(.green)
|
|
Text("Tags Updated")
|
|
.font(.system(size: 16, weight: .medium))
|
|
.foregroundColor(.white)
|
|
Text("File moved to new path")
|
|
.font(.system(size: 13))
|
|
.foregroundColor(.gray)
|
|
}
|
|
.padding(30)
|
|
.background(.ultraThinMaterial)
|
|
.cornerRadius(16)
|
|
.transition(.scale.combined(with: .opacity))
|
|
}
|
|
}
|
|
.task {
|
|
await fetchCompanionDetails()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - MusicBrainz Search
|
|
|
|
private func searchMusicBrainz() {
|
|
isSearchingMB = true
|
|
mbError = nil
|
|
Task {
|
|
let results = await MusicBrainzService.search(title: title, artist: artist)
|
|
await MainActor.run {
|
|
isSearchingMB = false
|
|
if results.isEmpty {
|
|
mbError = "No results found on MusicBrainz"
|
|
errorMessage = mbError
|
|
} else {
|
|
mbResults = results
|
|
showMBPicker = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Fetch companion details to populate album artist + disc number
|
|
|
|
private func fetchCompanionDetails() async {
|
|
guard let path = song.path,
|
|
let baseURL = CompanionSettings.shared.baseURL else { return }
|
|
|
|
var components = URLComponents(url: baseURL.appendingPathComponent("library/songs"), resolvingAgainstBaseURL: false)
|
|
components?.queryItems = [URLQueryItem(name: "album", value: song.album ?? "")]
|
|
guard let url = components?.url,
|
|
let (data, _) = try? await URLSession.shared.data(from: url),
|
|
let response = try? JSONDecoder().decode(CompanionLibraryResponse.self, from: data),
|
|
let songs = response.songs else { return }
|
|
|
|
if let match = songs.first(where: { $0.relative_path == path || path.hasSuffix($0.relative_path) }) {
|
|
await MainActor.run {
|
|
if albumArtist.isEmpty || albumArtist == (song.artist ?? "") {
|
|
albumArtist = match.album_artist
|
|
}
|
|
if discNumber.isEmpty, let dn = match.disc_number {
|
|
discNumber = "\(dn)"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Save
|
|
|
|
private func save() {
|
|
guard let path = song.path else { return }
|
|
isSaving = true
|
|
errorMessage = nil
|
|
|
|
Task {
|
|
do {
|
|
// Handle cover art first
|
|
if let image = pendingCoverImage {
|
|
if let companionId = companionSongId() {
|
|
try await api.uploadCoverArt(songId: companionId, image: image)
|
|
} else if let path = song.path {
|
|
// Fallback: no companion ID — use relative path endpoint
|
|
try await api.uploadCoverArtByPath(relativePath: path, image: image)
|
|
}
|
|
} else if removeCoverArt, let companionId = companionSongId() {
|
|
try await api.deleteCoverArt(songId: companionId)
|
|
}
|
|
|
|
// Only send metadata edit if any tag fields are checked
|
|
let hasTagChanges = editTitle || editArtist || editAlbum || editAlbumArtist ||
|
|
editGenre || editYear || editTrackNumber || editDiscNumber
|
|
if hasTagChanges {
|
|
let request = MetadataEditRequest(
|
|
relativePath: path,
|
|
title: editTitle ? (title.isEmpty ? nil : title) : nil,
|
|
artist: editArtist ? (artist.isEmpty ? nil : artist) : nil,
|
|
album: editAlbum ? (album.isEmpty ? nil : album) : nil,
|
|
albumArtist: editAlbumArtist ? (albumArtist.isEmpty ? nil : albumArtist) : nil,
|
|
genre: editGenre ? (genre.isEmpty ? nil : genre) : nil,
|
|
year: editYear ? Int(year) : nil,
|
|
trackNumber: editTrackNumber ? Int(trackNumber) : nil
|
|
)
|
|
|
|
try await api.editMetadata(request)
|
|
|
|
WatchConnectivityManager.shared.notifyTagsUpdated(
|
|
songId: song.id,
|
|
title: request.title,
|
|
artist: request.artist,
|
|
album: request.album,
|
|
albumArtist: request.albumArtist
|
|
)
|
|
}
|
|
|
|
await MainActor.run {
|
|
isSaving = false
|
|
withAnimation { showSuccess = true }
|
|
DebugLogger.shared.log("Tags updated: \(title) — \(artist)", category: "Companion")
|
|
}
|
|
|
|
try? await Task.sleep(for: .seconds(1.2))
|
|
await MainActor.run { dismiss() }
|
|
|
|
} catch {
|
|
await MainActor.run {
|
|
isSaving = false
|
|
errorMessage = error.localizedDescription
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Extract the Companion song ID from coverArt field ("companion:{id}")
|
|
private func companionSongId() -> String? {
|
|
guard let coverArt = song.coverArt, coverArt.hasPrefix("companion:") else { return nil }
|
|
return String(coverArt.dropFirst("companion:".count))
|
|
}
|
|
|
|
// MARK: - Info Row (read-only)
|
|
|
|
private func infoRow(_ label: String, _ value: String) -> some View {
|
|
HStack {
|
|
Text(label).foregroundColor(.gray)
|
|
Spacer()
|
|
Text(value).foregroundColor(.white.opacity(0.7)).lineLimit(1)
|
|
}
|
|
.font(.system(size: 14))
|
|
}
|
|
|
|
// MARK: - Cover Art Widget
|
|
|
|
private func coverArtWidget(songId: String?) -> some View {
|
|
CoverArtEditorWidget(
|
|
existingCoverArtId: songId,
|
|
pendingImage: $pendingCoverImage,
|
|
removeArt: $removeCoverArt,
|
|
showPicker: $showImagePicker,
|
|
size: 72
|
|
)
|
|
}
|
|
|
|
// MARK: - Checkmark Field with optional MusicBrainz suggestion
|
|
|
|
private func mbCheckField(
|
|
_ label: String,
|
|
text: Binding<String>,
|
|
isEnabled: Binding<Bool>,
|
|
mbValue: String?,
|
|
keyboard: UIKeyboardType = .default
|
|
) -> some View {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
HStack(spacing: 10) {
|
|
Button(action: { isEnabled.wrappedValue.toggle() }) {
|
|
Image(systemName: isEnabled.wrappedValue ? "checkmark.circle.fill" : "circle")
|
|
.font(.system(size: 20))
|
|
.foregroundColor(isEnabled.wrappedValue ? accentPink : .gray.opacity(0.4))
|
|
}
|
|
.buttonStyle(.plain)
|
|
|
|
Text(label)
|
|
.foregroundColor(isEnabled.wrappedValue ? .white : .gray)
|
|
.frame(width: 85, alignment: .leading)
|
|
|
|
TextField(label, text: text)
|
|
.keyboardType(keyboard)
|
|
.multilineTextAlignment(.trailing)
|
|
.foregroundColor(isEnabled.wrappedValue ? .white : .gray.opacity(0.5))
|
|
.disabled(!isEnabled.wrappedValue)
|
|
.keyboardDoneButton()
|
|
}
|
|
.font(.system(size: 13))
|
|
|
|
// MusicBrainz suggestion pill — only show if different from current value
|
|
if let mb = mbValue, !mb.isEmpty, mb != text.wrappedValue {
|
|
Button(action: {
|
|
text.wrappedValue = mb
|
|
isEnabled.wrappedValue = true
|
|
}) {
|
|
HStack(spacing: 4) {
|
|
Image(systemName: "arrow.down.circle.fill")
|
|
.font(.system(size: 10))
|
|
Text(mb)
|
|
.font(.system(size: 11))
|
|
.lineLimit(1)
|
|
}
|
|
.foregroundColor(.white)
|
|
.padding(.horizontal, 8)
|
|
.padding(.vertical, 3)
|
|
.background(Color.blue.opacity(0.35))
|
|
.cornerRadius(8)
|
|
}
|
|
.buttonStyle(.plain)
|
|
.padding(.leading, 30)
|
|
}
|
|
}
|
|
.padding(.vertical, mbValue != nil && mbValue != text.wrappedValue ? 2 : 0)
|
|
}
|
|
}
|
|
|
|
// MARK: - MusicBrainz Picker Sheet
|
|
|
|
struct MusicBrainzPickerSheet: View {
|
|
let results: [MBRecording]
|
|
let onSelect: (MBRecording) -> Void
|
|
@Environment(\.dismiss) private var dismiss
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
List(results) { rec in
|
|
Button(action: { onSelect(rec) }) {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text(rec.title)
|
|
.font(.system(size: 14, weight: .semibold))
|
|
.foregroundColor(.white)
|
|
Text(rec.artist)
|
|
.font(.system(size: 13))
|
|
.foregroundColor(.gray)
|
|
HStack(spacing: 8) {
|
|
if !rec.album.isEmpty {
|
|
Text(rec.album)
|
|
.font(.system(size: 12))
|
|
.foregroundColor(.white.opacity(0.6))
|
|
}
|
|
if !rec.year.isEmpty {
|
|
Text(rec.year)
|
|
.font(.system(size: 12))
|
|
.foregroundColor(.white.opacity(0.5))
|
|
}
|
|
if !rec.country.isEmpty {
|
|
Text(rec.country)
|
|
.font(.system(size: 11))
|
|
.foregroundColor(.white.opacity(0.4))
|
|
}
|
|
if !rec.trackNumber.isEmpty {
|
|
Text("Track \(rec.trackNumber)")
|
|
.font(.system(size: 11))
|
|
.foregroundColor(.white.opacity(0.4))
|
|
}
|
|
}
|
|
if !rec.label.isEmpty {
|
|
Text(rec.label)
|
|
.font(.system(size: 11))
|
|
.foregroundColor(.gray.opacity(0.7))
|
|
}
|
|
}
|
|
.padding(.vertical, 4)
|
|
}
|
|
.buttonStyle(.plain)
|
|
}
|
|
.navigationTitle("MusicBrainz Results")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
.toolbar {
|
|
ToolbarItem(placement: .navigationBarTrailing) {
|
|
Button("Cancel") { dismiss() }
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Cover Art Widget (shared by TrackEditorView and BatchAlbumEditorSheet)
|
|
|
|
struct CoverArtEditorWidget: View {
|
|
let existingCoverArtId: String?
|
|
@Binding var pendingImage: UIImage?
|
|
@Binding var removeArt: Bool
|
|
@Binding var showPicker: Bool
|
|
let size: CGFloat
|
|
|
|
private var isChanged: Bool { pendingImage != nil || removeArt }
|
|
|
|
var body: some View {
|
|
ZStack(alignment: .bottomTrailing) {
|
|
Group {
|
|
if let img = pendingImage {
|
|
Image(uiImage: img)
|
|
.resizable().scaledToFill()
|
|
} else if removeArt {
|
|
ZStack {
|
|
Color.gray.opacity(0.2)
|
|
Image(systemName: "photo.slash")
|
|
.font(.system(size: size * 0.35))
|
|
.foregroundColor(.gray)
|
|
}
|
|
} else if let id = existingCoverArtId,
|
|
id.hasPrefix("companion:"),
|
|
let url = CompanionSettings.shared.baseURL?
|
|
.appendingPathComponent("library/cover-art/\(id.dropFirst("companion:".count))") {
|
|
AsyncImage(url: url) { phase in
|
|
switch phase {
|
|
case .success(let img): img.resizable().scaledToFill()
|
|
default:
|
|
ZStack {
|
|
Color.gray.opacity(0.15)
|
|
Image(systemName: "music.note")
|
|
.font(.system(size: size * 0.35))
|
|
.foregroundColor(.gray)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
ZStack {
|
|
Color.gray.opacity(0.15)
|
|
Image(systemName: "photo.badge.plus")
|
|
.font(.system(size: size * 0.35))
|
|
.foregroundColor(.gray.opacity(0.7))
|
|
}
|
|
}
|
|
}
|
|
.frame(width: size, height: size)
|
|
.clipShape(RoundedRectangle(cornerRadius: 6))
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 6)
|
|
.stroke(isChanged ? Color.red.opacity(0.9) : Color.clear, lineWidth: 2)
|
|
.shadow(color: isChanged ? .red.opacity(0.6) : .clear, radius: 4)
|
|
)
|
|
|
|
if pendingImage != nil || (existingCoverArtId != nil && !removeArt) {
|
|
Menu {
|
|
Button { showPicker = true } label: {
|
|
Label("Replace", systemImage: "photo")
|
|
}
|
|
Button(role: .destructive) {
|
|
pendingImage = nil
|
|
removeArt = true
|
|
} label: {
|
|
Label("Remove", systemImage: "trash")
|
|
}
|
|
} label: {
|
|
Image(systemName: "ellipsis.circle.fill")
|
|
.font(.system(size: 18))
|
|
.foregroundColor(.white)
|
|
.shadow(radius: 2)
|
|
}
|
|
.offset(x: 4, y: 4)
|
|
}
|
|
}
|
|
.frame(width: size, height: size)
|
|
.onTapGesture {
|
|
if pendingImage == nil && existingCoverArtId == nil {
|
|
showPicker = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Image Picker (UIKit wrapper)
|
|
|
|
struct ImagePickerView: UIViewControllerRepresentable {
|
|
let onPick: (UIImage) -> Void
|
|
|
|
func makeCoordinator() -> Coordinator { Coordinator(onPick: onPick) }
|
|
|
|
func makeUIViewController(context: Context) -> UIImagePickerController {
|
|
let picker = UIImagePickerController()
|
|
picker.sourceType = .photoLibrary
|
|
picker.allowsEditing = true
|
|
picker.delegate = context.coordinator
|
|
return picker
|
|
}
|
|
|
|
func updateUIViewController(_ uiViewController: UIImagePickerController, context: Context) {}
|
|
|
|
class Coordinator: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
|
|
let onPick: (UIImage) -> Void
|
|
init(onPick: @escaping (UIImage) -> Void) { self.onPick = onPick }
|
|
|
|
func imagePickerController(_ picker: UIImagePickerController,
|
|
didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
|
|
let img = (info[.editedImage] ?? info[.originalImage]) as? UIImage
|
|
picker.dismiss(animated: true)
|
|
if let img { onPick(img) }
|
|
}
|
|
|
|
func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
|
|
picker.dismiss(animated: true)
|
|
}
|
|
}
|
|
}
|