v7.1.0

- Extract year from releaseDate using substring(0, 4) in both hooks
- Add year field to templateData in single download functions
- Add year field to templateData in bulk download functions
- Allows parseTemplate() to correctly replace {year} placeholder instead of defaulting to '0000'
- Fixes folder structure generation when year is used in filename or folder templates

Co-authored-by: Diego Glez <diego@example.com>

.github/workflows/build.yml

@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  GO_VERSION: '1.25.5'
+  GO_VERSION: '1.26'
   NODE_VERSION: '24'
 
 jobs:

README.md

@@ -1,12 +1,12 @@
 [![GitHub All Releases](https://img.shields.io/github/downloads/afkarxyz/SpotiFLAC/total?style=for-the-badge)](https://github.com/afkarxyz/SpotiFLAC/releases)
-
-<!-- ![Maintenance](https://maintenance.afkarxyz.fun?v=3) -->
+[![Telegram Channel](https://img.shields.io/badge/CHANNEL-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/spotiflac)
+[![Telegram Community](https://img.shields.io/badge/COMMUNITY-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/spotiflac_chat)
 
 ![Image](https://github.com/user-attachments/assets/a6e92fdd-2944-45c1-83e8-e23a26c827af)
 
 <div align="center">
 
-Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account required.
+Get Spotify tracks in true FLAC from Tidal, Qobuz, Amazon Music & Deezer — no account required.
 
 ![Windows](https://img.shields.io/badge/Windows-10%2B-0078D6?style=for-the-badge&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI1MTIiIGhlaWdodD0iNTEyIiB2aWV3Qm94PSIwIDAgMjAgMjAiPjxwYXRoIGZpbGw9IiNmZmZmZmYiIGZpbGwtcnVsZT0iZXZlbm9kZCIgZD0iTTIwIDEwLjg3M1YyMEw4LjQ3OSAxOC41MzdsLjAwMS03LjY2NEgyMFptLTEzLjEyIDBsLS4wMDEgNy40NjFMMCAxNy40NjF2LTYuNTg4aDYuODhaTTIwIDkuMjczSDguNDhsLS4wMDEtNy44MUwyMCAwdjkuMjczWk02Ljg3OSAxLjY2NmwuMDAxIDcuNjA3SDBWMi41MzlsNi44NzktLjg3M1oiLz48L3N2Zz4=)
 ![macOS](https://img.shields.io/badge/macOS-10.13%2B-000000?style=for-the-badge&logo=apple&logoColor=white)
@@ -20,7 +20,7 @@ Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account
 
 ## Screenshot
 
-![Image](https://github.com/user-attachments/assets/eba25a4a-0eb9-4d88-9646-80c7658a7de6)
+![Image](https://github.com/user-attachments/assets/adbdc056-bace-44a9-8ba6-898b4526b65a)
 
 ## Other projects
 
@@ -94,8 +94,7 @@ The software is provided "as is", without warranty of any kind. The author assum
 
 ## API Credits
 
-- **Tidal**: [hifi-api](https://github.com/binimum/hifi-api)
-- **Qobuz**: [dabmusic.xyz](https://dabmusic.xyz), [squid.wtf](https://squid.wtf), [jumo-dl](https://jumo-dl.pages.dev/)
+[MusicBrainz](https://musicbrainz.org) · [Spotify Lyrics API](https://github.akashrchandran.in/spotify-lyrics-api) · [LRCLIB](https://lrclib.net) · [Song.link](https://song.link) · [hifi-api](https://github.com/binimum/hifi-api) · [dabmusic.xyz](https://dabmusic.xyz) · [yoinkify.lol](https://yoinkify.lol)
 
 > [!TIP]
 >

app.go

@@ -8,21 +8,15 @@ import (
 	"os"
 
 	"path/filepath"
-	"regexp"
 
-	"spotiflac/backend"
 	"strings"
 	"time"
 
+	"github.com/afkarxyz/SpotiFLAC/backend"
+
 	"github.com/wailsapp/wails/v2/pkg/runtime"
 )
 
-var isrcRegex = regexp.MustCompile(`^[A-Z]{2}[A-Z0-9]{3}\d{2}\d{5}$`)
-
-func isValidISRC(isrc string) bool {
-	return isrcRegex.MatchString(isrc)
-}
-
 type App struct {
 	ctx context.Context
 }
@@ -31,6 +25,19 @@ func NewApp() *App {
 	return &App{}
 }
 
+func (a *App) getFirstArtist(artistString string) string {
+	if artistString == "" {
+		return ""
+	}
+	delimiters := []string{", ", " & ", " feat. ", " ft. ", " featuring "}
+	for _, d := range delimiters {
+		if idx := strings.Index(strings.ToLower(artistString), d); idx != -1 {
+			return strings.TrimSpace(artistString[:idx])
+		}
+	}
+	return artistString
+}
+
 func (a *App) startup(ctx context.Context) {
 	a.ctx = ctx
 
@@ -51,7 +58,6 @@ type SpotifyMetadataRequest struct {
 }
 
 type DownloadRequest struct {
-	ISRC                 string `json:"isrc"`
 	Service              string `json:"service"`
 	Query                string `json:"query,omitempty"`
 	TrackName            string `json:"track_name,omitempty"`
@@ -82,6 +88,9 @@ type DownloadRequest struct {
 	PlaylistName         string `json:"playlist_name,omitempty"`
 	PlaylistOwner        string `json:"playlist_owner,omitempty"`
 	AllowFallback        bool   `json:"allow_fallback"`
+	UseFirstArtistOnly   bool   `json:"use_first_artist_only,omitempty"`
+	UseSingleGenre       bool   `json:"use_single_genre,omitempty"`
+	EmbedGenre           bool   `json:"embed_genre,omitempty"`
 }
 
 type DownloadResponse struct {
@@ -128,6 +137,27 @@ func (a *App) GetSpotifyMetadata(req SpotifyMetadataRequest) (string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(req.Timeout*float64(time.Second)))
 	defer cancel()
 
+	settings, err := a.LoadSettings()
+
+	if err == nil && settings != nil {
+		if useAPI, ok := settings["useSpotFetchAPI"].(bool); ok && useAPI {
+			if apiURL, ok := settings["spotFetchAPIUrl"].(string); ok && apiURL != "" {
+
+				data, err := backend.GetSpotifyDataWithAPI(ctx, req.URL, true, apiURL, req.Batch, time.Duration(req.Delay*float64(time.Second)))
+				if err != nil {
+					return "", fmt.Errorf("failed to fetch metadata from API: %v", err)
+				}
+
+				jsonData, err := json.MarshalIndent(data, "", "  ")
+				if err != nil {
+					return "", fmt.Errorf("failed to encode response: %v", err)
+				}
+
+				return string(jsonData), nil
+			}
+		}
+	}
+
 	data, err := backend.GetFilteredSpotifyData(ctx, req.URL, req.Batch, time.Duration(req.Delay*float64(time.Second)))
 	if err != nil {
 		return "", fmt.Errorf("failed to fetch metadata: %v", err)
@@ -189,7 +219,7 @@ func (a *App) SearchSpotifyByType(req SpotifySearchByTypeRequest) ([]backend.Sea
 
 func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 
-	if req.Service == "qobuz" && req.ISRC == "" && req.SpotifyID == "" {
+	if req.Service == "qobuz" && req.SpotifyID == "" {
 		return DownloadResponse{
 			Success: false,
 			Error:   "Spotify ID is required for Qobuz",
@@ -305,89 +335,76 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 		}
 	}
 
+	lyricsChan := make(chan string, 1)
+	isrcChan := make(chan string, 1)
+
+	if req.SpotifyID != "" {
+		if req.EmbedLyrics {
+			go func() {
+				client := backend.NewLyricsClient()
+				resp, _, err := client.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName, req.Duration)
+				if err == nil && resp != nil && len(resp.Lines) > 0 {
+					lrc := client.ConvertToLRC(resp, req.TrackName, req.ArtistName)
+					lyricsChan <- lrc
+				} else {
+					lyricsChan <- ""
+				}
+			}()
+		} else {
+			close(lyricsChan)
+		}
+
+		go func() {
+			client := backend.NewSongLinkClient()
+			isrc, _ := client.GetISRC(req.SpotifyID)
+			isrcChan <- isrc
+		}()
+	} else {
+		close(lyricsChan)
+		close(isrcChan)
+	}
+
 	switch req.Service {
 	case "amazon":
+
 		downloader := backend.NewAmazonDownloader()
 		if req.ServiceURL != "" {
-			filename, err = downloader.DownloadByURL(req.ServiceURL, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.PlaylistName, req.PlaylistOwner, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.CoverURL, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.EmbedMaxQualityCover, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL)
+			filename, err = downloader.DownloadByURL(req.ServiceURL, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.PlaylistName, req.PlaylistOwner, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.CoverURL, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.EmbedMaxQualityCover, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 		} else {
-			if req.SpotifyID == "" {
-				return DownloadResponse{
-					Success: false,
-					Error:   "Spotify ID is required for Amazon Music",
-				}, fmt.Errorf("spotify ID is required for Amazon Music")
-			}
-			filename, err = downloader.DownloadBySpotifyID(req.SpotifyID, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.PlaylistName, req.PlaylistOwner, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.CoverURL, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.EmbedMaxQualityCover, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL)
+			filename, err = downloader.DownloadBySpotifyID(req.SpotifyID, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.PlaylistName, req.PlaylistOwner, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.CoverURL, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.EmbedMaxQualityCover, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 		}
 
 	case "tidal":
 		if req.ApiURL == "" || req.ApiURL == "auto" {
 			downloader := backend.NewTidalDownloader("")
 			if req.ServiceURL != "" {
-				filename, err = downloader.DownloadByURLWithFallback(req.ServiceURL, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback)
+				filename, err = downloader.DownloadByURLWithFallback(req.ServiceURL, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 			} else {
-				if req.SpotifyID == "" {
-					return DownloadResponse{
-						Success: false,
-						Error:   "Spotify ID is required for Tidal",
-					}, fmt.Errorf("spotify ID is required for Tidal")
-				}
-				filename, err = downloader.Download(req.SpotifyID, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback)
+				filename, err = downloader.Download(req.SpotifyID, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 			}
 		} else {
 			downloader := backend.NewTidalDownloader(req.ApiURL)
 			if req.ServiceURL != "" {
-				filename, err = downloader.DownloadByURL(req.ServiceURL, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback)
+				filename, err = downloader.DownloadByURL(req.ServiceURL, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 			} else {
-				if req.SpotifyID == "" {
-					return DownloadResponse{
-						Success: false,
-						Error:   "Spotify ID is required for Tidal",
-					}, fmt.Errorf("spotify ID is required for Tidal")
-				}
-				filename, err = downloader.Download(req.SpotifyID, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback)
+				filename, err = downloader.Download(req.SpotifyID, req.OutputDir, req.AudioFormat, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 			}
 		}
 
 	case "qobuz":
-		downloader := backend.NewQobuzDownloader()
 
+		fmt.Println("Waiting for ISRC (Qobuz dependency)...")
+		isrc := <-isrcChan
+		downloader := backend.NewQobuzDownloader()
 		quality := req.AudioFormat
 		if quality == "" {
 			quality = "6"
 		}
+		filename, err = downloader.DownloadTrackWithISRC(isrc, req.SpotifyID, req.OutputDir, quality, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 
-		deezerISRC := req.ISRC
-
-		if len(deezerISRC) != 12 || !isValidISRC(deezerISRC) {
-			deezerISRC = ""
-		}
-
-		if deezerISRC == "" && req.SpotifyID != "" {
-
-			songlinkClient := backend.NewSongLinkClient()
-			deezerURL, err := songlinkClient.GetDeezerURLFromSpotify(req.SpotifyID)
-			if err != nil {
-				return DownloadResponse{
-					Success: false,
-					Error:   fmt.Sprintf("Failed to get Deezer URL: %v", err),
-				}, err
-			}
-			deezerISRC, err = backend.GetDeezerISRC(deezerURL)
-			if err != nil {
-				return DownloadResponse{
-					Success: false,
-					Error:   fmt.Sprintf("Failed to get ISRC from Deezer: %v", err),
-				}, err
-			}
-		}
-		if deezerISRC == "" {
-			return DownloadResponse{
-				Success: false,
-				Error:   "ISRC is required for Qobuz (could not fetch from Deezer)",
-			}, fmt.Errorf("ISRC is required for Qobuz")
-		}
-		filename, err = downloader.DownloadByISRC(deezerISRC, req.OutputDir, quality, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback)
+	case "deezer":
+		downloader := backend.NewDeezerDownloader()
+		filename, err = downloader.Download(req.SpotifyID, req.OutputDir, req.FilenameFormat, req.PlaylistName, req.PlaylistOwner, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.CoverURL, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.EmbedMaxQualityCover, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 
 	default:
 		return DownloadResponse{
@@ -422,53 +439,30 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 		filename = strings.TrimPrefix(filename, "EXISTS:")
 	}
 
-	if !alreadyExists && req.SpotifyID != "" && req.EmbedLyrics && strings.HasSuffix(filename, ".flac") {
-		go func(filePath, spotifyID, trackName, artistName string) {
-			fmt.Printf("\n========== LYRICS FETCH START ==========\n")
-			fmt.Printf("Spotify ID: %s\n", spotifyID)
-			fmt.Printf("Track: %s\n", trackName)
-			fmt.Printf("Artist: %s\n", artistName)
-			fmt.Println("Searching all sources...")
-
-			lyricsClient := backend.NewLyricsClient()
-
-			lyricsResp, source, err := lyricsClient.FetchLyricsAllSources(spotifyID, trackName, artistName, 0)
-			if err != nil {
-				fmt.Printf("All sources failed: %v\n", err)
-				fmt.Printf("========== LYRICS FETCH END (FAILED) ==========\n\n")
-				return
-			}
-
-			if lyricsResp == nil || len(lyricsResp.Lines) == 0 {
-				fmt.Println("No lyrics content found")
-				fmt.Printf("========== LYRICS FETCH END (FAILED) ==========\n\n")
-				return
-			}
-
-			fmt.Printf("Lyrics found from: %s\n", source)
-			fmt.Printf("Sync type: %s\n", lyricsResp.SyncType)
-			fmt.Printf("Total lines: %d\n", len(lyricsResp.Lines))
-
-			lyrics := lyricsClient.ConvertToLRC(lyricsResp, trackName, artistName)
-			if lyrics == "" {
-				fmt.Println("No lyrics content to embed")
-				fmt.Printf("========== LYRICS FETCH END (FAILED) ==========\n\n")
-				return
-			}
-
+	if !alreadyExists && req.SpotifyID != "" && req.EmbedLyrics && (strings.HasSuffix(filename, ".flac") || strings.HasSuffix(filename, ".mp3") || strings.HasSuffix(filename, ".m4a")) {
+		fmt.Printf("\nWaiting for lyrics fetch to complete...\n")
+		lyrics := <-lyricsChan
+		if lyrics != "" {
 			fmt.Printf("\n--- Full LRC Content ---\n")
 			fmt.Println(lyrics)
 			fmt.Printf("--- End LRC Content ---\n\n")
 
-			fmt.Printf("Embedding into: %s\n", filePath)
-			if err := backend.EmbedLyricsOnly(filePath, lyrics); err != nil {
+			fmt.Printf("Embedding into: %s\n", filename)
+
+			if err := backend.EmbedLyricsOnlyUniversal(filename, lyrics); err != nil {
 				fmt.Printf("Failed to embed lyrics: %v\n", err)
-				fmt.Printf("========== LYRICS FETCH END (FAILED) ==========\n\n")
 			} else {
 				fmt.Printf("Lyrics embedded successfully!\n")
-				fmt.Printf("========== LYRICS FETCH END (SUCCESS) ==========\n\n")
 			}
-		}(filename, req.SpotifyID, req.TrackName, req.ArtistName)
+		} else {
+			fmt.Println("No lyrics found to embed.")
+		}
+	} else {
+
+		select {
+		case <-lyricsChan:
+		default:
+		}
 	}
 
 	message := "Download completed successfully"
@@ -491,11 +485,17 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 
 			meta, err := backend.GetTrackMetadata(fPath)
 			if err == nil && meta != nil {
-				quality = fmt.Sprintf("%d-bit/%.1fkHz", meta.BitsPerSample, float64(meta.SampleRate)/1000.0)
+				if meta.BitsPerSample > 0 {
+					quality = fmt.Sprintf("%d-bit/%.1fkHz", meta.BitsPerSample, float64(meta.SampleRate)/1000.0)
+				} else if meta.Bitrate > 0 {
+					quality = fmt.Sprintf("%dkbps/%.1fkHz", meta.Bitrate/1000, float64(meta.SampleRate)/1000.0)
+				} else if meta.SampleRate > 0 {
+					quality = fmt.Sprintf("%.1fkHz", float64(meta.SampleRate)/1000.0)
+				}
 				d := int(meta.Duration)
 				durationStr = fmt.Sprintf("%d:%02d", d/60, d%60)
 			} else {
-
+				fmt.Printf("[History] Failed to get metadata for %s: %v\n", fPath, err)
 			}
 
 			item := backend.HistoryItem{
@@ -506,7 +506,7 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 				DurationStr: durationStr,
 				CoverURL:    cover,
 				Quality:     quality,
-				Format:      format,
+				Format:      strings.ToUpper(format),
 				Path:        fPath,
 			}
 
@@ -578,9 +578,9 @@ func (a *App) ClearAllDownloads() {
 	backend.ClearAllDownloads()
 }
 
-func (a *App) AddToDownloadQueue(isrc, trackName, artistName, albumName string) string {
-	itemID := fmt.Sprintf("%s-%d", isrc, time.Now().UnixNano())
-	backend.AddToQueue(itemID, trackName, artistName, albumName, isrc)
+func (a *App) AddToDownloadQueue(spotifyID, trackName, artistName, albumName string) string {
+	itemID := fmt.Sprintf("%s-%d", spotifyID, time.Now().UnixNano())
+	backend.AddToQueue(itemID, trackName, artistName, albumName, "")
 	return itemID
 }
 
@@ -592,6 +592,74 @@ func (a *App) CancelAllQueuedItems() {
 	backend.CancelAllQueuedItems()
 }
 
+func (a *App) ExportFailedDownloads() (string, error) {
+	queueInfo := backend.GetDownloadQueue()
+	var failedItems []string
+
+	hasFailed := false
+	for _, item := range queueInfo.Queue {
+		if item.Status == backend.StatusFailed {
+			hasFailed = true
+			break
+		}
+	}
+
+	if !hasFailed {
+		return "No failed downloads to export.", nil
+	}
+
+	failedItems = append(failedItems, fmt.Sprintf("Failed Downloads Report - %s", time.Now().Format("2006-01-02 15:04:05")))
+	failedItems = append(failedItems, strings.Repeat("-", 50))
+	failedItems = append(failedItems, "")
+
+	count := 0
+	for _, item := range queueInfo.Queue {
+		if item.Status == backend.StatusFailed {
+			count++
+			line := fmt.Sprintf("%d. %s - %s", count, item.TrackName, item.ArtistName)
+			if item.AlbumName != "" {
+				line += fmt.Sprintf(" (%s)", item.AlbumName)
+			}
+			failedItems = append(failedItems, line)
+			failedItems = append(failedItems, fmt.Sprintf("   Error: %s", item.ErrorMessage))
+
+			if item.SpotifyID != "" {
+				failedItems = append(failedItems, fmt.Sprintf("   ID: %s", item.SpotifyID))
+				failedItems = append(failedItems, fmt.Sprintf("   URL: https://open.spotify.com/track/%s", item.SpotifyID))
+			}
+			failedItems = append(failedItems, "")
+		}
+	}
+
+	content := strings.Join(failedItems, "\n")
+	defaultFilename := fmt.Sprintf("SpotiFLAC_%s_Failed.txt", time.Now().Format("20060102_150405"))
+
+	path, err := runtime.SaveFileDialog(a.ctx, runtime.SaveDialogOptions{
+		DefaultFilename: defaultFilename,
+		Title:           "Export Failed Downloads",
+		Filters: []runtime.FileFilter{
+			{
+				DisplayName: "Text Files (*.txt)",
+				Pattern:     "*.txt",
+			},
+		},
+	})
+
+	if err != nil {
+		return "", fmt.Errorf("failed to open save dialog: %v", err)
+	}
+
+	if path == "" {
+		return "Export cancelled", nil
+	}
+
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		return "", fmt.Errorf("failed to write file: %v", err)
+	}
+
+	return fmt.Sprintf("Successfully exported %d failed downloads to %s", count, path), nil
+}
+
 func (a *App) Quit() {
 
 	panic("quit")
@@ -888,13 +956,13 @@ func (a *App) DownloadAvatar(req AvatarDownloadRequest) (backend.AvatarDownloadR
 	return *resp, nil
 }
 
-func (a *App) CheckTrackAvailability(spotifyTrackID string, isrc string) (string, error) {
+func (a *App) CheckTrackAvailability(spotifyTrackID string) (string, error) {
 	if spotifyTrackID == "" {
 		return "", fmt.Errorf("spotify track ID is required")
 	}
 
 	client := backend.NewSongLinkClient()
-	availability, err := client.CheckTrackAvailability(spotifyTrackID, isrc)
+	availability, err := client.CheckTrackAvailability(spotifyTrackID)
 	if err != nil {
 		return "", err
 	}
@@ -1091,12 +1159,15 @@ type CheckFileExistenceResult struct {
 	ArtistName string `json:"artist_name,omitempty"`
 }
 
-func (a *App) CheckFilesExistence(outputDir string, tracks []CheckFileExistenceRequest) []CheckFileExistenceResult {
+func (a *App) CheckFilesExistence(outputDir string, rootDir string, tracks []CheckFileExistenceRequest) []CheckFileExistenceResult {
 	if len(tracks) == 0 {
 		return []CheckFileExistenceResult{}
 	}
 
 	outputDir = backend.NormalizePath(outputDir)
+	if rootDir != "" {
+		rootDir = backend.NormalizePath(rootDir)
+	}
 
 	defaultFilenameFormat := "title-artist"
 
@@ -1107,6 +1178,30 @@ func (a *App) CheckFilesExistence(outputDir string, tracks []CheckFileExistenceR
 
 	resultsChan := make(chan result, len(tracks))
 
+	var rootDirFiles map[string]string
+	rootDirFilesOnce := false
+	getRootDirFiles := func() map[string]string {
+		if rootDirFilesOnce {
+			return rootDirFiles
+		}
+		rootDirFiles = make(map[string]string)
+		if rootDir != "" && rootDir != outputDir {
+			filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
+				if err != nil {
+					return nil
+				}
+				if !info.IsDir() {
+					if strings.EqualFold(filepath.Ext(path), ".flac") || strings.EqualFold(filepath.Ext(path), ".mp3") {
+						rootDirFiles[info.Name()] = path
+					}
+				}
+				return nil
+			})
+		}
+		rootDirFilesOnce = true
+		return rootDirFiles
+	}
+
 	for i, track := range tracks {
 		go func(idx int, t CheckFileExistenceRequest) {
 			res := CheckFileExistenceResult{
@@ -1163,6 +1258,9 @@ func (a *App) CheckFilesExistence(outputDir string, tracks []CheckFileExistenceR
 			if fileInfo, err := os.Stat(expectedPath); err == nil && fileInfo.Size() > 100*1024 {
 				res.Exists = true
 				res.FilePath = expectedPath
+			} else {
+
+				res.FilePath = expectedFilename
 			}
 
 			resultsChan <- result{index: idx, result: res}
@@ -1170,9 +1268,39 @@ func (a *App) CheckFilesExistence(outputDir string, tracks []CheckFileExistenceR
 	}
 
 	results := make([]CheckFileExistenceResult, len(tracks))
+	missingIndices := []int{}
+
 	for i := 0; i < len(tracks); i++ {
 		r := <-resultsChan
 		results[r.index] = r.result
+		if !results[r.index].Exists {
+			missingIndices = append(missingIndices, r.index)
+		}
+	}
+
+	if len(missingIndices) > 0 && rootDir != "" {
+		filesMap := getRootDirFiles()
+		if len(filesMap) > 0 {
+			for _, idx := range missingIndices {
+
+				expectedFilename := results[idx].FilePath
+				baseName := filepath.Base(expectedFilename)
+				if path, ok := filesMap[baseName]; ok {
+					results[idx].Exists = true
+					results[idx].FilePath = path
+				} else {
+					results[idx].FilePath = ""
+				}
+			}
+		} else {
+			for _, idx := range missingIndices {
+				results[idx].FilePath = ""
+			}
+		}
+	} else {
+		for _, idx := range missingIndices {
+			results[idx].FilePath = ""
+		}
 	}
 
 	return results
@@ -1245,3 +1373,52 @@ func (a *App) CheckFFmpegInstalled() (bool, error) {
 func (a *App) GetOSInfo() (string, error) {
 	return backend.GetOSInfo()
 }
+
+func (a *App) CreateM3U8File(m3u8Name string, outputDir string, filePaths []string) error {
+	if len(filePaths) == 0 {
+		return nil
+	}
+
+	if err := os.MkdirAll(outputDir, 0755); err != nil {
+		return err
+	}
+
+	fnName := m3u8Name
+
+	safeName := backend.SanitizeFilename(fnName)
+	if safeName == "" {
+		safeName = "playlist"
+	}
+
+	m3u8Path := filepath.Join(outputDir, safeName+".m3u8")
+
+	f, err := os.Create(m3u8Path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	if _, err := f.WriteString("#EXTM3U\n"); err != nil {
+		return err
+	}
+
+	for _, path := range filePaths {
+		if path == "" {
+			continue
+		}
+
+		relPath, err := filepath.Rel(outputDir, path)
+		if err != nil {
+
+			relPath = path
+		}
+
+		relPath = filepath.ToSlash(relPath)
+
+		if _, err := f.WriteString(relPath + "\n"); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

backend/amazon.go

@@ -1,13 +1,13 @@
 package backend
 
 import (
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -25,13 +25,9 @@ type SongLinkResponse struct {
 	} `json:"linksByPlatform"`
 }
 
-type AfkarXYZResponse struct {
-	Success bool `json:"success"`
-	Data    struct {
-		DirectLink string `json:"direct_link"`
-		FileName   string `json:"file_name"`
-		FileSize   int64  `json:"file_size"`
-	} `json:"data"`
+type AmazonStreamResponse struct {
+	StreamURL     string `json:"streamUrl"`
+	DecryptionKey string `json:"decryptionKey"`
 }
 
 func NewAmazonDownloader() *AmazonDownloader {
@@ -55,6 +51,7 @@ func (a *AmazonDownloader) GetAmazonURLFromSpotify(spotifyTrackID string) (strin
 	if err != nil {
 		return "", fmt.Errorf("failed to create request: %w", err)
 	}
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 
 	fmt.Println("Getting Amazon URL...")
 
@@ -98,8 +95,7 @@ func (a *AmazonDownloader) GetAmazonURLFromSpotify(spotifyTrackID string) (strin
 		parts := strings.Split(amazonURL, "trackAsin=")
 		if len(parts) > 1 {
 			trackAsin := strings.Split(parts[1], "&")[0]
-			musicBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9tdXNpYy5hbWF6b24uY29tL3RyYWNrcy8=")
-			amazonURL = fmt.Sprintf("%s%s?musicTerritory=US", string(musicBase), trackAsin)
+			amazonURL = fmt.Sprintf("https://music.amazon.com/tracks/%s?musicTerritory=US", trackAsin)
 		}
 	}
 
@@ -108,13 +104,21 @@ func (a *AmazonDownloader) GetAmazonURLFromSpotify(spotifyTrackID string) (strin
 }
 
 func (a *AmazonDownloader) DownloadFromAfkarXYZ(amazonURL, outputDir, quality string) (string, error) {
-	apiURL := "https://amazon.afkarxyz.fun/convert?url=" + url.QueryEscape(amazonURL)
+
+	asinRegex := regexp.MustCompile(`(B[0-9A-Z]{9})`)
+	asin := asinRegex.FindString(amazonURL)
+	if asin == "" {
+		return "", fmt.Errorf("failed to extract ASIN from URL: %s", amazonURL)
+	}
+
+	apiURL := fmt.Sprintf("https://amzn.afkarxyz.fun/api/track/%s", asin)
 	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
 		return "", err
 	}
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 
-	fmt.Printf("Fetching from AfkarXYZ...\n")
+	fmt.Printf("Fetching from Amazon API (ASIN: %s)...\n", asin)
 	resp, err := a.client.Do(req)
 	if err != nil {
 		return "", err
@@ -122,27 +126,25 @@ func (a *AmazonDownloader) DownloadFromAfkarXYZ(amazonURL, outputDir, quality st
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("AfkarXYZ API returned status %d", resp.StatusCode)
+		return "", fmt.Errorf("Amazon API returned status %d", resp.StatusCode)
 	}
 
-	bodyBytes, _ := io.ReadAll(resp.Body)
-	var apiResp AfkarXYZResponse
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	var apiResp AmazonStreamResponse
 	if err := json.Unmarshal(bodyBytes, &apiResp); err != nil {
 		return "", fmt.Errorf("failed to decode response: %w", err)
 	}
 
-	if !apiResp.Success || apiResp.Data.DirectLink == "" {
-		return "", fmt.Errorf("AfkarXYZ failed or no link found")
+	if apiResp.StreamURL == "" {
+		return "", fmt.Errorf("no stream URL found in response")
 	}
 
-	downloadURL := apiResp.Data.DirectLink
-	fileName := apiResp.Data.FileName
-	if fileName == "" {
-		fileName = "track.flac"
-	}
-
-	reg := regexp.MustCompile(`[<>:"/\\|?*]`)
-	fileName = reg.ReplaceAllString(fileName, "")
+	downloadURL := apiResp.StreamURL
+	fileName := fmt.Sprintf("%s.m4a", asin)
 	filePath := filepath.Join(outputDir, fileName)
 
 	out, err := os.Create(filePath)
@@ -152,6 +154,7 @@ func (a *AmazonDownloader) DownloadFromAfkarXYZ(amazonURL, outputDir, quality st
 	defer out.Close()
 
 	dlReq, _ := http.NewRequest("GET", downloadURL, nil)
+	dlReq.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 
 	dlResp, err := a.client.Do(dlReq)
 	if err != nil {
@@ -159,7 +162,7 @@ func (a *AmazonDownloader) DownloadFromAfkarXYZ(amazonURL, outputDir, quality st
 	}
 	defer dlResp.Body.Close()
 
-	fmt.Printf("Downloading from AfkarXYZ: %s\n", fileName)
+	fmt.Printf("Downloading track: %s\n", fileName)
 	pw := NewProgressWriter(out)
 	_, err = io.Copy(pw, dlResp.Body)
 	if err != nil {
@@ -169,6 +172,86 @@ func (a *AmazonDownloader) DownloadFromAfkarXYZ(amazonURL, outputDir, quality st
 	}
 
 	fmt.Printf("\rDownloaded: %.2f MB (Complete)\n", float64(pw.GetTotal())/(1024*1024))
+
+	if apiResp.DecryptionKey != "" {
+		fmt.Printf("Decrypting file...\n")
+
+		ffprobePath, err := GetFFprobePath()
+		var codec string
+		if err == nil {
+			cmdProbe := exec.Command(ffprobePath,
+				"-v", "quiet",
+				"-select_streams", "a:0",
+				"-show_entries", "stream=codec_name",
+				"-of", "default=noprint_wrappers=1:nokey=1",
+				filePath,
+			)
+			setHideWindow(cmdProbe)
+			codecOutput, _ := cmdProbe.Output()
+			codec = strings.TrimSpace(string(codecOutput))
+			fmt.Printf("Detected codec: %s\n", codec)
+		}
+
+		targetExt := ".m4a"
+		if codec == "flac" {
+			targetExt = ".flac"
+		}
+
+		decryptedFilename := "dec_" + fileName + targetExt
+
+		if targetExt == ".flac" && strings.HasSuffix(fileName, ".m4a") {
+			decryptedFilename = "dec_" + strings.TrimSuffix(fileName, ".m4a") + ".flac"
+		}
+
+		decryptedPath := filepath.Join(outputDir, decryptedFilename)
+
+		ffmpegPath, err := GetFFmpegPath()
+		if err != nil {
+			return "", fmt.Errorf("ffmpeg not found for decryption: %w", err)
+		}
+
+		if err := ValidateExecutable(ffmpegPath); err != nil {
+			return "", fmt.Errorf("invalid ffmpeg executable: %w", err)
+		}
+
+		key := strings.TrimSpace(apiResp.DecryptionKey)
+
+		cmd := exec.Command(ffmpegPath,
+			"-decryption_key", key,
+			"-i", filePath,
+			"-c", "copy",
+			"-y",
+			decryptedPath,
+		)
+
+		setHideWindow(cmd)
+		output, err := cmd.CombinedOutput()
+		if err != nil {
+
+			outStr := string(output)
+			if len(outStr) > 500 {
+				outStr = outStr[len(outStr)-500:]
+			}
+			return "", fmt.Errorf("ffmpeg decryption failed: %v\nTail Output: %s", err, outStr)
+		}
+
+		if info, err := os.Stat(decryptedPath); err != nil || info.Size() == 0 {
+			return "", fmt.Errorf("decrypted file missing or empty")
+		}
+
+		if err := os.Remove(filePath); err != nil {
+			fmt.Printf("Warning: Failed to remove encrypted file: %v\n", err)
+		}
+
+		finalPath := filepath.Join(outputDir, strings.TrimPrefix(decryptedFilename, "dec_"))
+		if err := os.Rename(decryptedPath, finalPath); err != nil {
+			return "", fmt.Errorf("failed to rename decrypted file: %w", err)
+		}
+		filePath = finalPath
+
+		fmt.Println("Decryption successful")
+	}
+
 	return filePath, nil
 }
 
@@ -176,7 +259,7 @@ func (a *AmazonDownloader) DownloadFromService(amazonURL, outputDir, quality str
 	return a.DownloadFromAfkarXYZ(amazonURL, outputDir, quality)
 }
 
-func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filenameFormat, playlistName, playlistOwner string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, spotifyCoverURL string, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, embedMaxQualityCover bool, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string) (string, error) {
+func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filenameFormat, playlistName, playlistOwner string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, spotifyCoverURL string, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, embedMaxQualityCover bool, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
 
 	if outputDir != "." {
 		if err := os.MkdirAll(outputDir, 0755); err != nil {
@@ -185,7 +268,13 @@ func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filename
 	}
 
 	if spotifyTrackName != "" && spotifyArtistName != "" {
-		expectedFilename := BuildExpectedFilename(spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, filenameFormat, playlistName, playlistOwner, includeTrackNumber, position, spotifyDiscNumber, false)
+		filenameArtist := spotifyArtistName
+		filenameAlbumArtist := spotifyAlbumArtist
+		if useFirstArtistOnly {
+			filenameArtist = GetFirstArtist(spotifyArtistName)
+			filenameAlbumArtist = GetFirstArtist(spotifyAlbumArtist)
+		}
+		expectedFilename := BuildExpectedFilename(spotifyTrackName, filenameArtist, spotifyAlbumName, filenameAlbumArtist, spotifyReleaseDate, filenameFormat, playlistName, playlistOwner, includeTrackNumber, position, spotifyDiscNumber, false)
 		expectedPath := filepath.Join(outputDir, expectedFilename)
 
 		if fileInfo, err := os.Stat(expectedPath); err == nil && fileInfo.Size() > 0 {
@@ -194,6 +283,42 @@ func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filename
 		}
 	}
 
+	type mbResult struct {
+		ISRC     string
+		Metadata Metadata
+	}
+
+	metaChan := make(chan mbResult, 1)
+	if embedGenre && spotifyURL != "" {
+		go func() {
+			res := mbResult{}
+			var isrc string
+			parts := strings.Split(spotifyURL, "/")
+			if len(parts) > 0 {
+				sID := strings.Split(parts[len(parts)-1], "?")[0]
+				if sID != "" {
+					client := NewSongLinkClient()
+					if val, err := client.GetISRC(sID); err == nil {
+						isrc = val
+					}
+				}
+			}
+			res.ISRC = isrc
+			if isrc != "" {
+				fmt.Println("Fetching MusicBrainz metadata...")
+				if fetchedMeta, err := FetchMusicBrainzMetadata(isrc, spotifyTrackName, spotifyArtistName, spotifyAlbumName, useSingleGenre, embedGenre); err == nil {
+					res.Metadata = fetchedMeta
+					fmt.Println("✓ MusicBrainz metadata fetched")
+				} else {
+					fmt.Printf("Warning: Failed to fetch MusicBrainz metadata: %v\n", err)
+				}
+			}
+			metaChan <- res
+		}()
+	} else {
+		close(metaChan)
+	}
+
 	fmt.Printf("Using Amazon URL: %s\n", amazonURL)
 
 	filePath, err := a.DownloadFromService(amazonURL, outputDir, quality)
@@ -201,11 +326,28 @@ func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filename
 		return "", err
 	}
 
+	var isrc string
+	var mbMeta Metadata
+	if spotifyURL != "" {
+		result := <-metaChan
+		isrc = result.ISRC
+		mbMeta = result.Metadata
+	}
+
+	originalFileDir := filepath.Dir(filePath)
+	originalFileBase := strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath))
+
 	if spotifyTrackName != "" && spotifyArtistName != "" {
 		safeArtist := sanitizeFilename(spotifyArtistName)
+		safeAlbumArtist := sanitizeFilename(spotifyAlbumArtist)
+
+		if useFirstArtistOnly {
+			safeArtist = sanitizeFilename(GetFirstArtist(spotifyArtistName))
+			safeAlbumArtist = sanitizeFilename(GetFirstArtist(spotifyAlbumArtist))
+		}
+
 		safeTitle := sanitizeFilename(spotifyTrackName)
 		safeAlbum := sanitizeFilename(spotifyAlbumName)
-		safeAlbumArtist := sanitizeFilename(spotifyAlbumArtist)
 
 		year := ""
 		if len(spotifyReleaseDate) >= 4 {
@@ -221,6 +363,7 @@ func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filename
 			newFilename = strings.ReplaceAll(newFilename, "{album}", safeAlbum)
 			newFilename = strings.ReplaceAll(newFilename, "{album_artist}", safeAlbumArtist)
 			newFilename = strings.ReplaceAll(newFilename, "{year}", year)
+			newFilename = strings.ReplaceAll(newFilename, "{date}", SanitizeFilename(spotifyReleaseDate))
 
 			if spotifyDiscNumber > 0 {
 				newFilename = strings.ReplaceAll(newFilename, "{disc}", fmt.Sprintf("%d", spotifyDiscNumber))
@@ -252,7 +395,11 @@ func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filename
 			}
 		}
 
-		newFilename = newFilename + ".flac"
+		ext := filepath.Ext(filePath)
+		if ext == "" {
+			ext = ".flac"
+		}
+		newFilename = newFilename + ext
 		newFilePath := filepath.Join(outputDir, newFilename)
 
 		if err := os.Rename(filePath, newFilePath); err != nil {
@@ -298,25 +445,41 @@ func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filename
 		Copyright:   spotifyCopyright,
 		Publisher:   spotifyPublisher,
 		Description: "https://github.com/afkarxyz/SpotiFLAC",
+		ISRC:        isrc,
+		Genre:       mbMeta.Genre,
 	}
 
-	if err := EmbedMetadata(filePath, metadata, coverPath); err != nil {
+	if err := EmbedMetadataToConvertedFile(filePath, metadata, coverPath); err != nil {
 		fmt.Printf("Warning: Failed to embed metadata: %v\n", err)
 	} else {
 		fmt.Println("Metadata embedded successfully")
 	}
 
+	if strings.HasSuffix(strings.ToLower(filePath), ".flac") {
+
+		originalM4aPath := filepath.Join(originalFileDir, originalFileBase+".m4a")
+		if _, err := os.Stat(originalM4aPath); err == nil {
+			if err := os.Remove(originalM4aPath); err != nil {
+				fmt.Printf("Warning: Failed to remove M4A file: %v\n", err)
+			} else {
+				fmt.Printf("Cleaned up original M4A file: %s\n", filepath.Base(originalM4aPath))
+			}
+		}
+	}
+
 	fmt.Println("Done")
 	fmt.Println("✓ Downloaded successfully from Amazon Music")
 	return filePath, nil
 }
 
-func (a *AmazonDownloader) DownloadBySpotifyID(spotifyTrackID, outputDir, quality, filenameFormat, playlistName, playlistOwner string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, spotifyCoverURL string, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, embedMaxQualityCover bool, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string) (string, error) {
+func (a *AmazonDownloader) DownloadBySpotifyID(spotifyTrackID, outputDir, quality, filenameFormat, playlistName, playlistOwner string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, spotifyCoverURL string, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, embedMaxQualityCover bool, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string,
+	useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool,
+) (string, error) {
 
 	amazonURL, err := a.GetAmazonURLFromSpotify(spotifyTrackID)
 	if err != nil {
 		return "", err
 	}
 
-	return a.DownloadByURL(amazonURL, outputDir, quality, filenameFormat, playlistName, playlistOwner, includeTrackNumber, position, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, spotifyCoverURL, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, embedMaxQualityCover, spotifyTotalDiscs, spotifyCopyright, spotifyPublisher, spotifyURL)
+	return a.DownloadByURL(amazonURL, outputDir, quality, filenameFormat, playlistName, playlistOwner, includeTrackNumber, position, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, spotifyCoverURL, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, embedMaxQualityCover, spotifyTotalDiscs, spotifyCopyright, spotifyPublisher, spotifyURL, useFirstArtistOnly, useSingleGenre, embedGenre)
 }

backend/analysis.go

@@ -4,6 +4,10 @@ import (
 	"fmt"
 	"math"
 	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"time"
 
 	"github.com/go-flac/go-flac"
 	mewflac "github.com/mewkiz/flac"
@@ -17,6 +21,7 @@ type AnalysisResult struct {
 	BitsPerSample uint8         `json:"bits_per_sample"`
 	TotalSamples  uint64        `json:"total_samples"`
 	Duration      float64       `json:"duration"`
+	Bitrate       int           `json:"bit_rate"`
 	BitDepth      string        `json:"bit_depth"`
 	DynamicRange  float64       `json:"dynamic_range"`
 	PeakAmplitude float64       `json:"peak_amplitude"`
@@ -168,40 +173,106 @@ func GetTrackMetadata(filepath string) (*AnalysisResult, error) {
 		return nil, fmt.Errorf("file does not exist: %s", filepath)
 	}
 
-	fileInfo, err := os.Stat(filepath)
+	return GetMetadataWithFFprobe(filepath)
+}
+
+func GetMetadataWithFFprobe(filePath string) (*AnalysisResult, error) {
+	ffprobePath, err := GetFFprobePath()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get file info: %w", err)
+		return nil, err
 	}
 
-	f, err := flac.ParseFile(filepath)
+	for i := 0; i < 5; i++ {
+		if f, err := os.Open(filePath); err == nil {
+			f.Close()
+			break
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
+
+	args := []string{
+		"-v", "error",
+		"-select_streams", "a:0",
+		"-show_entries", "stream=sample_rate,channels,bits_per_raw_sample,bits_per_sample,duration,bit_rate",
+		"-of", "default=noprint_wrappers=1:nokey=1",
+		filePath,
+	}
+
+	cmd := exec.Command(ffprobePath, args...)
+	setHideWindow(cmd)
+	output, err := cmd.CombinedOutput()
 	if err != nil {
-		return nil, fmt.Errorf("failed to parse FLAC file: %w", err)
+		return nil, fmt.Errorf("ffprobe failed: %w - %s", err, string(output))
 	}
 
-	result := &AnalysisResult{
-		FilePath: filepath,
-		FileSize: fileInfo.Size(),
+	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
+	if len(lines) < 4 {
+		return nil, fmt.Errorf("unexpected ffprobe output: %s", string(output))
 	}
 
-	if len(f.Meta) > 0 {
-		streamInfo := f.Meta[0]
-		if streamInfo.Type == flac.StreamInfo {
-			data := streamInfo.Data
-			if len(data) >= 18 {
-				result.SampleRate = uint32(data[10])<<12 | uint32(data[11])<<4 | uint32(data[12])>>4
-				result.BitsPerSample = ((data[12]&0x01)<<4 | data[13]>>4) + 1
-				result.TotalSamples = uint64(data[13]&0x0F)<<32 |
-					uint64(data[14])<<24 |
-					uint64(data[15])<<16 |
-					uint64(data[16])<<8 |
-					uint64(data[17])
+	res := &AnalysisResult{
+		FilePath: filePath,
+	}
 
-				if result.SampleRate > 0 {
-					result.Duration = float64(result.TotalSamples) / float64(result.SampleRate)
-				}
+	if info, err := os.Stat(filePath); err == nil {
+		res.FileSize = info.Size()
+	}
+
+	infoMap := make(map[string]string)
+
+	args = []string{
+		"-v", "error",
+		"-select_streams", "a:0",
+		"-show_entries", "stream=sample_rate,channels,bits_per_raw_sample,bits_per_sample,duration,bit_rate",
+		"-of", "default=noprint_wrappers=0",
+		filePath,
+	}
+	cmd = exec.Command(ffprobePath, args...)
+	setHideWindow(cmd)
+	output, err = cmd.CombinedOutput()
+	if err == nil {
+		lines = strings.Split(string(output), "\n")
+		for _, line := range lines {
+			if strings.Contains(line, "=") {
+				parts := strings.SplitN(line, "=", 2)
+				infoMap[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
 			}
 		}
 	}
-	result.BitDepth = fmt.Sprintf("%d-bit", result.BitsPerSample)
-	return result, nil
+
+	if val, ok := infoMap["sample_rate"]; ok {
+		s, _ := strconv.Atoi(val)
+		res.SampleRate = uint32(s)
+	}
+	if val, ok := infoMap["channels"]; ok {
+		c, _ := strconv.Atoi(val)
+		res.Channels = uint8(c)
+	}
+	if val, ok := infoMap["duration"]; ok {
+		d, _ := strconv.ParseFloat(val, 64)
+		res.Duration = d
+	}
+	if val, ok := infoMap["bit_rate"]; ok && val != "N/A" {
+		br, _ := strconv.Atoi(val)
+		res.Bitrate = br
+	}
+
+	bits := 0
+	if val, ok := infoMap["bits_per_raw_sample"]; ok && val != "N/A" {
+		bits, _ = strconv.Atoi(val)
+	}
+	if bits == 0 {
+		if val, ok := infoMap["bits_per_sample"]; ok && val != "N/A" {
+			bits, _ = strconv.Atoi(val)
+		}
+	}
+
+	res.BitsPerSample = uint8(bits)
+	if bits > 0 {
+		res.BitDepth = fmt.Sprintf("%d-bit", bits)
+	} else {
+		res.BitDepth = "Unknown"
+	}
+
+	return res, nil
 }

backend/cover.go

@@ -83,6 +83,7 @@ func buildCoverFilename(trackName, artistName, albumName, albumArtist, releaseDa
 		filename = strings.ReplaceAll(filename, "{album}", safeAlbum)
 		filename = strings.ReplaceAll(filename, "{album_artist}", safeAlbumArtist)
 		filename = strings.ReplaceAll(filename, "{year}", year)
+		filename = strings.ReplaceAll(filename, "{date}", sanitizeFilename(releaseDate))
 
 		if discNumber > 0 {
 			filename = strings.ReplaceAll(filename, "{disc}", fmt.Sprintf("%d", discNumber))

backend/deezer.go

@@ -0,0 +1,273 @@
+package backend
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+type DeezerDownloader struct {
+	client *http.Client
+}
+
+func NewDeezerDownloader() *DeezerDownloader {
+	return &DeezerDownloader{
+		client: &http.Client{
+			Timeout: 300 * time.Second,
+		},
+	}
+}
+
+type YoinkifyRequest struct {
+	URL         string `json:"url"`
+	Format      string `json:"format"`
+	GenreSource string `json:"genreSource"`
+}
+
+func (d *DeezerDownloader) DownloadFromYoinkify(spotifyURL, outputDir string) (string, error) {
+	apiURL := "https://yoinkify.lol/api/download"
+
+	payload := YoinkifyRequest{
+		URL:         spotifyURL,
+		Format:      "flac",
+		GenreSource: "spotify",
+	}
+
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return "", err
+	}
+
+	req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
+
+	fmt.Printf("Fetching from Deezer API (Yoinkify)...\n")
+	resp, err := d.client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("Deezer API returned status %d", resp.StatusCode)
+	}
+
+	tempFileName := fmt.Sprintf("deezer_%d.flac", time.Now().UnixNano())
+	filePath := filepath.Join(outputDir, tempFileName)
+
+	out, err := os.Create(filePath)
+	if err != nil {
+		return "", err
+	}
+	defer out.Close()
+
+	fmt.Printf("Downloading track from Deezer...\n")
+	pw := NewProgressWriter(out)
+	_, err = io.Copy(pw, resp.Body)
+	if err != nil {
+		out.Close()
+		os.Remove(filePath)
+		return "", err
+	}
+
+	fmt.Printf("\rDownloaded: %.2f MB (Complete)\n", float64(pw.GetTotal())/(1024*1024))
+	return filePath, nil
+}
+
+func (d *DeezerDownloader) Download(spotifyID, outputDir, filenameFormat, playlistName, playlistOwner string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, spotifyCoverURL string, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, embedMaxQualityCover bool, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
+
+	if outputDir != "." {
+		if err := os.MkdirAll(outputDir, 0755); err != nil {
+			return "", fmt.Errorf("failed to create output directory: %w", err)
+		}
+	}
+
+	if spotifyTrackName != "" && spotifyArtistName != "" {
+		filenameArtist := spotifyArtistName
+		filenameAlbumArtist := spotifyAlbumArtist
+		if useFirstArtistOnly {
+			filenameArtist = GetFirstArtist(spotifyArtistName)
+			filenameAlbumArtist = GetFirstArtist(spotifyAlbumArtist)
+		}
+		expectedFilename := BuildExpectedFilename(spotifyTrackName, filenameArtist, spotifyAlbumName, filenameAlbumArtist, spotifyReleaseDate, filenameFormat, playlistName, playlistOwner, includeTrackNumber, position, spotifyDiscNumber, false)
+		expectedPath := filepath.Join(outputDir, expectedFilename)
+
+		if fileInfo, err := os.Stat(expectedPath); err == nil && fileInfo.Size() > 0 {
+			fmt.Printf("File already exists: %s (%.2f MB)\n", expectedPath, float64(fileInfo.Size())/(1024*1024))
+			return "EXISTS:" + expectedPath, nil
+		}
+	}
+
+	type mbResult struct {
+		ISRC     string
+		Metadata Metadata
+	}
+
+	metaChan := make(chan mbResult, 1)
+	if (embedGenre || true) && spotifyURL != "" {
+		go func() {
+			res := mbResult{}
+			var isrc string
+			parts := strings.Split(spotifyURL, "/")
+			if len(parts) > 0 {
+				sID := strings.Split(parts[len(parts)-1], "?")[0]
+				if sID != "" {
+					client := NewSongLinkClient()
+					if val, err := client.GetISRC(sID); err == nil {
+						isrc = val
+					}
+				}
+			}
+			res.ISRC = isrc
+			if isrc != "" && embedGenre {
+				fmt.Println("Fetching MusicBrainz metadata...")
+				if fetchedMeta, err := FetchMusicBrainzMetadata(isrc, spotifyTrackName, spotifyArtistName, spotifyAlbumName, useSingleGenre, embedGenre); err == nil {
+					res.Metadata = fetchedMeta
+					fmt.Println("✓ MusicBrainz metadata fetched")
+				} else {
+					fmt.Printf("Warning: Failed to fetch MusicBrainz metadata: %v\n", err)
+				}
+			}
+			metaChan <- res
+		}()
+	} else {
+		close(metaChan)
+	}
+
+	filePath, err := d.DownloadFromYoinkify(spotifyURL, outputDir)
+	if err != nil {
+		return "", err
+	}
+
+	var isrc string
+	var mbMeta Metadata
+	if spotifyURL != "" {
+		result := <-metaChan
+		isrc = result.ISRC
+		mbMeta = result.Metadata
+	}
+
+	if spotifyTrackName != "" && spotifyArtistName != "" {
+		safeArtist := sanitizeFilename(spotifyArtistName)
+		safeAlbumArtist := sanitizeFilename(spotifyAlbumArtist)
+
+		if useFirstArtistOnly {
+			safeArtist = sanitizeFilename(GetFirstArtist(spotifyArtistName))
+			safeAlbumArtist = sanitizeFilename(GetFirstArtist(spotifyAlbumArtist))
+		}
+
+		safeTitle := sanitizeFilename(spotifyTrackName)
+		safeAlbum := sanitizeFilename(spotifyAlbumName)
+
+		year := ""
+		if len(spotifyReleaseDate) >= 4 {
+			year = spotifyReleaseDate[:4]
+		}
+
+		var newFilename string
+
+		if strings.Contains(filenameFormat, "{") {
+			newFilename = filenameFormat
+			newFilename = strings.ReplaceAll(newFilename, "{title}", safeTitle)
+			newFilename = strings.ReplaceAll(newFilename, "{artist}", safeArtist)
+			newFilename = strings.ReplaceAll(newFilename, "{album}", safeAlbum)
+			newFilename = strings.ReplaceAll(newFilename, "{album_artist}", safeAlbumArtist)
+			newFilename = strings.ReplaceAll(newFilename, "{year}", year)
+			newFilename = strings.ReplaceAll(newFilename, "{date}", SanitizeFilename(spotifyReleaseDate))
+
+			if spotifyDiscNumber > 0 {
+				newFilename = strings.ReplaceAll(newFilename, "{disc}", fmt.Sprintf("%d", spotifyDiscNumber))
+			} else {
+				newFilename = strings.ReplaceAll(newFilename, "{disc}", "")
+			}
+
+			if position > 0 {
+				newFilename = strings.ReplaceAll(newFilename, "{track}", fmt.Sprintf("%02d", position))
+			} else {
+				newFilename = strings.ReplaceAll(newFilename, "{track}", "")
+			}
+		} else {
+			switch filenameFormat {
+			case "artist-title":
+				newFilename = fmt.Sprintf("%s - %s", safeArtist, safeTitle)
+			case "title":
+				newFilename = safeTitle
+			default:
+				newFilename = fmt.Sprintf("%s - %s", safeTitle, safeArtist)
+			}
+
+			if includeTrackNumber && position > 0 {
+				newFilename = fmt.Sprintf("%02d. %s", position, newFilename)
+			}
+		}
+
+		ext := ".flac"
+		newFilename = newFilename + ext
+		newFilePath := filepath.Join(outputDir, newFilename)
+
+		if err := os.Rename(filePath, newFilePath); err != nil {
+			fmt.Printf("Warning: Failed to rename file: %v\n", err)
+		} else {
+			filePath = newFilePath
+			fmt.Printf("Renamed to: %s\n", newFilename)
+		}
+	}
+
+	fmt.Println("Embedding Spotify metadata...")
+
+	coverPath := ""
+	if spotifyCoverURL != "" {
+		coverPath = filePath + ".cover.jpg"
+		coverClient := NewCoverClient()
+		if err := coverClient.DownloadCoverToPath(spotifyCoverURL, coverPath, embedMaxQualityCover); err != nil {
+			fmt.Printf("Warning: Failed to download Spotify cover: %v\n", err)
+			coverPath = ""
+		} else {
+			defer os.Remove(coverPath)
+			fmt.Println("Spotify cover downloaded")
+		}
+	}
+
+	trackNumberToEmbed := spotifyTrackNumber
+	if trackNumberToEmbed == 0 {
+		trackNumberToEmbed = 1
+	}
+
+	metadata := Metadata{
+		Title:       spotifyTrackName,
+		Artist:      spotifyArtistName,
+		Album:       spotifyAlbumName,
+		AlbumArtist: spotifyAlbumArtist,
+		Date:        spotifyReleaseDate,
+		TrackNumber: trackNumberToEmbed,
+		TotalTracks: spotifyTotalTracks,
+		DiscNumber:  spotifyDiscNumber,
+		TotalDiscs:  spotifyTotalDiscs,
+		URL:         spotifyURL,
+		Copyright:   spotifyCopyright,
+		Publisher:   spotifyPublisher,
+		Description: "https://github.com/afkarxyz/SpotiFLAC",
+		ISRC:        isrc,
+		Genre:       mbMeta.Genre,
+	}
+
+	if err := EmbedMetadataToConvertedFile(filePath, metadata, coverPath); err != nil {
+		fmt.Printf("Warning: Failed to embed metadata: %v\n", err)
+	} else {
+		fmt.Println("Metadata embedded successfully")
+	}
+
+	fmt.Println("Done")
+	fmt.Println("✓ Downloaded successfully from Deezer")
+	return filePath, nil
+}

backend/ffmpeg.go

@@ -3,7 +3,7 @@ package backend
 import (
 	"archive/tar"
 	"archive/zip"
-	"encoding/base64"
+
 	"fmt"
 	"io"
 	"net/http"
@@ -18,14 +18,6 @@ import (
 	"github.com/ulikunitz/xz"
 )
 
-func decodeBase64(encoded string) (string, error) {
-	decoded, err := base64.StdEncoding.DecodeString(encoded)
-	if err != nil {
-		return "", err
-	}
-	return string(decoded), nil
-}
-
 func ValidateExecutable(path string) error {
 	cleanedPath := filepath.Clean(path)
 	if cleanedPath == "" {
@@ -65,13 +57,6 @@ func ValidateExecutable(path string) error {
 	return nil
 }
 
-const (
-	ffmpegWindowsURL = "aHR0cHM6Ly9naXRodWIuY29tL0J0Yk4vRkZtcGVnLUJ1aWxkcy9yZWxlYXNlcy9kb3dubG9hZC9sYXRlc3QvZmZtcGVnLW1hc3Rlci1sYXRlc3Qtd2luNjQtZ3BsLnppcA=="
-	ffmpegLinuxURL   = "aHR0cHM6Ly9naXRodWIuY29tL0J0Yk4vRkZtcGVnLUJ1aWxkcy9yZWxlYXNlcy9kb3dubG9hZC9sYXRlc3QvZmZtcGVnLW1hc3Rlci1sYXRlc3QtbGludXg2NC1ncGwudGFyLnh6"
-	ffmpegMacOSURL   = "aHR0cHM6Ly9ldmVybWVldC5jeC9mZm1wZWcvZ2V0cmVsZWFzZS96aXA="
-	ffprobeMacOSURL  = "aHR0cHM6Ly9ldmVybWVldC5jeC9mZm1wZWcvZ2V0cmVsZWFzZS9mZnByb2JlL3ppcA=="
-)
-
 func GetFFmpegDir() (string, error) {
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
@@ -91,7 +76,17 @@ func GetFFmpegPath() (string, error) {
 		ffmpegName = "ffmpeg.exe"
 	}
 
-	return filepath.Join(ffmpegDir, ffmpegName), nil
+	localPath := filepath.Join(ffmpegDir, ffmpegName)
+	if _, err := os.Stat(localPath); err == nil {
+		return localPath, nil
+	}
+
+	path, err := exec.LookPath(ffmpegName)
+	if err == nil {
+		return path, nil
+	}
+
+	return localPath, nil
 }
 
 func GetFFprobePath() (string, error) {
@@ -105,12 +100,17 @@ func GetFFprobePath() (string, error) {
 		ffprobeName = "ffprobe.exe"
 	}
 
-	ffprobePath := filepath.Join(ffmpegDir, ffprobeName)
-	if _, err := os.Stat(ffprobePath); err == nil {
-		return ffprobePath, nil
+	localPath := filepath.Join(ffmpegDir, ffprobeName)
+	if _, err := os.Stat(localPath); err == nil {
+		return localPath, nil
 	}
 
-	return "", fmt.Errorf("ffprobe not found in app directory")
+	path, err := exec.LookPath(ffprobeName)
+	if err == nil {
+		return path, nil
+	}
+
+	return localPath, fmt.Errorf("ffprobe not found in app directory or system path")
 }
 
 func IsFFprobeInstalled() (bool, error) {
@@ -146,6 +146,11 @@ func IsFFmpegInstalled() (bool, error) {
 	return err == nil, nil
 }
 
+const (
+	ffmpegWindowsURL = "https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-windows-amd64.zip"
+	ffmpegLinuxURL   = "https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-linux-amd64.tar.xz"
+)
+
 func DownloadFFmpeg(progressCallback func(int)) error {
 
 	SetDownloadProgress(0)
@@ -166,54 +171,51 @@ func DownloadFFmpeg(progressCallback func(int)) error {
 		ffmpegInstalled, _ := IsFFmpegInstalled()
 		ffprobeInstalled, _ := IsFFprobeInstalled()
 
-		if !ffmpegInstalled && !ffprobeInstalled {
+		isARM := runtime.GOARCH == "arm64"
 
-			ffmpegURL, _ := decodeBase64(ffmpegMacOSURL)
-			fmt.Printf("[FFmpeg] Downloading ffmpeg from: %s\n", ffmpegURL)
-			if err := downloadAndExtract(ffmpegURL, ffmpegDir, progressCallback, 0, 50); err != nil {
+		var macFFmpegURLs []string
+		var macFFprobeURLs []string
+
+		if isARM {
+
+			macFFmpegURLs = []string{"https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-macos-arm64.zip"}
+			macFFprobeURLs = []string{"https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffprobe-macos-arm64.zip"}
+		} else {
+
+			macFFmpegURLs = []string{"https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-macos-intel.zip"}
+			macFFprobeURLs = []string{"https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffprobe-macos-intel.zip"}
+		}
+
+		if !ffmpegInstalled && !ffprobeInstalled {
+			if err := downloadWithFallback(macFFmpegURLs, ffmpegDir, progressCallback, 0, 50); err != nil {
 				return err
 			}
-
-			ffprobeURL, _ := decodeBase64(ffprobeMacOSURL)
-			fmt.Printf("[FFmpeg] Downloading ffprobe from: %s\n", ffprobeURL)
-			if err := downloadAndExtract(ffprobeURL, ffmpegDir, progressCallback, 50, 100); err != nil {
-				return fmt.Errorf("failed to download ffprobe: %w", err)
+			if err := downloadWithFallback(macFFprobeURLs, ffmpegDir, progressCallback, 50, 100); err != nil {
+				return err
 			}
 		} else if !ffmpegInstalled {
-
-			ffmpegURL, _ := decodeBase64(ffmpegMacOSURL)
-			fmt.Printf("[FFmpeg] Downloading ffmpeg from: %s\n", ffmpegURL)
-			if err := downloadAndExtract(ffmpegURL, ffmpegDir, progressCallback, 0, 100); err != nil {
+			if err := downloadWithFallback(macFFmpegURLs, ffmpegDir, progressCallback, 0, 100); err != nil {
 				return err
 			}
 		} else if !ffprobeInstalled {
-
-			ffprobeURL, _ := decodeBase64(ffprobeMacOSURL)
-			fmt.Printf("[FFmpeg] Downloading ffprobe from: %s\n", ffprobeURL)
-			if err := downloadAndExtract(ffprobeURL, ffmpegDir, progressCallback, 0, 100); err != nil {
-				return fmt.Errorf("failed to download ffprobe: %w", err)
+			if err := downloadWithFallback(macFFprobeURLs, ffmpegDir, progressCallback, 0, 100); err != nil {
+				return err
 			}
 		}
 		return nil
 	}
 
-	var encodedURL string
+	var url string
 	switch runtime.GOOS {
 	case "windows":
-		encodedURL = ffmpegWindowsURL
+		url = ffmpegWindowsURL
 	case "linux":
-		encodedURL = ffmpegLinuxURL
+		url = ffmpegLinuxURL
 	default:
 		return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
 	}
 
-	url, err := decodeBase64(encodedURL)
-	if err != nil {
-		return fmt.Errorf("failed to decode ffmpeg URL: %w", err)
-	}
-
 	fmt.Printf("[FFmpeg] Downloading from: %s\n", url)
-
 	if err := downloadAndExtract(url, ffmpegDir, progressCallback, 0, 100); err != nil {
 		return err
 	}
@@ -221,6 +223,20 @@ func DownloadFFmpeg(progressCallback func(int)) error {
 	return nil
 }
 
+func downloadWithFallback(urls []string, destDir string, progressCallback func(int), start, end int) error {
+	var lastErr error
+	for _, url := range urls {
+		fmt.Printf("[FFmpeg] Trying to download from: %s\n", url)
+		err := downloadAndExtract(url, destDir, progressCallback, start, end)
+		if err == nil {
+			return nil
+		}
+		lastErr = err
+		fmt.Printf("[FFmpeg] Attempt failed: %v\n", err)
+	}
+	return fmt.Errorf("all download attempts failed: %w", lastErr)
+}
+
 func downloadAndExtract(url, destDir string, progressCallback func(int), progressStart, progressEnd int) error {
 
 	tmpFile, err := os.CreateTemp("", "ffmpeg-*")
@@ -230,7 +246,14 @@ func downloadAndExtract(url, destDir string, progressCallback func(int), progres
 	defer os.Remove(tmpFile.Name())
 	defer tmpFile.Close()
 
-	resp, err := http.Get(url)
+	client := &http.Client{}
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+
+	resp, err := client.Do(req)
 	if err != nil {
 		return fmt.Errorf("failed to download: %w", err)
 	}

backend/filemanager.go

@@ -332,6 +332,7 @@ func GenerateFilename(metadata *AudioMetadata, format string, ext string) string
 	result = strings.ReplaceAll(result, "{album}", sanitizeFilenameForRename(metadata.Album))
 	result = strings.ReplaceAll(result, "{album_artist}", sanitizeFilenameForRename(metadata.AlbumArtist))
 	result = strings.ReplaceAll(result, "{year}", sanitizeFilenameForRename(year))
+	result = strings.ReplaceAll(result, "{date}", sanitizeFilenameForRename(metadata.Year))
 
 	if metadata.TrackNumber > 0 {
 		result = strings.ReplaceAll(result, "{track}", fmt.Sprintf("%02d", metadata.TrackNumber))

backend/filename.go

@@ -33,6 +33,7 @@ func BuildExpectedFilename(trackName, artistName, albumName, albumArtist, releas
 		filename = strings.ReplaceAll(filename, "{album}", safeAlbum)
 		filename = strings.ReplaceAll(filename, "{album_artist}", safeAlbumArtist)
 		filename = strings.ReplaceAll(filename, "{year}", year)
+		filename = strings.ReplaceAll(filename, "{date}", SanitizeFilename(releaseDate))
 		filename = strings.ReplaceAll(filename, "{playlist}", safePlaylist)
 		filename = strings.ReplaceAll(filename, "{creator}", safeCreator)
 
@@ -118,6 +119,19 @@ func SanitizeFilename(name string) string {
 	return sanitized
 }
 
+func GetFirstArtist(artistString string) string {
+	if artistString == "" {
+		return ""
+	}
+	delimiters := []string{", ", " & ", " feat. ", " ft. ", " featuring "}
+	for _, d := range delimiters {
+		if idx := strings.Index(strings.ToLower(artistString), d); idx != -1 {
+			return strings.TrimSpace(artistString[:idx])
+		}
+	}
+	return artistString
+}
+
 func NormalizePath(folderPath string) string {
 
 	return strings.ReplaceAll(folderPath, "/", string(filepath.Separator))

backend/lyrics.go

@@ -1,7 +1,6 @@
 package backend
 
 import (
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -38,6 +37,17 @@ type LyricsResponse struct {
 	Lines    []LyricsLine `json:"lines"`
 }
 
+type SpotifyLyricsLine struct {
+	TimeTag string `json:"timeTag"`
+	Words   string `json:"words"`
+}
+
+type SpotifyLyricsAPIResponse struct {
+	Error    bool                `json:"error"`
+	SyncType string              `json:"syncType"`
+	Lines    []SpotifyLyricsLine `json:"lines"`
+}
+
 type LyricsDownloadRequest struct {
 	SpotifyID           string `json:"spotify_id"`
 	TrackName           string `json:"track_name"`
@@ -73,9 +83,7 @@ func NewLyricsClient() *LyricsClient {
 
 func (c *LyricsClient) FetchLyricsWithMetadata(trackName, artistName string, duration int) (*LyricsResponse, error) {
 
-	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9scmNsaWIubmV0L2FwaS9nZXQ/YXJ0aXN0X25hbWU9")
-	apiURL := fmt.Sprintf("%s%s&track_name=%s",
-		string(apiBase),
+	apiURL := fmt.Sprintf("https://lrclib.net/api/get?artist_name=%s&track_name=%s",
 		url.QueryEscape(artistName),
 		url.QueryEscape(trackName))
 
@@ -167,8 +175,7 @@ func lrcTimestampToMs(timestamp string) int64 {
 
 func (c *LyricsClient) FetchLyricsFromLRCLibSearch(trackName, artistName string) (*LyricsResponse, error) {
 	query := fmt.Sprintf("%s %s", artistName, trackName)
-	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9scmNsaWIubmV0L2FwaS9zZWFyY2g/cT0=")
-	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(query))
+	apiURL := fmt.Sprintf("https://lrclib.net/api/search?q=%s", url.QueryEscape(query))
 
 	resp, err := c.httpClient.Get(apiURL)
 	if err != nil {
@@ -212,6 +219,61 @@ func (c *LyricsClient) FetchLyricsFromLRCLibSearch(trackName, artistName string)
 	return c.convertLRCLibToLyricsResponse(best), nil
 }
 
+func (c *LyricsClient) FetchLyricsFromSpotifyAPI(spotifyID string) (*LyricsResponse, error) {
+	if spotifyID == "" {
+		return nil, fmt.Errorf("spotify ID is empty")
+	}
+
+	apiURL := fmt.Sprintf("https://spotify-lyrics-api-pi.vercel.app/?trackid=%s&format=lrc", spotifyID)
+
+	resp, err := c.httpClient.Get(apiURL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch from Spotify Lyrics API: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("Spotify Lyrics API returned status %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read Spotify Lyrics API response: %v", err)
+	}
+
+	var apiResp SpotifyLyricsAPIResponse
+	if err := json.Unmarshal(body, &apiResp); err != nil {
+		return nil, fmt.Errorf("failed to parse Spotify Lyrics API response: %v", err)
+	}
+
+	if apiResp.Error {
+		return nil, fmt.Errorf("Spotify Lyrics API returned error")
+	}
+
+	result := &LyricsResponse{
+		Error:    false,
+		SyncType: apiResp.SyncType,
+		Lines:    []LyricsLine{},
+	}
+
+	for _, line := range apiResp.Lines {
+		if line.TimeTag == "" && line.Words == "" {
+			continue
+		}
+		ms := lrcTimestampToMs(line.TimeTag)
+		result.Lines = append(result.Lines, LyricsLine{
+			StartTimeMs: fmt.Sprintf("%d", ms),
+			Words:       line.Words,
+		})
+	}
+
+	if len(result.Lines) == 0 {
+		return nil, fmt.Errorf("Spotify Lyrics API returned empty lines")
+	}
+
+	return result, nil
+}
+
 func simplifyTrackName(name string) string {
 
 	if idx := strings.Index(name, "("); idx > 0 {
@@ -226,7 +288,13 @@ func simplifyTrackName(name string) string {
 
 func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName string, duration int) (*LyricsResponse, string, error) {
 
-	resp, err := c.FetchLyricsWithMetadata(trackName, artistName, duration)
+	resp, err := c.FetchLyricsFromSpotifyAPI(spotifyID)
+	if err == nil && resp != nil && !resp.Error && len(resp.Lines) > 0 {
+		return resp, "Spotify", nil
+	}
+	fmt.Printf("   Spotify Lyrics API: %v\n", err)
+
+	resp, err = c.FetchLyricsWithMetadata(trackName, artistName, duration)
 	if err == nil && resp != nil && !resp.Error && len(resp.Lines) > 0 {
 		return resp, "LRCLIB", nil
 	}
@@ -313,6 +381,7 @@ func buildLyricsFilename(trackName, artistName, albumName, albumArtist, releaseD
 		filename = strings.ReplaceAll(filename, "{album}", safeAlbum)
 		filename = strings.ReplaceAll(filename, "{album_artist}", safeAlbumArtist)
 		filename = strings.ReplaceAll(filename, "{year}", year)
+		filename = strings.ReplaceAll(filename, "{date}", sanitizeFilename(releaseDate))
 
 		if discNumber > 0 {
 			filename = strings.ReplaceAll(filename, "{disc}", fmt.Sprintf("%d", discNumber))

backend/metadata.go

@@ -31,6 +31,8 @@ type Metadata struct {
 	Publisher   string
 	Lyrics      string
 	Description string
+	ISRC        string
+	Genre       string
 }
 
 func EmbedMetadata(filepath string, metadata Metadata, coverPath string) error {
@@ -86,6 +88,14 @@ func EmbedMetadata(filepath string, metadata Metadata, coverPath string) error {
 		_ = cmt.Add("DESCRIPTION", metadata.Description)
 	}
 
+	if metadata.ISRC != "" {
+		_ = cmt.Add("ISRC", metadata.ISRC)
+	}
+
+	if metadata.Genre != "" {
+		_ = cmt.Add("GENRE", metadata.Genre)
+	}
+
 	if metadata.Lyrics != "" {
 		_ = cmt.Add("LYRICS", metadata.Lyrics)
 	}
@@ -504,6 +514,13 @@ func EmbedLyricsOnlyUniversal(filepath string, lyrics string) error {
 		return nil
 	}
 
+	validatedLyrics, err := validateLyricsDuration(lyrics, filepath)
+	if err != nil {
+		fmt.Printf("[EmbedLyricsOnlyUniversal] Warning: Failed to validate lyrics duration: %v, using original lyrics\n", err)
+		validatedLyrics = lyrics
+	}
+	lyrics = validatedLyrics
+
 	ext := strings.ToLower(pathfilepath.Ext(filepath))
 	switch ext {
 	case ".mp3":
@@ -635,27 +652,22 @@ func validateLyricsDuration(lyrics string, filepath string) (string, error) {
 
 		if strings.HasPrefix(trimmedLine, "[") {
 
-			if strings.Index(trimmedLine, ":") > 0 {
-
-				validLines = append(validLines, line)
-				continue
-			}
-
 			closeBracket := strings.Index(trimmedLine, "]")
 			if closeBracket > 0 {
 				timestampStr := trimmedLine[1:closeBracket]
 
 				ms := parseLRCTimestamp(timestampStr)
-				if ms >= 0 && ms <= durationMs {
-
-					validLines = append(validLines, line)
+				if ms >= 0 {
+					if ms <= durationMs {
+						validLines = append(validLines, line)
+					} else {
+						fmt.Printf("[ValidateLyrics] Filtered out line with timestamp %s (exceeds duration %d ms): %s\n", timestampStr, durationMs, trimmedLine)
+					}
 				} else {
 
-					fmt.Printf("[ValidateLyrics] Filtered out line with timestamp %s (exceeds duration %d ms): %s\n", timestampStr, durationMs, trimmedLine)
+					validLines = append(validLines, line)
 				}
-			} else {
-
-				validLines = append(validLines, line)
+				continue
 			}
 		} else {
 
@@ -858,6 +870,11 @@ func embedMetadataToMP3(filePath string, metadata Metadata, coverPath string) er
 		tag.AddTextFrame("TPUB", id3v2.EncodingUTF8, metadata.Publisher)
 	}
 
+	if metadata.ISRC != "" {
+		tag.DeleteFrames("TSRC")
+		tag.AddTextFrame("TSRC", id3v2.EncodingUTF8, metadata.ISRC)
+	}
+
 	if coverPath != "" && fileExists(coverPath) {
 
 		tag.DeleteFrames(tag.CommonID("Attached picture"))
@@ -941,6 +958,9 @@ func embedMetadataToM4A(filePath string, metadata Metadata, coverPath string) er
 	if metadata.Publisher != "" {
 		args = append(args, "-metadata", "publisher="+metadata.Publisher)
 	}
+	if metadata.ISRC != "" {
+		args = append(args, "-metadata", "isrc="+metadata.ISRC)
+	}
 
 	tmpOutputFile := strings.TrimSuffix(filePath, pathfilepath.Ext(filePath)) + ".tmp" + pathfilepath.Ext(filePath)
 	defer func() {

backend/musicbrainz.go

@@ -0,0 +1,154 @@
+package backend
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+)
+
+var AppVersion = "Unknown"
+
+const musicBrainzAPIBase = "https://musicbrainz.org/ws/2"
+
+type MusicBrainzRecordingResponse struct {
+	Recordings []struct {
+		ID       string `json:"id"`
+		Title    string `json:"title"`
+		Length   int    `json:"length"`
+		Releases []struct {
+			ID           string `json:"id"`
+			Title        string `json:"title"`
+			Status       string `json:"status"`
+			ReleaseGroup struct {
+				ID          string `json:"id"`
+				Title       string `json:"title"`
+				PrimaryType string `json:"primary-type"`
+			} `json:"release-group"`
+			Date    string `json:"date"`
+			Country string `json:"country"`
+			Media   []struct {
+				Format string `json:"format"`
+			} `json:"media"`
+			LabelInfo []struct {
+				Label struct {
+					Name string `json:"name"`
+				} `json:"label"`
+			} `json:"label-info"`
+		} `json:"releases"`
+		ArtistCredit []struct {
+			Artist struct {
+				ID   string `json:"id"`
+				Name string `json:"name"`
+			} `json:"artist"`
+		} `json:"artist-credit"`
+		Tags []struct {
+			Count int    `json:"count"`
+			Name  string `json:"name"`
+		} `json:"tags"`
+	} `json:"recordings"`
+}
+
+func FetchMusicBrainzMetadata(isrc, title, artist, album string, useSingleGenre bool, embedGenre bool) (Metadata, error) {
+	var meta Metadata
+
+	if !embedGenre {
+		return meta, nil
+	}
+
+	if isrc == "" {
+		return meta, fmt.Errorf("no ISRC provided")
+	}
+
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	query := fmt.Sprintf("isrc:%s", isrc)
+	reqURL := fmt.Sprintf("%s/recording?query=%s&fmt=json&inc=releases+artist-credits+tags+media+release-groups+labels", musicBrainzAPIBase, url.QueryEscape(query))
+
+	req, err := http.NewRequest("GET", reqURL, nil)
+	if err != nil {
+		return meta, err
+	}
+
+	req.Header.Set("User-Agent", fmt.Sprintf("SpotiFLAC/%s ( support@exyezed.cc )", AppVersion))
+
+	var resp *http.Response
+	var lastErr error
+
+	for i := 0; i < 3; i++ {
+		resp, lastErr = client.Do(req)
+		if lastErr == nil && resp.StatusCode == http.StatusOK {
+			break
+		}
+
+		if resp != nil {
+			resp.Body.Close()
+		}
+
+		if i < 2 {
+			time.Sleep(2 * time.Second)
+		}
+	}
+
+	if lastErr != nil {
+		return meta, lastErr
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		resp.Body.Close()
+		return meta, fmt.Errorf("MusicBrainz API returned status: %d", resp.StatusCode)
+	}
+	defer resp.Body.Close()
+
+	var mbResp MusicBrainzRecordingResponse
+	if err := json.NewDecoder(resp.Body).Decode(&mbResp); err != nil {
+		return meta, err
+	}
+
+	if len(mbResp.Recordings) == 0 {
+		return meta, fmt.Errorf("no recordings found for ISRC: %s", isrc)
+	}
+
+	recording := mbResp.Recordings[0]
+
+	var genres []string
+	caser := cases.Title(language.English)
+
+	if useSingleGenre {
+
+		maxCount := -1
+		var bestTag string
+
+		for _, tag := range recording.Tags {
+			if tag.Count > maxCount {
+				maxCount = tag.Count
+				bestTag = tag.Name
+			}
+		}
+
+		if bestTag != "" {
+			meta.Genre = caser.String(bestTag)
+		}
+	} else {
+		for _, tag := range recording.Tags {
+
+			genres = append(genres, caser.String(tag.Name))
+		}
+		if len(genres) > 0 {
+
+			if len(genres) > 5 {
+				genres = genres[:5]
+			}
+			meta.Genre = strings.Join(genres, "; ")
+		}
+	}
+
+	return meta, nil
+}

backend/progress.go

@@ -22,7 +22,7 @@ type DownloadItem struct {
 	TrackName    string         `json:"track_name"`
 	ArtistName   string         `json:"artist_name"`
 	AlbumName    string         `json:"album_name"`
-	ISRC         string         `json:"isrc"`
+	SpotifyID    string         `json:"spotify_id"`
 	Status       DownloadStatus `json:"status"`
 	Progress     float64        `json:"progress"`
 	TotalSize    float64        `json:"total_size"`
@@ -184,7 +184,7 @@ func (pw *ProgressWriter) GetTotal() int64 {
 	return pw.total
 }
 
-func AddToQueue(id, trackName, artistName, albumName, isrc string) {
+func AddToQueue(id, trackName, artistName, albumName, spotifyID string) {
 	downloadQueueLock.Lock()
 	defer downloadQueueLock.Unlock()
 
@@ -193,7 +193,7 @@ func AddToQueue(id, trackName, artistName, albumName, isrc string) {
 		TrackName:  trackName,
 		ArtistName: artistName,
 		AlbumName:  albumName,
-		ISRC:       isrc,
+		SpotifyID:  spotifyID,
 		Status:     StatusQueued,
 		Progress:   0,
 		TotalSize:  0,

backend/qobuz.go

@@ -77,7 +77,7 @@ func NewQobuzDownloader() *QobuzDownloader {
 	}
 }
 
-func (q *QobuzDownloader) SearchByISRC(isrc string) (*QobuzTrack, error) {
+func (q *QobuzDownloader) searchByISRC(isrc string) (*QobuzTrack, error) {
 	apiBase := "https://www.qobuz.com/api.json/0.2/track/search?query="
 	url := fmt.Sprintf("%s%s&limit=1&app_id=%s", apiBase, isrc, q.appID)
 
@@ -118,78 +118,6 @@ func (q *QobuzDownloader) SearchByISRC(isrc string) (*QobuzTrack, error) {
 	return &searchResp.Tracks.Items[0], nil
 }
 
-func decodeXOR(data []byte) string {
-	text := string(data)
-	runes := []rune(text)
-	result := make([]rune, len(runes))
-	for i, char := range runes {
-		key := rune((i * 17) % 128)
-		result[i] = char ^ 253 ^ key
-	}
-	return string(result)
-}
-
-func (q *QobuzDownloader) mapJumoQuality(quality string) int {
-	switch quality {
-	case "6":
-		return 6
-	case "7":
-		return 7
-	case "27":
-		return 27
-	default:
-		return 6
-	}
-}
-
-func (q *QobuzDownloader) DownloadFromJumo(trackID int64, quality string) (string, error) {
-	formatID := q.mapJumoQuality(quality)
-	region := "US"
-	url := fmt.Sprintf("https://jumo-dl.pages.dev/file?track_id=%d&format_id=%d&region=%s", trackID, formatID, region)
-
-	client := &http.Client{Timeout: 30 * time.Second}
-	resp, err := client.Get(url)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("HTTP %d", resp.StatusCode)
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-
-	var result map[string]interface{}
-
-	if err := json.Unmarshal(body, &result); err != nil {
-
-		decoded := decodeXOR(body)
-		if err := json.Unmarshal([]byte(decoded), &result); err != nil {
-			return "", fmt.Errorf("failed to parse JSON (plain or XOR): %w", err)
-		}
-	}
-
-	if urlVal, ok := result["url"].(string); ok && urlVal != "" {
-		return urlVal, nil
-	}
-
-	if data, ok := result["data"].(map[string]interface{}); ok {
-		if urlVal, ok := data["url"].(string); ok && urlVal != "" {
-			return urlVal, nil
-		}
-	}
-
-	if linkVal, ok := result["link"].(string); ok && linkVal != "" {
-		return linkVal, nil
-	}
-
-	return "", fmt.Errorf("URL not found in Jumo response")
-}
-
 func (q *QobuzDownloader) DownloadFromStandard(apiBase string, trackID int64, quality string) (string, error) {
 	apiURL := fmt.Sprintf("%s%d&quality=%s", apiBase, trackID, quality)
 	resp, err := q.client.Get(apiURL)
@@ -216,6 +144,15 @@ func (q *QobuzDownloader) DownloadFromStandard(apiBase string, trackID int64, qu
 		return streamResp.URL, nil
 	}
 
+	var nestedResp struct {
+		Data struct {
+			URL string `json:"url"`
+		} `json:"data"`
+	}
+	if err := json.Unmarshal(body, &nestedResp); err == nil && nestedResp.Data.URL != "" {
+		return nestedResp.Data.URL, nil
+	}
+
 	return "", fmt.Errorf("invalid response")
 }
 
@@ -230,7 +167,6 @@ func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string, allowFal
 	standardAPIs := []string{
 		"https://dab.yeet.su/api/stream?trackId=",
 		"https://dabmusic.xyz/api/stream?trackId=",
-		"https://qobuz.squid.wtf/api/download-music?track_id=",
 	}
 
 	downloadFunc := func(qual string) (string, error) {
@@ -251,13 +187,6 @@ func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string, allowFal
 			})
 		}
 
-		providers = append(providers, Provider{
-			Name: "Jumo-DL",
-			Func: func() (string, error) {
-				return q.DownloadFromJumo(trackID, qual)
-			},
-		})
-
 		rand.Seed(time.Now().UnixNano())
 		rand.Shuffle(len(providers), func(i, j int) { providers[i], providers[j] = providers[j], providers[i] })
 
@@ -389,6 +318,7 @@ func buildQobuzFilename(title, artist, album, albumArtist, releaseDate string, t
 		filename = strings.ReplaceAll(filename, "{album}", album)
 		filename = strings.ReplaceAll(filename, "{album_artist}", albumArtist)
 		filename = strings.ReplaceAll(filename, "{year}", year)
+		filename = strings.ReplaceAll(filename, "{date}", SanitizeFilename(releaseDate))
 
 		if discNumber > 0 {
 			filename = strings.ReplaceAll(filename, "{disc}", fmt.Sprintf("%d", discNumber))
@@ -423,16 +353,48 @@ func buildQobuzFilename(title, artist, album, albumArtist, releaseDate string, t
 	return filename + ".flac"
 }
 
-func (q *QobuzDownloader) DownloadByISRC(deezerISRC, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool) (string, error) {
+func (q *QobuzDownloader) DownloadTrack(spotifyID, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
+	var deezerISRC string
+	if spotifyID != "" {
+		songlinkClient := NewSongLinkClient()
+		isrc, err := songlinkClient.GetISRC(spotifyID)
+		if err != nil {
+			return "", fmt.Errorf("failed to get ISRC: %v", err)
+		}
+		deezerISRC = isrc
+	} else {
+		return "", fmt.Errorf("spotify ID is required for Qobuz download")
+	}
+
+	return q.DownloadTrackWithISRC(deezerISRC, spotifyID, outputDir, quality, filenameFormat, includeTrackNumber, position, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, useAlbumTrackNumber, spotifyCoverURL, embedMaxQualityCover, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, spotifyTotalDiscs, spotifyCopyright, spotifyPublisher, spotifyURL, allowFallback, useFirstArtistOnly, useSingleGenre, embedGenre)
+}
+
+func (q *QobuzDownloader) DownloadTrackWithISRC(deezerISRC, spotifyID, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
 	fmt.Printf("Fetching track info for ISRC: %s\n", deezerISRC)
 
+	metaChan := make(chan Metadata, 1)
+	if embedGenre && deezerISRC != "" {
+		go func() {
+			fmt.Println("Fetching MusicBrainz metadata...")
+			if fetchedMeta, err := FetchMusicBrainzMetadata(deezerISRC, spotifyTrackName, spotifyArtistName, spotifyAlbumName, useSingleGenre, embedGenre); err == nil {
+				fmt.Println("✓ MusicBrainz metadata fetched")
+				metaChan <- fetchedMeta
+			} else {
+				fmt.Printf("Warning: Failed to fetch MusicBrainz metadata: %v\n", err)
+				metaChan <- Metadata{}
+			}
+		}()
+	} else {
+		close(metaChan)
+	}
+
 	if outputDir != "." {
 		if err := os.MkdirAll(outputDir, 0755); err != nil {
 			return "", fmt.Errorf("failed to create output directory: %w", err)
 		}
 	}
 
-	track, err := q.SearchByISRC(deezerISRC)
+	track, err := q.searchByISRC(deezerISRC)
 	if err != nil {
 		return "", err
 	}
@@ -467,9 +429,15 @@ func (q *QobuzDownloader) DownloadByISRC(deezerISRC, outputDir, quality, filenam
 	fmt.Printf("Download URL obtained: %s\n", urlPreview)
 
 	safeArtist := sanitizeFilename(artists)
+	safeAlbumArtist := sanitizeFilename(spotifyAlbumArtist)
+
+	if useFirstArtistOnly {
+		safeArtist = sanitizeFilename(GetFirstArtist(artists))
+		safeAlbumArtist = sanitizeFilename(GetFirstArtist(spotifyAlbumArtist))
+	}
+
 	safeTitle := sanitizeFilename(trackTitle)
 	safeAlbum := sanitizeFilename(albumTitle)
-	safeAlbumArtist := sanitizeFilename(spotifyAlbumArtist)
 
 	filename := buildQobuzFilename(safeTitle, safeArtist, safeAlbum, safeAlbumArtist, spotifyReleaseDate, spotifyTrackNumber, spotifyDiscNumber, filenameFormat, includeTrackNumber, position, useAlbumTrackNumber)
 	filepath := filepath.Join(outputDir, filename)
@@ -500,6 +468,11 @@ func (q *QobuzDownloader) DownloadByISRC(deezerISRC, outputDir, quality, filenam
 		}
 	}
 
+	var mbMeta Metadata
+	if deezerISRC != "" {
+		mbMeta = <-metaChan
+	}
+
 	fmt.Println("Embedding metadata and cover art...")
 
 	trackNumberToEmbed := spotifyTrackNumber
@@ -521,6 +494,8 @@ func (q *QobuzDownloader) DownloadByISRC(deezerISRC, outputDir, quality, filenam
 		Copyright:   spotifyCopyright,
 		Publisher:   spotifyPublisher,
 		Description: "https://github.com/afkarxyz/SpotiFLAC",
+		ISRC:        deezerISRC,
+		Genre:       mbMeta.Genre,
 	}
 
 	if err := EmbedMetadata(filepath, metadata, coverPath); err != nil {

backend/songlink.go

@@ -1,7 +1,6 @@
 package backend
 
 import (
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -21,6 +20,7 @@ type SongLinkClient struct {
 type SongLinkURLs struct {
 	TidalURL  string `json:"tidal_url"`
 	AmazonURL string `json:"amazon_url"`
+	ISRC      string `json:"isrc"`
 }
 
 type TrackAvailability struct {
@@ -28,9 +28,11 @@ type TrackAvailability struct {
 	Tidal     bool   `json:"tidal"`
 	Amazon    bool   `json:"amazon"`
 	Qobuz     bool   `json:"qobuz"`
+	Deezer    bool   `json:"deezer"`
 	TidalURL  string `json:"tidal_url,omitempty"`
 	AmazonURL string `json:"amazon_url,omitempty"`
 	QobuzURL  string `json:"qobuz_url,omitempty"`
+	DeezerURL string `json:"deezer_url,omitempty"`
 }
 
 func NewSongLinkClient() *SongLinkClient {
@@ -70,11 +72,9 @@ func (s *SongLinkClient) GetAllURLsFromSpotify(spotifyTrackID string, region str
 		}
 	}
 
-	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
-	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)
+	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
 
-	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
-	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(spotifyURL))
+	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?url=%s", url.QueryEscape(spotifyURL))
 
 	if region != "" {
 		apiURL += fmt.Sprintf("&userCountry=%s", region)
@@ -158,6 +158,12 @@ func (s *SongLinkClient) GetAllURLsFromSpotify(spotifyTrackID string, region str
 		}
 	}
 
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		if isrc, err := getDeezerISRC(deezerLink.URL); err == nil && isrc != "" {
+			urls.ISRC = isrc
+		}
+	}
+
 	if urls.TidalURL == "" && urls.AmazonURL == "" {
 		return nil, fmt.Errorf("no streaming URLs found")
 	}
@@ -165,7 +171,7 @@ func (s *SongLinkClient) GetAllURLsFromSpotify(spotifyTrackID string, region str
 	return urls, nil
 }
 
-func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
+func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string) (*TrackAvailability, error) {
 
 	now := time.Now()
 	if now.Sub(s.apiCallResetTime) >= time.Minute {
@@ -193,11 +199,9 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 		}
 	}
 
-	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
-	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)
+	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
 
-	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
-	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(spotifyURL))
+	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?url=%s", url.QueryEscape(spotifyURL))
 
 	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
@@ -277,8 +281,10 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		deezerURL := deezerLink.URL
+		availability.Deezer = true
+		availability.DeezerURL = deezerURL
 
-		deezerISRC, err := GetDeezerISRC(deezerURL)
+		deezerISRC, err := getDeezerISRC(deezerURL)
 		if err == nil && deezerISRC != "" {
 			qobuzAvailable := checkQobuzAvailability(deezerISRC)
 			availability.Qobuz = qobuzAvailable
@@ -292,8 +298,7 @@ func checkQobuzAvailability(isrc string) bool {
 	client := &http.Client{Timeout: 10 * time.Second}
 	appID := "798273057"
 
-	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
-	searchURL := fmt.Sprintf("%s%s&limit=1&app_id=%s", string(apiBase), isrc, appID)
+	searchURL := fmt.Sprintf("https://www.qobuz.com/api.json/0.2/track/search?query=%s&limit=1&app_id=%s", isrc, appID)
 
 	resp, err := client.Get(searchURL)
 	if err != nil {
@@ -345,11 +350,9 @@ func (s *SongLinkClient) GetDeezerURLFromSpotify(spotifyTrackID string) (string,
 		}
 	}
 
-	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
-	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)
+	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
 
-	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
-	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(spotifyURL))
+	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?url=%s", url.QueryEscape(spotifyURL))
 
 	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
@@ -408,7 +411,7 @@ func (s *SongLinkClient) GetDeezerURLFromSpotify(spotifyTrackID string) (string,
 	return deezerURL, nil
 }
 
-func GetDeezerISRC(deezerURL string) (string, error) {
+func getDeezerISRC(deezerURL string) (string, error) {
 
 	var trackID string
 	if strings.Contains(deezerURL, "/track/") {
@@ -452,3 +455,11 @@ func GetDeezerISRC(deezerURL string) (string, error) {
 	fmt.Printf("Found ISRC from Deezer: %s (track: %s)\n", deezerTrack.ISRC, deezerTrack.Title)
 	return deezerTrack.ISRC, nil
 }
+
+func (s *SongLinkClient) GetISRC(spotifyID string) (string, error) {
+	deezerURL, err := s.GetDeezerURLFromSpotify(spotifyID)
+	if err != nil {
+		return "", err
+	}
+	return getDeezerISRC(deezerURL)
+}

backend/spotfetch.go

@@ -2,9 +2,7 @@ package backend
 
 import (
 	"bytes"
-	"encoding/base32"
 	"encoding/base64"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -41,39 +39,10 @@ func NewSpotifyClient() *SpotifyClient {
 	}
 }
 
-func (c *SpotifyClient) getTOTPSecret() (int, []byte) {
-	secrets := map[int][]byte{
-		59: {123, 105, 79, 70, 110, 59, 52, 125, 60, 49, 80, 70, 89, 75, 80, 86, 63, 53, 123, 37, 117, 49, 52, 93, 77, 62, 47, 86, 48, 104, 68, 72},
-		60: {79, 109, 69, 123, 90, 65, 46, 74, 94, 34, 58, 48, 70, 71, 92, 85, 122, 63, 91, 64, 87, 87},
-		61: {44, 55, 47, 42, 70, 40, 34, 114, 76, 74, 50, 111, 120, 97, 75, 76, 94, 102, 43, 69, 49, 120, 118, 80, 64, 78},
-	}
-
-	version := 61
-	secretList := secrets[version]
-	return version, secretList
-}
-
 func (c *SpotifyClient) generateTOTP() (string, int, error) {
-	version, secretList := c.getTOTPSecret()
 
-	transformed := make([]byte, len(secretList))
-	for i, b := range secretList {
-		transformed[i] = b ^ byte((i%33)+9)
-	}
-
-	var joined strings.Builder
-	for _, b := range transformed {
-		joined.WriteString(strconv.Itoa(int(b)))
-	}
-
-	hexStr := hex.EncodeToString([]byte(joined.String()))
-	hexBytes, err := hex.DecodeString(hexStr)
-	if err != nil {
-		return "", 0, err
-	}
-
-	secret := base32Encode(hexBytes)
-	secret = strings.TrimRight(secret, "=")
+	secret := "GM3TMMJTGYZTQNZVGM4DINJZHA4TGOBYGMZTCMRTGEYDSMJRHE4TEOBUG4YTCMRUGQ4DQOJUGQYTAMRRGA2TCMJSHE3TCMBY"
+	version := 61
 
 	key, err := otp.NewKeyFromURL(fmt.Sprintf("otpauth://totp/secret?secret=%s", secret))
 	if err != nil {
@@ -88,11 +57,6 @@ func (c *SpotifyClient) generateTOTP() (string, int, error) {
 	return totpCode, version, nil
 }
 
-func base32Encode(data []byte) string {
-	b32 := base32.StdEncoding.WithPadding(base32.NoPadding)
-	return b32.EncodeToString(data)
-}
-
 func (c *SpotifyClient) getAccessToken() error {
 	totpCode, version, err := c.generateTOTP()
 	if err != nil {
@@ -112,7 +76,7 @@ func (c *SpotifyClient) getAccessToken() error {
 	q.Add("totpServer", totpCode)
 	req.URL.RawQuery = q.Encode()
 
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
 
 	resp, err := c.client.Do(req)
@@ -149,7 +113,7 @@ func (c *SpotifyClient) getSessionInfo() error {
 		return err
 	}
 
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 
 	for name, value := range c.cookies {
 		req.AddCookie(&http.Cookie{Name: name, Value: value})
@@ -230,7 +194,7 @@ func (c *SpotifyClient) getClientToken() error {
 	req.Header.Set("Authority", "clienttoken.spotify.com")
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Accept", "application/json")
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 
 	resp, err := c.client.Do(req)
 	if err != nil {
@@ -288,7 +252,7 @@ func (c *SpotifyClient) Query(payload map[string]interface{}) (map[string]interf
 	req.Header.Set("Client-Token", c.clientToken)
 	req.Header.Set("Spotify-App-Version", c.clientVersion)
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 
 	resp, err := c.client.Do(req)
 	if err != nil {
@@ -364,9 +328,6 @@ func getBool(m map[string]interface{}, key string) bool {
 
 func extractArtists(artistsData map[string]interface{}) []map[string]interface{} {
 	items := getSlice(artistsData, "items")
-	if items == nil {
-		return []map[string]interface{}{}
-	}
 
 	artists := []map[string]interface{}{}
 	for _, item := range items {
@@ -384,7 +345,7 @@ func extractArtists(artistsData map[string]interface{}) []map[string]interface{}
 }
 
 func extractCoverImage(coverData map[string]interface{}) map[string]interface{} {
-	if coverData == nil || len(coverData) == 0 {
+	if len(coverData) == 0 {
 		return nil
 	}
 
@@ -401,7 +362,7 @@ func extractCoverImage(coverData map[string]interface{}) map[string]interface{}
 		}
 	}
 
-	if sources == nil || len(sources) == 0 {
+	if len(sources) == 0 {
 		return nil
 	}
 
@@ -532,7 +493,7 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 	}
 
 	var albumFetchDataMap map[string]interface{}
-	if len(albumFetchData) > 0 && albumFetchData[0] != nil {
+	if len(albumFetchData) > 0 {
 		albumFetchDataMap = albumFetchData[0]
 	}
 
@@ -541,39 +502,35 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 	if len(artists) == 0 {
 		artists = []map[string]interface{}{}
 		firstArtistItems := getSlice(getMap(trackData, "firstArtist"), "items")
-		if firstArtistItems != nil {
-			for _, item := range firstArtistItems {
-				itemMap, ok := item.(map[string]interface{})
-				if !ok {
-					continue
-				}
-				if profile, exists := itemMap["profile"]; exists {
-					profileMap, ok := profile.(map[string]interface{})
-					if ok {
-						artistInfo := map[string]interface{}{
-							"name": getString(profileMap, "name"),
-						}
-						artists = append(artists, artistInfo)
+		for _, item := range firstArtistItems {
+			itemMap, ok := item.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if profile, exists := itemMap["profile"]; exists {
+				profileMap, ok := profile.(map[string]interface{})
+				if ok {
+					artistInfo := map[string]interface{}{
+						"name": getString(profileMap, "name"),
 					}
+					artists = append(artists, artistInfo)
 				}
 			}
 		}
 
 		otherArtistItems := getSlice(getMap(trackData, "otherArtists"), "items")
-		if otherArtistItems != nil {
-			for _, item := range otherArtistItems {
-				itemMap, ok := item.(map[string]interface{})
-				if !ok {
-					continue
-				}
-				if profile, exists := itemMap["profile"]; exists {
-					profileMap, ok := profile.(map[string]interface{})
-					if ok {
-						artistInfo := map[string]interface{}{
-							"name": getString(profileMap, "name"),
-						}
-						artists = append(artists, artistInfo)
+		for _, item := range otherArtistItems {
+			itemMap, ok := item.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if profile, exists := itemMap["profile"]; exists {
+				profileMap, ok := profile.(map[string]interface{})
+				if ok {
+					artistInfo := map[string]interface{}{
+						"name": getString(profileMap, "name"),
 					}
+					artists = append(artists, artistInfo)
 				}
 			}
 		}
@@ -710,6 +667,9 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 					}
 					albumArtistsString = strings.Join(albumArtistNames, ", ")
 				}
+				if albumArtistsString == "" {
+					albumArtistsString = getString(albumUnionData, "artists")
+				}
 				albumLabel = getString(albumUnionData, "label")
 			}
 		}
@@ -767,8 +727,57 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 	if discNumber == 0 {
 		discNumber = 1
 	}
+
+	maxDiscFromAlbum := 0
+	totalDiscsFromAlbum := 0
+
+	if len(albumFetchData) > 0 && albumFetchData[0] != nil {
+		albumUnion := getMap(getMap(albumFetchData[0], "data"), "albumUnion")
+		if len(albumUnion) > 0 {
+			discsData := getMap(albumUnion, "discs")
+			if len(discsData) > 0 {
+				totalDiscsFromAlbum = int(getFloat64(discsData, "totalCount"))
+			}
+
+			albumTracks := getMap(albumUnion, "tracks")
+			if len(albumTracks) > 0 {
+				albumTrackItems := getSlice(albumTracks, "items")
+				currentTrackID := getString(trackData, "id")
+				for idx, item := range albumTrackItems {
+					itemMap, ok := item.(map[string]interface{})
+					if !ok {
+						continue
+					}
+					trackItem := getMap(itemMap, "track")
+					if len(trackItem) > 0 {
+						dNum := int(getFloat64(trackItem, "discNumber"))
+						if dNum > maxDiscFromAlbum {
+							maxDiscFromAlbum = dNum
+						}
+
+						trackURI := getString(trackItem, "uri")
+						if strings.Contains(trackURI, currentTrackID) || getString(trackItem, "id") == currentTrackID {
+							if dNum > 0 {
+								discNumber = dNum
+							}
+						}
+
+						trackNum := int(getFloat64(trackData, "trackNumber"))
+						itemTrackNum := idx + 1
+						if trackNum == itemTrackNum && dNum > 0 {
+						}
+					}
+				}
+			}
+		}
+	}
+
 	totalDiscs := 1
-	if discInfo["totalDiscs"] != nil {
+	if totalDiscsFromAlbum > 0 {
+		totalDiscs = totalDiscsFromAlbum
+	} else if maxDiscFromAlbum > 0 {
+		totalDiscs = maxDiscFromAlbum
+	} else if discInfo["totalDiscs"] != nil {
 		totalDiscs = discInfo["totalDiscs"].(int)
 	}
 
@@ -878,6 +887,11 @@ func FilterAlbum(data map[string]interface{}) map[string]interface{} {
 			contentRating := getMap(track, "contentRating")
 			isExplicit := getString(contentRating, "label") == "EXPLICIT"
 
+			discNumber := int(getFloat64(track, "discNumber"))
+			if discNumber == 0 {
+				discNumber = 1
+			}
+
 			trackInfo := map[string]interface{}{
 				"id":          trackID,
 				"name":        getString(track, "name"),
@@ -886,6 +900,7 @@ func FilterAlbum(data map[string]interface{}) map[string]interface{} {
 				"duration":    durationString,
 				"plays":       getString(track, "playcount"),
 				"is_explicit": isExplicit,
+				"disc_number": discNumber,
 			}
 			tracks = append(tracks, trackInfo)
 		}
@@ -905,6 +920,12 @@ func FilterAlbum(data map[string]interface{}) map[string]interface{} {
 		albumID = parts[len(parts)-1]
 	}
 
+	totalDiscs := 1
+	discsData := getMap(albumData, "discs")
+	if len(discsData) > 0 {
+		totalDiscs = int(getFloat64(discsData, "totalCount"))
+	}
+
 	filtered := map[string]interface{}{
 		"id":          albumID,
 		"name":        getString(albumData, "name"),
@@ -913,6 +934,10 @@ func FilterAlbum(data map[string]interface{}) map[string]interface{} {
 		"releaseDate": releaseDate,
 		"count":       len(tracks),
 		"tracks":      tracks,
+		"discs": map[string]interface{}{
+			"totalCount": totalDiscs,
+		},
+		"label": getString(albumData, "label"),
 	}
 
 	return filtered
@@ -1103,10 +1128,15 @@ func FilterPlaylist(data map[string]interface{}) map[string]interface{} {
 			contentRating := getMap(trackData, "contentRating")
 			isExplicit := getString(contentRating, "label") == "EXPLICIT"
 
+			trackName := getString(trackData, "name")
+			if trackName == "" {
+				continue
+			}
+
 			trackInfo := map[string]interface{}{
 				"id":          trackID,
 				"cover":       trackCover,
-				"title":       getString(trackData, "name"),
+				"title":       trackName,
 				"artist":      artistsString,
 				"artistIds":   artistIDs,
 				"plays":       rank,
@@ -1116,6 +1146,7 @@ func FilterPlaylist(data map[string]interface{}) map[string]interface{} {
 				"albumId":     albumID,
 				"duration":    durationString,
 				"is_explicit": isExplicit,
+				"disc_number": int(getFloat64(trackData, "discNumber")),
 			}
 			tracks = append(tracks, trackInfo)
 		}

backend/spotfetch_api.go

@@ -0,0 +1,101 @@
+package backend
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+	"time"
+)
+
+func GetSpotifyDataWithAPI(ctx context.Context, spotifyURL string, useAPI bool, apiBaseURL string, batch bool, delay time.Duration) (interface{}, error) {
+	if !useAPI || apiBaseURL == "" {
+
+		return GetFilteredSpotifyData(ctx, spotifyURL, batch, delay)
+	}
+
+	spotifyType, id := parseSpotifyURLToTypeAndID(spotifyURL)
+	if spotifyType == "" || id == "" {
+		return nil, fmt.Errorf("invalid Spotify URL: %s", spotifyURL)
+	}
+
+	apiURL := fmt.Sprintf("%s/%s/%s", strings.TrimSuffix(apiBaseURL, "/"), spotifyType, id)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create API request: %w", err)
+	}
+
+	client := &http.Client{
+		Timeout: 30 * time.Second,
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("SpotFetch API request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("SpotFetch API error: HTTP %d", resp.StatusCode)
+	}
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read API response: %w", err)
+	}
+
+	var data interface{}
+
+	switch spotifyType {
+	case "track":
+		var trackResp TrackResponse
+		if err := json.Unmarshal(bodyBytes, &trackResp); err != nil {
+			return nil, fmt.Errorf("failed to decode track response: %w", err)
+		}
+		data = trackResp
+	case "album":
+		var albumResp AlbumResponsePayload
+		if err := json.Unmarshal(bodyBytes, &albumResp); err != nil {
+			return nil, fmt.Errorf("failed to decode album response: %w", err)
+		}
+		data = &albumResp
+	case "playlist":
+		var playlistResp PlaylistResponsePayload
+		if err := json.Unmarshal(bodyBytes, &playlistResp); err != nil {
+			return nil, fmt.Errorf("failed to decode playlist response: %w", err)
+		}
+		data = playlistResp
+	case "artist":
+		var artistResp ArtistDiscographyPayload
+		if err := json.Unmarshal(bodyBytes, &artistResp); err != nil {
+			return nil, fmt.Errorf("failed to decode artist response: %w", err)
+		}
+		data = &artistResp
+	default:
+		return nil, fmt.Errorf("unsupported Spotify type: %s", spotifyType)
+	}
+
+	return data, nil
+}
+
+func parseSpotifyURLToTypeAndID(url string) (string, string) {
+
+	if strings.HasPrefix(url, "spotify:") {
+		parts := strings.Split(url, ":")
+		if len(parts) >= 3 {
+			return parts[1], parts[2]
+		}
+	}
+
+	re := regexp.MustCompile(`spotify\.com/(track|album|playlist|artist)/([a-zA-Z0-9]+)`)
+	matches := re.FindStringSubmatch(url)
+	if len(matches) == 3 {
+		return matches[1], matches[2]
+	}
+
+	return "", ""
+}

backend/spotify_metadata.go

@@ -42,7 +42,6 @@ type TrackMetadata struct {
 	DiscNumber  int    `json:"disc_number,omitempty"`
 	TotalDiscs  int    `json:"total_discs,omitempty"`
 	ExternalURL string `json:"external_urls"`
-	ISRC        string `json:"isrc"`
 	Copyright   string `json:"copyright,omitempty"`
 	Publisher   string `json:"publisher,omitempty"`
 	Plays       string `json:"plays,omitempty"`
@@ -70,7 +69,6 @@ type AlbumTrackMetadata struct {
 	DiscNumber  int            `json:"disc_number,omitempty"`
 	TotalDiscs  int            `json:"total_discs,omitempty"`
 	ExternalURL string         `json:"external_urls"`
-	ISRC        string         `json:"isrc"`
 	AlbumType   string         `json:"album_type,omitempty"`
 	AlbumID     string         `json:"album_id,omitempty"`
 	AlbumURL    string         `json:"album_url,omitempty"`
@@ -210,7 +208,11 @@ type apiAlbumResponse struct {
 	Cover       string `json:"cover"`
 	ReleaseDate string `json:"releaseDate"`
 	Count       int    `json:"count"`
-	Tracks      []struct {
+	Label       string `json:"label"`
+	Discs       struct {
+		TotalCount int `json:"totalCount"`
+	} `json:"discs"`
+	Tracks []struct {
 		ID         string   `json:"id"`
 		Name       string   `json:"name"`
 		Artists    string   `json:"artists"`
@@ -218,6 +220,7 @@ type apiAlbumResponse struct {
 		Duration   string   `json:"duration"`
 		Plays      string   `json:"plays"`
 		IsExplicit bool     `json:"is_explicit"`
+		DiscNumber int      `json:"disc_number"`
 	} `json:"tracks"`
 }
 
@@ -245,6 +248,7 @@ type apiPlaylistResponse struct {
 		AlbumID     string   `json:"albumId"`
 		Duration    string   `json:"duration"`
 		IsExplicit  bool     `json:"is_explicit"`
+		DiscNumber  int      `json:"disc_number"`
 	} `json:"tracks"`
 }
 
@@ -432,22 +436,47 @@ func (c *SpotifyMetadataClient) fetchTrack(ctx context.Context, trackID string)
 				}
 
 				if albumID != "" {
-					albumPayload := map[string]interface{}{
-						"variables": map[string]interface{}{
-							"uri":    fmt.Sprintf("spotify:album:%s", albumID),
-							"locale": "",
-							"offset": 0,
-							"limit":  1,
-						},
-						"operationName": "getAlbum",
-						"extensions": map[string]interface{}{
-							"persistedQuery": map[string]interface{}{
-								"version":    1,
-								"sha256Hash": "b9bfabef66ed756e5e13f68a942deb60bd4125ec1f1be8cc42769dc0259b4b10",
+
+					albumResponse, err := c.fetchAlbumWithClient(ctx, client, albumID)
+					if err == nil && albumResponse != nil {
+
+						albumJSON, _ := json.Marshal(albumResponse)
+						var albumMap map[string]interface{}
+						json.Unmarshal(albumJSON, &albumMap)
+
+						tracksItems := []interface{}{}
+						if albumMap["tracks"] != nil {
+							if trackList, ok := albumMap["tracks"].([]interface{}); ok {
+								for _, t := range trackList {
+									if trackMap, ok := t.(map[string]interface{}); ok {
+										tracksItems = append(tracksItems, map[string]interface{}{
+											"track": map[string]interface{}{
+												"discNumber": trackMap["disc_number"],
+												"id":         trackMap["id"],
+												"uri":        fmt.Sprintf("spotify:track:%s", trackMap["id"]),
+											},
+										})
+									}
+								}
+							}
+						}
+
+						albumFetchData = map[string]interface{}{
+							"data": map[string]interface{}{
+								"albumUnion": map[string]interface{}{
+									"discs": map[string]interface{}{
+										"totalCount": albumResponse.Discs.TotalCount,
+									},
+									"tracks": map[string]interface{}{
+										"items":      tracksItems,
+										"totalCount": albumResponse.Count,
+									},
+									"artists": albumResponse.Artists,
+									"label":   albumResponse.Label,
+								},
 							},
-						},
+						}
 					}
-					albumFetchData, _ = client.Query(albumPayload)
 				}
 			}
 		}
@@ -858,7 +887,6 @@ func (c *SpotifyMetadataClient) formatTrackData(raw *apiTrackResponse) TrackResp
 		DiscNumber:  raw.Disc,
 		TotalDiscs:  raw.Discs,
 		ExternalURL: externalURL,
-		ISRC:        raw.ID,
 		Copyright:   raw.Copyright,
 		Publisher:   raw.Album.Label,
 		Plays:       raw.Plays,
@@ -914,10 +942,9 @@ func (c *SpotifyMetadataClient) formatAlbumData(raw *apiAlbumResponse) (*AlbumRe
 			ReleaseDate: raw.ReleaseDate,
 			TrackNumber: trackNumber,
 			TotalTracks: raw.Count,
-			DiscNumber:  1,
-			TotalDiscs:  0,
+			DiscNumber:  item.DiscNumber,
+			TotalDiscs:  raw.Discs.TotalCount,
 			ExternalURL: fmt.Sprintf("https://open.spotify.com/track/%s", item.ID),
-			ISRC:        item.ID,
 			AlbumID:     raw.ID,
 			AlbumURL:    fmt.Sprintf("https://open.spotify.com/album/%s", raw.ID),
 			ArtistID:    artistID,
@@ -974,10 +1001,9 @@ func (c *SpotifyMetadataClient) formatPlaylistData(raw *apiPlaylistResponse) Pla
 			ReleaseDate: "",
 			TrackNumber: 0,
 			TotalTracks: 0,
-			DiscNumber:  1,
+			DiscNumber:  item.DiscNumber,
 			TotalDiscs:  0,
 			ExternalURL: fmt.Sprintf("https://open.spotify.com/track/%s", item.ID),
-			ISRC:        item.ID,
 			AlbumID:     item.AlbumID,
 			AlbumURL:    fmt.Sprintf("https://open.spotify.com/album/%s", item.AlbumID),
 			ArtistID:    artistID,
@@ -1094,9 +1120,8 @@ func (c *SpotifyMetadataClient) formatArtistDiscographyData(ctx context.Context,
 					ReleaseDate: albumData.ReleaseDate,
 					TrackNumber: trackNumber,
 					TotalTracks: albumData.Count,
-					DiscNumber:  1,
+					DiscNumber:  tr.DiscNumber,
 					ExternalURL: fmt.Sprintf("https://open.spotify.com/track/%s", tr.ID),
-					ISRC:        tr.ID,
 					AlbumID:     albumID,
 					AlbumURL:    fmt.Sprintf("https://open.spotify.com/album/%s", albumID),
 					ArtistID:    artistID,

backend/tidal.go

@@ -82,8 +82,6 @@ func (t *TidalDownloader) GetAvailableAPIs() ([]string, error) {
 		"https://triton.squid.wtf",
 		"https://hifi-one.spotisaver.net",
 		"https://hifi-two.spotisaver.net",
-		"https://tidal.kinoplus.online",
-		"https://tidal-api.binimum.org",
 	}
 	return apis, nil
 }
@@ -101,6 +99,8 @@ func (t *TidalDownloader) GetTidalURLFromSpotify(spotifyTrackID string) (string,
 		return "", fmt.Errorf("failed to create request: %w", err)
 	}
 
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
+
 	fmt.Println("Getting Tidal URL...")
 
 	resp, err := t.client.Do(req)
@@ -157,7 +157,15 @@ func (t *TidalDownloader) GetDownloadURL(trackID int64, quality string) (string,
 	url := fmt.Sprintf("%s/track/?id=%d&quality=%s", t.apiURL, trackID, quality)
 	fmt.Printf("Tidal API URL: %s\n", url)
 
-	resp, err := t.client.Get(url)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		fmt.Printf("✗ failed to create request: %v\n", err)
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
+
+	resp, err := t.client.Do(req)
 	if err != nil {
 		fmt.Printf("✗ Tidal API request failed: %v\n", err)
 		return "", fmt.Errorf("failed to get download URL: %w", err)
@@ -214,7 +222,14 @@ func (t *TidalDownloader) DownloadFile(url, filepath string) error {
 		return t.DownloadFromManifest(strings.TrimPrefix(url, "MANIFEST:"), filepath)
 	}
 
-	resp, err := t.client.Get(url)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
+
+	resp, err := t.client.Do(req)
 
 	if err != nil {
 		return fmt.Errorf("failed to download file: %w", err)
@@ -244,7 +259,7 @@ func (t *TidalDownloader) DownloadFile(url, filepath string) error {
 }
 
 func (t *TidalDownloader) DownloadFromManifest(manifestB64, outputPath string) error {
-	directURL, initURL, mediaURLs, err := parseManifest(manifestB64)
+	directURL, initURL, mediaURLs, mimeType, err := parseManifest(manifestB64)
 	if err != nil {
 		return fmt.Errorf("failed to parse manifest: %w", err)
 	}
@@ -253,10 +268,19 @@ func (t *TidalDownloader) DownloadFromManifest(manifestB64, outputPath string) e
 		Timeout: 120 * time.Second,
 	}
 
-	if directURL != "" {
+	doRequest := func(url string) (*http.Response, error) {
+		req, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			return nil, err
+		}
+		req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
+		return client.Do(req)
+	}
+
+	if directURL != "" && (strings.Contains(strings.ToLower(mimeType), "flac") || mimeType == "") {
 		fmt.Println("Downloading file...")
 
-		resp, err := client.Get(directURL)
+		resp, err := doRequest(directURL)
 		if err != nil {
 			return fmt.Errorf("failed to download file: %w", err)
 		}
@@ -283,83 +307,116 @@ func (t *TidalDownloader) DownloadFromManifest(manifestB64, outputPath string) e
 		return nil
 	}
 
-	fmt.Printf("Downloading %d segments...\n", len(mediaURLs)+1)
-
 	tempPath := outputPath + ".m4a.tmp"
-	out, err := os.Create(tempPath)
-	if err != nil {
-		return fmt.Errorf("failed to create temp file: %w", err)
-	}
 
-	fmt.Print("Downloading init segment... ")
-	resp, err := client.Get(initURL)
-	if err != nil {
-		out.Close()
-		os.Remove(tempPath)
-		return fmt.Errorf("failed to download init segment: %w", err)
-	}
-	if resp.StatusCode != 200 {
-		resp.Body.Close()
-		out.Close()
-		os.Remove(tempPath)
-		return fmt.Errorf("init segment download failed with status %d", resp.StatusCode)
-	}
-	_, err = io.Copy(out, resp.Body)
-	resp.Body.Close()
-	if err != nil {
-		out.Close()
-		os.Remove(tempPath)
-		return fmt.Errorf("failed to write init segment: %w", err)
-	}
-	fmt.Println("OK")
+	if directURL != "" {
+		fmt.Printf("Downloading non-FLAC file (%s)...\n", mimeType)
 
-	totalSegments := len(mediaURLs)
-	var totalBytes int64
-	lastTime := time.Now()
-	var lastBytes int64
-	for i, mediaURL := range mediaURLs {
-		resp, err := client.Get(mediaURL)
+		resp, err := doRequest(directURL)
+		if err != nil {
+			return fmt.Errorf("failed to download file: %w", err)
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != 200 {
+			return fmt.Errorf("download failed with status %d", resp.StatusCode)
+		}
+
+		out, err := os.Create(tempPath)
+		if err != nil {
+			return fmt.Errorf("failed to create temp file: %w", err)
+		}
+
+		pw := NewProgressWriter(out)
+		_, err = io.Copy(pw, resp.Body)
+		out.Close()
+
+		if err != nil {
+			os.Remove(tempPath)
+			return fmt.Errorf("failed to write temp file: %w", err)
+		}
+
+		fmt.Printf("\rDownloaded: %.2f MB (Complete)\n", float64(pw.GetTotal())/(1024*1024))
+
+	} else {
+
+		fmt.Printf("Downloading %d segments...\n", len(mediaURLs)+1)
+
+		out, err := os.Create(tempPath)
+		if err != nil {
+			return fmt.Errorf("failed to create temp file: %w", err)
+		}
+
+		fmt.Print("Downloading init segment... ")
+		resp, err := doRequest(initURL)
 		if err != nil {
 			out.Close()
 			os.Remove(tempPath)
-			return fmt.Errorf("failed to download segment %d: %w", i+1, err)
+			return fmt.Errorf("failed to download init segment: %w", err)
 		}
 		if resp.StatusCode != 200 {
 			resp.Body.Close()
 			out.Close()
 			os.Remove(tempPath)
-			return fmt.Errorf("segment %d download failed with status %d", i+1, resp.StatusCode)
+			return fmt.Errorf("init segment download failed with status %d", resp.StatusCode)
 		}
-		n, err := io.Copy(out, resp.Body)
-		totalBytes += n
+		_, err = io.Copy(out, resp.Body)
 		resp.Body.Close()
 		if err != nil {
 			out.Close()
 			os.Remove(tempPath)
-			return fmt.Errorf("failed to write segment %d: %w", i+1, err)
+			return fmt.Errorf("failed to write init segment: %w", err)
+		}
+		fmt.Println("OK")
+
+		totalSegments := len(mediaURLs)
+		var totalBytes int64
+		lastTime := time.Now()
+		var lastBytes int64
+		for i, mediaURL := range mediaURLs {
+			resp, err := doRequest(mediaURL)
+			if err != nil {
+				out.Close()
+				os.Remove(tempPath)
+				return fmt.Errorf("failed to download segment %d: %w", i+1, err)
+			}
+			if resp.StatusCode != 200 {
+				resp.Body.Close()
+				out.Close()
+				os.Remove(tempPath)
+				return fmt.Errorf("segment %d download failed with status %d", i+1, resp.StatusCode)
+			}
+			n, err := io.Copy(out, resp.Body)
+			totalBytes += n
+			resp.Body.Close()
+			if err != nil {
+				out.Close()
+				os.Remove(tempPath)
+				return fmt.Errorf("failed to write segment %d: %w", i+1, err)
+			}
+
+			mbDownloaded := float64(totalBytes) / (1024 * 1024)
+			now := time.Now()
+			timeDiff := now.Sub(lastTime).Seconds()
+			var speedMBps float64
+			if timeDiff > 0.1 {
+				bytesDiff := float64(totalBytes - lastBytes)
+				speedMBps = (bytesDiff / (1024 * 1024)) / timeDiff
+				SetDownloadSpeed(speedMBps)
+				lastTime = now
+				lastBytes = totalBytes
+			}
+			SetDownloadProgress(mbDownloaded)
+
+			fmt.Printf("\rDownloading: %.2f MB (%d/%d segments)", mbDownloaded, i+1, totalSegments)
 		}
 
-		mbDownloaded := float64(totalBytes) / (1024 * 1024)
-		now := time.Now()
-		timeDiff := now.Sub(lastTime).Seconds()
-		var speedMBps float64
-		if timeDiff > 0.1 {
-			bytesDiff := float64(totalBytes - lastBytes)
-			speedMBps = (bytesDiff / (1024 * 1024)) / timeDiff
-			SetDownloadSpeed(speedMBps)
-			lastTime = now
-			lastBytes = totalBytes
-		}
-		SetDownloadProgress(mbDownloaded)
+		out.Close()
 
-		fmt.Printf("\rDownloading: %.2f MB (%d/%d segments)", mbDownloaded, i+1, totalSegments)
+		tempInfo, _ := os.Stat(tempPath)
+		fmt.Printf("\rDownloaded: %.2f MB (Complete)          \n", float64(tempInfo.Size())/(1024*1024))
 	}
 
-	out.Close()
-
-	tempInfo, _ := os.Stat(tempPath)
-	fmt.Printf("\rDownloaded: %.2f MB (Complete)          \n", float64(tempInfo.Size())/(1024*1024))
-
 	fmt.Println("Converting to FLAC...")
 	ffmpegPath, err := GetFFmpegPath()
 	if err != nil {
@@ -387,7 +444,7 @@ func (t *TidalDownloader) DownloadFromManifest(manifestB64, outputPath string) e
 	return nil
 }
 
-func (t *TidalDownloader) DownloadByURL(tidalURL, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool) (string, error) {
+func (t *TidalDownloader) DownloadByURL(tidalURL, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
 	if outputDir != "." {
 		if err := os.MkdirAll(outputDir, 0755); err != nil {
 			return "", fmt.Errorf("directory error: %w", err)
@@ -410,9 +467,15 @@ func (t *TidalDownloader) DownloadByURL(tidalURL, outputDir, quality, filenameFo
 	albumTitle := spotifyAlbumName
 
 	artistNameForFile := sanitizeFilename(artistName)
+	albumArtistForFile := sanitizeFilename(spotifyAlbumArtist)
+
+	if useFirstArtistOnly {
+		artistNameForFile = sanitizeFilename(GetFirstArtist(artistName))
+		albumArtistForFile = sanitizeFilename(GetFirstArtist(spotifyAlbumArtist))
+	}
+
 	trackTitleForFile := sanitizeFilename(trackTitle)
 	albumTitleForFile := sanitizeFilename(albumTitle)
-	albumArtistForFile := sanitizeFilename(spotifyAlbumArtist)
 
 	filename := buildTidalFilename(trackTitleForFile, artistNameForFile, albumTitleForFile, albumArtistForFile, spotifyReleaseDate, spotifyTrackNumber, spotifyDiscNumber, filenameFormat, includeTrackNumber, position, useAlbumTrackNumber)
 	outputFilename := filepath.Join(outputDir, filename)
@@ -435,11 +498,55 @@ func (t *TidalDownloader) DownloadByURL(tidalURL, outputDir, quality, filenameFo
 		}
 	}
 
+	type mbResult struct {
+		ISRC     string
+		Metadata Metadata
+	}
+
+	metaChan := make(chan mbResult, 1)
+	if embedGenre && spotifyURL != "" {
+		go func() {
+			res := mbResult{}
+			var isrc string
+			parts := strings.Split(spotifyURL, "/")
+			if len(parts) > 0 {
+				sID := strings.Split(parts[len(parts)-1], "?")[0]
+				if sID != "" {
+					client := NewSongLinkClient()
+					if val, err := client.GetISRC(sID); err == nil {
+						isrc = val
+					}
+				}
+			}
+			res.ISRC = isrc
+			if isrc != "" {
+				fmt.Println("Fetching MusicBrainz metadata...")
+				if fetchedMeta, err := FetchMusicBrainzMetadata(isrc, trackTitle, artistName, albumTitle, useSingleGenre, embedGenre); err == nil {
+					res.Metadata = fetchedMeta
+					fmt.Println("✓ MusicBrainz metadata fetched")
+				} else {
+					fmt.Printf("Warning: Failed to fetch MusicBrainz metadata: %v\n", err)
+				}
+			}
+			metaChan <- res
+		}()
+	} else {
+		close(metaChan)
+	}
+
 	fmt.Printf("Downloading to: %s\n", outputFilename)
 	if err := t.DownloadFile(downloadURL, outputFilename); err != nil {
 		return "", err
 	}
 
+	var isrc string
+	var mbMeta Metadata
+	if spotifyURL != "" {
+		result := <-metaChan
+		isrc = result.ISRC
+		mbMeta = result.Metadata
+	}
+
 	fmt.Println("Adding metadata...")
 
 	coverPath := ""
@@ -475,6 +582,8 @@ func (t *TidalDownloader) DownloadByURL(tidalURL, outputDir, quality, filenameFo
 		Copyright:   spotifyCopyright,
 		Publisher:   spotifyPublisher,
 		Description: "https://github.com/afkarxyz/SpotiFLAC",
+		ISRC:        isrc,
+		Genre:       mbMeta.Genre,
 	}
 
 	if err := EmbedMetadata(outputFilename, metadata, coverPath); err != nil {
@@ -488,7 +597,7 @@ func (t *TidalDownloader) DownloadByURL(tidalURL, outputDir, quality, filenameFo
 	return outputFilename, nil
 }
 
-func (t *TidalDownloader) DownloadByURLWithFallback(tidalURL, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool) (string, error) {
+func (t *TidalDownloader) DownloadByURLWithFallback(tidalURL, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
 	apis, err := t.GetAvailableAPIs()
 	if err != nil {
 		return "", fmt.Errorf("no APIs available for fallback: %w", err)
@@ -516,9 +625,15 @@ func (t *TidalDownloader) DownloadByURLWithFallback(tidalURL, outputDir, quality
 	albumTitle := spotifyAlbumName
 
 	artistNameForFile := sanitizeFilename(artistName)
+	albumArtistForFile := sanitizeFilename(spotifyAlbumArtist)
+
+	if useFirstArtistOnly {
+		artistNameForFile = sanitizeFilename(GetFirstArtist(artistName))
+		albumArtistForFile = sanitizeFilename(GetFirstArtist(spotifyAlbumArtist))
+	}
+
 	trackTitleForFile := sanitizeFilename(trackTitle)
 	albumTitleForFile := sanitizeFilename(albumTitle)
-	albumArtistForFile := sanitizeFilename(spotifyAlbumArtist)
 
 	filename := buildTidalFilename(trackTitleForFile, artistNameForFile, albumTitleForFile, albumArtistForFile, spotifyReleaseDate, spotifyTrackNumber, spotifyDiscNumber, filenameFormat, includeTrackNumber, position, useAlbumTrackNumber)
 	outputFilename := filepath.Join(outputDir, filename)
@@ -541,12 +656,56 @@ func (t *TidalDownloader) DownloadByURLWithFallback(tidalURL, outputDir, quality
 		}
 	}
 
+	type mbResultFallback struct {
+		ISRC     string
+		Metadata Metadata
+	}
+
+	metaChan := make(chan mbResultFallback, 1)
+	if embedGenre && spotifyURL != "" {
+		go func() {
+			res := mbResultFallback{}
+			var isrc string
+			parts := strings.Split(spotifyURL, "/")
+			if len(parts) > 0 {
+				sID := strings.Split(parts[len(parts)-1], "?")[0]
+				if sID != "" {
+					client := NewSongLinkClient()
+					if val, err := client.GetISRC(sID); err == nil {
+						isrc = val
+					}
+				}
+			}
+			res.ISRC = isrc
+			if isrc != "" {
+				fmt.Println("Fetching MusicBrainz metadata...")
+				if fetchedMeta, err := FetchMusicBrainzMetadata(isrc, trackTitle, artistName, albumTitle, useSingleGenre, embedGenre); err == nil {
+					res.Metadata = fetchedMeta
+					fmt.Println("✓ MusicBrainz metadata fetched")
+				} else {
+					fmt.Printf("Warning: Failed to fetch MusicBrainz metadata: %v\n", err)
+				}
+			}
+			metaChan <- res
+		}()
+	} else {
+		close(metaChan)
+	}
+
 	fmt.Printf("Downloading to: %s\n", outputFilename)
 	downloader := NewTidalDownloader(successAPI)
 	if err := downloader.DownloadFile(downloadURL, outputFilename); err != nil {
 		return "", err
 	}
 
+	var isrc string
+	var mbMeta Metadata
+	if spotifyURL != "" {
+		result := <-metaChan
+		isrc = result.ISRC
+		mbMeta = result.Metadata
+	}
+
 	fmt.Println("Adding metadata...")
 
 	coverPath := ""
@@ -582,6 +741,8 @@ func (t *TidalDownloader) DownloadByURLWithFallback(tidalURL, outputDir, quality
 		Copyright:   spotifyCopyright,
 		Publisher:   spotifyPublisher,
 		Description: "https://github.com/afkarxyz/SpotiFLAC",
+		ISRC:        isrc,
+		Genre:       mbMeta.Genre,
 	}
 
 	if err := EmbedMetadata(outputFilename, metadata, coverPath); err != nil {
@@ -595,14 +756,14 @@ func (t *TidalDownloader) DownloadByURLWithFallback(tidalURL, outputDir, quality
 	return outputFilename, nil
 }
 
-func (t *TidalDownloader) Download(spotifyTrackID, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool) (string, error) {
+func (t *TidalDownloader) Download(spotifyTrackID, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
 
 	tidalURL, err := t.GetTidalURLFromSpotify(spotifyTrackID)
 	if err != nil {
 		return "", fmt.Errorf("songlink couldn't find Tidal URL: %w", err)
 	}
 
-	return t.DownloadByURLWithFallback(tidalURL, outputDir, quality, filenameFormat, includeTrackNumber, position, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, useAlbumTrackNumber, spotifyCoverURL, embedMaxQualityCover, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, spotifyTotalDiscs, spotifyCopyright, spotifyPublisher, spotifyURL, allowFallback)
+	return t.DownloadByURLWithFallback(tidalURL, outputDir, quality, filenameFormat, includeTrackNumber, position, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, useAlbumTrackNumber, spotifyCoverURL, embedMaxQualityCover, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, spotifyTotalDiscs, spotifyCopyright, spotifyPublisher, spotifyURL, allowFallback, useFirstArtistOnly, useSingleGenre, embedGenre)
 }
 
 type SegmentTemplate struct {
@@ -633,10 +794,10 @@ type MPD struct {
 	} `xml:"Period"`
 }
 
-func parseManifest(manifestB64 string) (directURL string, initURL string, mediaURLs []string, err error) {
+func parseManifest(manifestB64 string) (directURL string, initURL string, mediaURLs []string, mimeType string, err error) {
 	manifestBytes, err := base64.StdEncoding.DecodeString(manifestB64)
 	if err != nil {
-		return "", "", nil, fmt.Errorf("failed to decode manifest: %w", err)
+		return "", "", nil, "", fmt.Errorf("failed to decode manifest: %w", err)
 	}
 
 	manifestStr := string(manifestBytes)
@@ -644,15 +805,15 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 	if strings.HasPrefix(strings.TrimSpace(manifestStr), "{") {
 		var btsManifest TidalBTSManifest
 		if err := json.Unmarshal(manifestBytes, &btsManifest); err != nil {
-			return "", "", nil, fmt.Errorf("failed to parse BTS manifest: %w", err)
+			return "", "", nil, "", fmt.Errorf("failed to parse BTS manifest: %w", err)
 		}
 
 		if len(btsManifest.URLs) == 0 {
-			return "", "", nil, fmt.Errorf("no URLs in BTS manifest")
+			return "", "", nil, "", fmt.Errorf("no URLs in BTS manifest")
 		}
 
 		fmt.Printf("Manifest: BTS format (%s, %s)\n", btsManifest.MimeType, btsManifest.Codecs)
-		return btsManifest.URLs[0], "", nil, nil
+		return btsManifest.URLs[0], "", nil, btsManifest.MimeType, nil
 	}
 
 	fmt.Println("Manifest: DASH format")
@@ -717,7 +878,7 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 			mediaURL := strings.ReplaceAll(mediaTemplate, "$Number$", fmt.Sprintf("%d", i))
 			mediaURLs = append(mediaURLs, mediaURL)
 		}
-		return "", initURL, mediaURLs, nil
+		return "", initURL, mediaURLs, "", nil
 	}
 
 	fmt.Println("Using regex fallback for DASH manifest...")
@@ -733,7 +894,7 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 	}
 
 	if initURL == "" {
-		return "", "", nil, fmt.Errorf("no initialization URL found in manifest")
+		return "", "", nil, "", fmt.Errorf("no initialization URL found in manifest")
 	}
 
 	initURL = strings.ReplaceAll(initURL, "&amp;", "&")
@@ -754,7 +915,7 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 	}
 
 	if segmentCount == 0 {
-		return "", "", nil, fmt.Errorf("no segments found in manifest (XML: %d, Regex: 0)", len(matches))
+		return "", "", nil, "", fmt.Errorf("no segments found in manifest (XML: %d, Regex: 0)", len(matches))
 	}
 
 	fmt.Printf("Parsed manifest via Regex: %d segments\n", segmentCount)
@@ -764,7 +925,7 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 		mediaURLs = append(mediaURLs, mediaURL)
 	}
 
-	return "", initURL, mediaURLs, nil
+	return "", initURL, mediaURLs, "", nil
 }
 
 func getDownloadURLRotated(apis []string, trackID int64, quality string) (string, string, error) {
@@ -858,6 +1019,7 @@ func buildTidalFilename(title, artist, album, albumArtist, releaseDate string, t
 		filename = strings.ReplaceAll(filename, "{album}", album)
 		filename = strings.ReplaceAll(filename, "{album_artist}", albumArtist)
 		filename = strings.ReplaceAll(filename, "{year}", year)
+		filename = strings.ReplaceAll(filename, "{date}", SanitizeFilename(releaseDate))
 
 		if discNumber > 0 {
 			filename = strings.ReplaceAll(filename, "{disc}", fmt.Sprintf("%d", discNumber))

backend/uploader.go

@@ -66,12 +66,17 @@ func uploadToService(filename string, fileReader io.Reader) (string, error) {
 
 	writer.Close()
 
-	req, err := http.NewRequest("POST", "https://u1112.send.now/cgi-bin/upload.cgi?upload_type=file&utype=anon", body)
+	uploadURL, err := getUploadURL()
+	if err != nil {
+		return "", fmt.Errorf("failed to get upload server: %v", err)
+	}
+
+	req, err := http.NewRequest("POST", uploadURL, body)
 	if err != nil {
 		return "", err
 	}
 
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 	req.Header.Set("Origin", "https://send.now")
 	req.Header.Set("Referer", "https://send.now/")
 	req.Header.Set("Content-Type", writer.FormDataContentType())
@@ -113,12 +118,51 @@ func uploadToService(filename string, fileReader io.Reader) (string, error) {
 	return fetchDirectImageLink(downloadLink)
 }
 
+func getUploadURL() (string, error) {
+	req, err := http.NewRequest("GET", "https://send.now/", nil)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
+
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("failed to fetch main page: status %d", resp.StatusCode)
+	}
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	body := string(bodyBytes)
+
+	re := regexp.MustCompile(`action=["'](https://[^"']+/cgi-bin/upload\.cgi\?upload_type=file[^"']*)["']`)
+	matches := re.FindStringSubmatch(body)
+	if len(matches) > 1 {
+		return matches[1], nil
+	}
+
+	reFallback := regexp.MustCompile(`action=["'](https://[^"']+/cgi-bin/upload\.cgi)`)
+	matchesFallback := reFallback.FindStringSubmatch(body)
+	if len(matchesFallback) > 1 {
+		return matchesFallback[1] + "?upload_type=file&utype=anon", nil
+	}
+
+	return "", fmt.Errorf("upload URL not found in main page")
+}
+
 func fetchDirectImageLink(url string) (string, error) {
 	req, err := http.NewRequest("GET", url, nil)
 	if err != nil {
 		return "", err
 	}
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 
 	client := &http.Client{Timeout: 30 * time.Second}
 	resp, err := client.Do(req)

frontend/package.json

@@ -16,6 +16,7 @@
     "@radix-ui/react-context-menu": "^2.2.16",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-label": "^2.1.8",
+    "@radix-ui/react-menubar": "^1.1.16",
     "@radix-ui/react-progress": "^1.1.8",
     "@radix-ui/react-scroll-area": "^1.2.10",
     "@radix-ui/react-select": "^2.2.6",
@@ -25,32 +26,32 @@
     "@radix-ui/react-toggle": "^1.1.10",
     "@radix-ui/react-toggle-group": "^1.1.11",
     "@radix-ui/react-tooltip": "^1.2.8",
-    "@tailwindcss/vite": "^4.1.18",
+    "@tailwindcss/vite": "^4.2.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "lucide-react": "^0.562.0",
-    "motion": "^12.26.2",
+    "lucide-react": "^0.575.0",
+    "motion": "^12.34.3",
     "next-themes": "^0.4.6",
-    "react": "^19.2.3",
-    "react-dom": "^19.2.3",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
     "sonner": "^2.0.7",
-    "tailwind-merge": "^3.4.0",
-    "tailwindcss": "^4.1.18"
+    "tailwind-merge": "^3.5.0",
+    "tailwindcss": "^4.2.1"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@types/node": "^25.0.8",
-    "@types/react": "^19.2.8",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.3.0",
+    "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^5.1.2",
-    "eslint": "^9.39.2",
+    "@vitejs/plugin-react": "^5.1.4",
+    "eslint": "^10.0.2",
     "eslint-plugin-react-hooks": "^7.0.1",
-    "eslint-plugin-react-refresh": "^0.4.26",
-    "globals": "^17.0.0",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.3.0",
     "sharp": "^0.34.5",
     "tw-animate-css": "^1.4.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.53.0",
+    "typescript-eslint": "^8.56.1",
     "vite": "^7.3.1"
   }
 }

frontend/package.json.md5

@@ -1 +1 @@
-629a5f17426ea4202a25837a341483dd
+3ca7ac3e41fb33a6fc3e30c16b39657b

frontend/src/App.tsx

@@ -3,7 +3,7 @@ import { Button } from "@/components/ui/button";
 import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@/components/ui/dialog";
 import { Search, X, ArrowUp } from "lucide-react";
 import { TooltipProvider } from "@/components/ui/tooltip";
-import { getSettings, getSettingsWithDefaults, loadSettings, saveSettings, applyThemeMode, applyFont } from "@/lib/settings";
+import { getSettings, getSettingsWithDefaults, loadSettings, saveSettings, applyThemeMode, applyFont, updateSettings } from "@/lib/settings";
 import { applyTheme } from "@/lib/themes";
 import { OpenFolder, CheckFFmpegInstalled, DownloadFFmpeg } from "../wailsjs/go/main/App";
 import { EventsOn, EventsOff, Quit } from "../wailsjs/runtime/runtime";
@@ -119,6 +119,17 @@ function App() {
             window.removeEventListener("scroll", handleScroll);
         };
     }, []);
+    const handleEnableSpotFetchApi = async () => {
+        try {
+            await updateSettings({ useSpotFetchAPI: true });
+            metadata.setShowApiModal(false);
+            toast.success("SpotFetch API enabled! You can now try fetching again.");
+        }
+        catch (err) {
+            console.error("Failed to enable SpotFetch API:", err);
+            toast.error("Failed to update settings");
+        }
+    };
     const scrollToTop = useCallback(() => {
         window.scrollTo({ top: 0, behavior: "smooth" });
     }, []);
@@ -290,19 +301,19 @@ function App() {
         setSearchQuery(value);
         setCurrentListPage(1);
     };
-    const toggleTrackSelection = (isrc: string) => {
-        setSelectedTracks((prev) => prev.includes(isrc) ? prev.filter((id) => id !== isrc) : [...prev, isrc]);
+    const toggleTrackSelection = (id: string) => {
+        setSelectedTracks((prev) => prev.includes(id) ? prev.filter((prevId) => prevId !== id) : [...prev, id]);
     };
     const toggleSelectAll = (tracks: any[]) => {
-        const tracksWithIsrc = tracks.filter((track) => track.isrc).map((track) => track.isrc);
-        if (tracksWithIsrc.length === 0)
+        const tracksWithId = tracks.filter((track) => track.spotify_id).map((track) => track.spotify_id || "");
+        if (tracksWithId.length === 0)
             return;
-        const allSelected = tracksWithIsrc.every(isrc => selectedTracks.includes(isrc));
+        const allSelected = tracksWithId.every(id => selectedTracks.includes(id));
         if (allSelected) {
-            setSelectedTracks(prev => prev.filter(isrc => !tracksWithIsrc.includes(isrc)));
+            setSelectedTracks(prev => prev.filter(id => !tracksWithId.includes(id)));
         }
         else {
-            setSelectedTracks(prev => Array.from(new Set([...prev, ...tracksWithIsrc])));
+            setSelectedTracks(prev => Array.from(new Set([...prev, ...tracksWithId])));
         }
     };
     const handleOpenFolder = async () => {
@@ -324,7 +335,8 @@ function App() {
             return null;
         if ("track" in metadata.metadata) {
             const { track } = metadata.metadata;
-            return (<TrackInfo track={track} isDownloading={download.isDownloading} downloadingTrack={download.downloadingTrack} isDownloaded={download.downloadedTracks.has(track.isrc)} isFailed={download.failedTracks.has(track.isrc)} isSkipped={download.skippedTracks.has(track.isrc)} downloadingLyricsTrack={lyrics.downloadingLyricsTrack} downloadedLyrics={lyrics.downloadedLyrics.has(track.spotify_id || "")} failedLyrics={lyrics.failedLyrics.has(track.spotify_id || "")} skippedLyrics={lyrics.skippedLyrics.has(track.spotify_id || "")} checkingAvailability={availability.checkingTrackId === track.spotify_id} availability={availability.availabilityMap.get(track.spotify_id || "")} downloadingCover={cover.downloadingCoverTrack === (track.spotify_id || `${track.name}-${track.artists}`)} downloadedCover={cover.downloadedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} failedCover={cover.failedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} skippedCover={cover.skippedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} onDownload={download.handleDownloadTrack} onDownloadLyrics={(spotifyId, name, artists, albumName, albumArtist, releaseDate, discNumber) => lyrics.handleDownloadLyrics(spotifyId, name, artists, albumName, track.album_name, undefined, albumArtist, releaseDate, discNumber)} onDownloadCover={(coverUrl, trackName, artistName, albumName, _playlistName, _position, trackId, albumArtist, releaseDate, discNumber) => cover.handleDownloadCover(coverUrl, trackName, artistName, albumName, track.album_name, undefined, trackId, albumArtist, releaseDate, discNumber)} onCheckAvailability={availability.checkAvailability} onOpenFolder={handleOpenFolder} onBack={metadata.resetMetadata}/>);
+            const trackId = track.spotify_id || "";
+            return (<TrackInfo track={track} isDownloading={download.isDownloading} downloadingTrack={download.downloadingTrack} isDownloaded={download.downloadedTracks.has(trackId)} isFailed={download.failedTracks.has(trackId)} isSkipped={download.skippedTracks.has(trackId)} downloadingLyricsTrack={lyrics.downloadingLyricsTrack} downloadedLyrics={lyrics.downloadedLyrics.has(track.spotify_id || "")} failedLyrics={lyrics.failedLyrics.has(track.spotify_id || "")} skippedLyrics={lyrics.skippedLyrics.has(track.spotify_id || "")} checkingAvailability={availability.checkingTrackId === track.spotify_id} availability={availability.availabilityMap.get(track.spotify_id || "")} downloadingCover={cover.downloadingCoverTrack === (track.spotify_id || `${track.name}-${track.artists}`)} downloadedCover={cover.downloadedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} failedCover={cover.failedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} skippedCover={cover.skippedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} onDownload={download.handleDownloadTrack} onDownloadLyrics={(spotifyId, name, artists, albumName, albumArtist, releaseDate, discNumber) => lyrics.handleDownloadLyrics(spotifyId, name, artists, albumName, track.album_name, undefined, albumArtist, releaseDate, discNumber)} onDownloadCover={(coverUrl, trackName, artistName, albumName, _playlistName, _position, trackId, albumArtist, releaseDate, discNumber) => cover.handleDownloadCover(coverUrl, trackName, artistName, albumName, track.album_name, undefined, trackId, albumArtist, releaseDate, discNumber)} onCheckAvailability={availability.checkAvailability} onOpenFolder={handleOpenFolder} onBack={metadata.resetMetadata}/>);
         }
         if ("album_info" in metadata.metadata) {
             const { album_info, track_list } = metadata.metadata;
@@ -555,6 +567,25 @@ function App() {
                     </DialogFooter>
                 </DialogContent>
             </Dialog>
+
+            <Dialog open={metadata.showApiModal} onOpenChange={metadata.setShowApiModal}>
+                <DialogContent className="sm:max-w-[425px]">
+                    <DialogHeader>
+                        <DialogTitle>SpotFetch API Recommended</DialogTitle>
+                        <DialogDescription>
+                            Direct fetch failed. This usually happens when your <span className="text-foreground font-bold">country is blocked</span> by Spotify or your IP is restricted. Would you like to enable the <span className="text-foreground font-bold">SpotFetch API</span> to bypass this?
+                        </DialogDescription>
+                    </DialogHeader>
+                    <DialogFooter>
+                        <Button variant="outline" onClick={() => metadata.setShowApiModal(false)}>
+                            Cancel
+                        </Button>
+                        <Button onClick={handleEnableSpotFetchApi}>
+                            Enable SpotFetch API
+                        </Button>
+                    </DialogFooter>
+                </DialogContent>
+            </Dialog>
         </div>
     </TooltipProvider>);
 }

frontend/src/assets/kofi_symbol.svg

@@ -0,0 +1,13 @@
+<svg width="241" height="194" viewBox="0 0 241 194" fill="none" xmlns="http://www.w3.org/2000/svg">
+<mask id="mask0_1_219" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="-1" y="0" width="242" height="194">
+<path d="M240.469 0.958984H-0.00585938V193.918H240.469V0.958984Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_1_219)">
+<path d="M96.1344 193.911C61.1312 193.911 32.6597 178.256 15.9721 149.829C1.19788 124.912 -0.00585938 97.9229 -0.00585938 67.7662C-0.00585938 49.8876 5.37293 34.3215 15.5413 22.7466C24.8861 12.1157 38.1271 5.22907 52.8317 3.35378C70.2858 1.14271 91.9848 0.958984 114.545 0.958984C151.259 0.958984 161.63 1.4088 176.075 2.85328C195.29 4.76026 211.458 11.932 222.824 23.5955C234.368 35.4428 240.469 51.2624 240.469 69.3627V72.9994C240.469 103.885 219.821 129.733 191.046 136.759C188.898 141.827 186.237 146.871 183.089 151.837L183.006 151.964C172.869 167.632 149.042 193.918 103.401 193.918H96.1281L96.1344 193.911Z" fill="white"/>
+<path d="M174.568 17.9772C160.927 16.6151 151.38 16.1589 114.552 16.1589C90.908 16.1589 70.9008 16.387 54.7644 18.4334C33.3949 21.164 15.2058 37.5285 15.2058 67.7674C15.2058 98.0066 16.796 121.422 29.0741 142.107C42.9425 165.751 66.1302 178.707 96.1412 178.707H103.414C140.242 178.707 160.25 159.156 170.253 143.698C174.574 136.874 177.754 130.058 179.801 123.234C205.947 120.96 225.27 99.3624 225.27 72.9941V69.3577C225.27 40.9432 206.631 21.164 174.574 17.9772H174.568Z" fill="white"/>
+<path d="M15.1975 67.7674C15.1975 37.5285 33.3866 21.164 54.7559 18.4334C70.8987 16.387 90.906 16.1589 114.544 16.1589C151.372 16.1589 160.919 16.6151 174.559 17.9772C206.617 21.1576 225.255 40.937 225.255 69.3577V72.9941C225.255 99.3687 205.932 120.966 179.786 123.234C177.74 130.058 174.559 136.874 170.238 143.698C160.235 159.156 140.228 178.707 103.4 178.707H96.1264C66.1155 178.707 42.9277 165.751 29.0595 142.107C16.7814 121.422 15.1912 98.4563 15.1912 67.7674" fill="#202020"/>
+<path d="M32.2469 67.9899C32.2469 97.3168 34.0654 116.184 43.6127 133.689C54.5225 153.924 74.3018 161.653 96.8117 161.653H103.857C133.411 161.653 147.736 147.329 155.693 134.829C159.558 128.462 162.966 121.417 164.784 112.547L166.147 106.864H174.332C192.521 106.864 208.208 92.09 208.208 73.2166V69.8082C208.208 48.6669 195.024 37.5228 172.058 34.7987C159.102 33.6646 151.372 33.2084 114.538 33.2084C89.7602 33.2084 72.0272 33.4364 58.6152 35.4828C39.7483 38.2134 32.2407 48.8951 32.2407 67.9899" fill="white"/>
+<path d="M166.158 83.6801C166.158 86.4107 168.204 88.4572 171.841 88.4572C183.435 88.4572 189.802 81.8619 189.802 70.9523C189.802 60.0427 183.435 53.2195 171.841 53.2195C168.204 53.2195 166.158 55.2657 166.158 57.9963V83.6866V83.6801Z" fill="#202020"/>
+<path d="M54.5321 82.3198C54.5321 95.732 62.0332 107.326 71.5807 116.424C77.9478 122.562 87.9515 128.93 94.7685 133.022C96.8147 134.157 98.8611 134.841 101.136 134.841C103.866 134.841 106.134 134.157 107.959 133.022C114.782 128.93 124.779 122.562 130.919 116.424C140.694 107.332 148.195 95.7383 148.195 82.3198C148.195 67.7673 137.286 54.8115 121.599 54.8115C112.28 54.8115 105.912 59.5882 101.136 66.1772C96.8147 59.582 90.2259 54.8115 80.9001 54.8115C64.9855 54.8115 54.5256 67.7673 54.5256 82.3198" fill="#FF5A16"/>
+</g>
+</svg>

frontend/src/components/AboutPage.tsx

@@ -2,12 +2,12 @@ import { useState, useEffect } from "react";
 import { Button } from "@/components/ui/button";
 import { openExternal } from "@/lib/utils";
 import { GetOSInfo } from "../../wailsjs/go/main/App";
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle, } from "@/components/ui/card";
 import { Label } from "@/components/ui/label";
 import { Input } from "@/components/ui/input";
 import { Textarea } from "@/components/ui/textarea";
 import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle-group";
-import { Bug, Lightbulb, ExternalLink, Star, GitFork, Clock, Download, CircleHelp, Blocks } from "lucide-react";
+import { Bug, Lightbulb, ExternalLink, Star, GitFork, Clock, Download, CircleHelp, Blocks, Heart, } from "lucide-react";
 import AudioTTSProIcon from "@/assets/audiotts-pro.webp";
 import ChatGPTTTSIcon from "@/assets/chatgpt-tts.webp";
 import XProIcon from "@/assets/x-pro.webp";
@@ -15,6 +15,7 @@ import SpotubeDLIcon from "@/assets/icons/spotubedl.svg";
 import SpotiDownloaderIcon from "@/assets/icons/spotidownloader.svg";
 import XBatchDLIcon from "@/assets/icons/xbatchdl.svg";
 import SpotiFLACNextIcon from "@/assets/icons/next.svg";
+import KofiLogo from "@/assets/kofi_symbol.svg";
 import { langColors } from "@/assets/github-lang-colors";
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { DragDropMedia } from "./DragDropTextarea";
@@ -24,7 +25,7 @@ interface AboutPageProps {
 export function AboutPage({ version }: AboutPageProps) {
     const [os, setOs] = useState("Unknown");
     const [location, setLocation] = useState("Unknown");
-    const [activeTab, setActiveTab] = useState<"bug_report" | "feature_request" | "faq" | "projects">("bug_report");
+    const [activeTab, setActiveTab] = useState<"bug_report" | "feature_request" | "faq" | "projects" | "support">("bug_report");
     const [bugType, setBugType] = useState("Track");
     const [problem, setProblem] = useState("");
     const [spotifyUrl, setSpotifyUrl] = useState("");
@@ -52,14 +53,14 @@ export function AboutPage({ version }: AboutPageProps) {
         fetchOS();
         const fetchLocation = async () => {
             try {
-                const response = await fetch('https://ipapi.co/json/');
+                const response = await fetch("https://ipapi.co/json/");
                 if (response.ok) {
                     const data = await response.json();
-                    const city = data.city || '';
-                    const region = data.region || '';
-                    const country = data.country_name || '';
+                    const city = data.city || "";
+                    const region = data.region || "";
+                    const country = data.country_name || "";
                     const parts = [city, region, country].filter(Boolean);
-                    setLocation(parts.join(', ') || 'Unknown');
+                    setLocation(parts.join(", ") || "Unknown");
                 }
                 else {
                     const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -73,7 +74,7 @@ export function AboutPage({ version }: AboutPageProps) {
         };
         fetchLocation();
         const fetchRepoStats = async () => {
-            const CACHE_KEY = 'github_repo_stats';
+            const CACHE_KEY = "github_repo_stats";
             const CACHE_DURATION = 1000 * 60 * 60;
             const cached = localStorage.getItem(CACHE_KEY);
             if (cached) {
@@ -85,13 +86,13 @@ export function AboutPage({ version }: AboutPageProps) {
                     }
                 }
                 catch (err) {
-                    console.error('Failed to parse cache:', err);
+                    console.error("Failed to parse cache:", err);
                 }
             }
             const repos = [
-                { name: 'SpotiDownloader', owner: 'afkarxyz' },
-                { name: 'SpotiFLAC-Next', owner: 'spotiverse' },
-                { name: 'Twitter-X-Media-Batch-Downloader', owner: 'afkarxyz' }
+                { name: "SpotiDownloader", owner: "afkarxyz" },
+                { name: "SpotiFLAC-Next", owner: "spotiverse" },
+                { name: "Twitter-X-Media-Batch-Downloader", owner: "afkarxyz" },
             ];
             const stats: Record<string, any> = {};
             for (const repo of repos) {
@@ -99,7 +100,7 @@ export function AboutPage({ version }: AboutPageProps) {
                     const [repoRes, releasesRes, langsRes] = await Promise.all([
                         fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}`),
                         fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}/releases`),
-                        fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}/languages`)
+                        fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}/languages`),
                     ]);
                     if (repoRes.status === 403) {
                         if (cached) {
@@ -115,9 +116,11 @@ export function AboutPage({ version }: AboutPageProps) {
                         let totalDownloads = 0;
                         let latestDownloads = 0;
                         if (releases.length > 0) {
-                            latestDownloads = releases[0].assets?.reduce((sum: number, asset: any) => sum + (asset.download_count || 0), 0) || 0;
+                            latestDownloads =
+                                releases[0].assets?.reduce((sum: number, asset: any) => sum + (asset.download_count || 0), 0) || 0;
                             totalDownloads = releases.reduce((sum: number, release: any) => {
-                                return sum + (release.assets?.reduce((s: number, a: any) => s + (a.download_count || 0), 0) || 0);
+                                return (sum +
+                                    (release.assets?.reduce((s: number, a: any) => s + (a.download_count || 0), 0) || 0));
                             }, 0);
                         }
                         const topLangs = Object.entries(languages)
@@ -130,7 +133,7 @@ export function AboutPage({ version }: AboutPageProps) {
                             createdAt: repoData.created_at,
                             totalDownloads,
                             latestDownloads,
-                            languages: topLangs
+                            languages: topLangs,
                         };
                     }
                 }
@@ -151,24 +154,24 @@ export function AboutPage({ version }: AboutPageProps) {
     const faqs = [
         {
             q: "Is this software free?",
-            a: "Yes. This software is completely free. You do not need an account, login, or subscription. All you need is an internet connection."
+            a: "Yes. This software is completely free. You do not need an account, login, or subscription. All you need is an internet connection.",
         },
         {
             q: "Can using this software get my Spotify account suspended or banned?",
-            a: "No. This software has no connection to your Spotify account. Spotify data is obtained through reverse engineering of the Spotify Web Player, not through user authentication."
+            a: "No. This software has no connection to your Spotify account. Spotify data is obtained through reverse engineering of the Spotify Web Player, not through user authentication.",
         },
         {
             q: "Where does the audio come from?",
-            a: "The audio is fetched using third-party APIs."
+            a: "The audio is fetched using third-party APIs.",
         },
         {
             q: "Why does metadata fetching sometimes fail?",
-            a: "This usually happens because your IP address has been rate-limited. You can wait and try again later, or use a VPN to bypass the rate limit."
+            a: "This usually happens because your IP address has been rate-limited. You can wait and try again later, or use a VPN to bypass the rate limit.",
         },
         {
             q: "Why does Windows Defender or antivirus flag or delete the file?",
-            a: "This is a false positive. It likely happens because the executable is compressed using UPX. If you are concerned, you can fork the repository and build the software yourself from source."
-        }
+            a: "This is a false positive. It likely happens because the executable is compressed using UPX. If you are concerned, you can fork the repository and build the software yourself from source.",
+        },
     ];
     const formatTimeAgo = (dateString: string): string => {
         const now = new Date();
@@ -177,13 +180,13 @@ export function AboutPage({ version }: AboutPageProps) {
         const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
         const diffMonths = Math.floor(diffDays / 30);
         if (diffDays === 0)
-            return 'today';
+            return "today";
         if (diffDays === 1)
-            return '1d';
+            return "1d";
         if (diffDays < 30)
             return `${diffDays}d`;
         if (diffMonths === 1)
-            return '1mo';
+            return "1mo";
         if (diffMonths < 12)
             return `${diffMonths}mo`;
         const diffYears = Math.floor(diffMonths / 12);
@@ -196,7 +199,7 @@ export function AboutPage({ version }: AboutPageProps) {
         return num.toString();
     };
     const getLangColor = (lang: string): string => {
-        return langColors[lang] || '#858585';
+        return langColors[lang] || "#858585";
     };
     const handleSubmit = () => {
         const title = activeTab === "bug_report"
@@ -204,7 +207,9 @@ export function AboutPage({ version }: AboutPageProps) {
             : `[Feature Request] ${featureDesc.substring(0, 50)}${featureDesc.length > 50 ? "..." : ""}`;
         let bodyContent = "";
         if (activeTab === "bug_report") {
-            const contextContent = bugContext.trim() ? bugContext.trim() : "Type here or send screenshot/recording";
+            const contextContent = bugContext.trim()
+                ? bugContext.trim()
+                : "Type here or send screenshot/recording";
             bodyContent = `### [Bug Report]
 
 #### Problem
@@ -225,7 +230,9 @@ ${contextContent}
 - Location: ${location}`;
         }
         else {
-            const contextContent = featureContext.trim() ? featureContext.trim() : "Type here or send screenshot/recording";
+            const contextContent = featureContext.trim()
+                ? featureContext.trim()
+                : "Type here or send screenshot/recording";
             bodyContent = `### [Feature Request]
 
 #### Description
@@ -239,200 +246,320 @@ ${contextContent}`;
         }
         const params = new URLSearchParams({
             title: title,
-            body: bodyContent
+            body: bodyContent,
         });
         const url = `https://github.com/afkarxyz/SpotiFLAC/issues/new?${params.toString()}`;
         openExternal(url);
     };
     return (<div className={`flex flex-col space-y-4 ${activeTab === "faq" ? "h-[calc(100vh-10rem)]" : ""}`}>
-        <div className="flex items-center justify-between shrink-0">
-            <h2 className="text-2xl font-bold tracking-tight">About</h2>
-        </div>
+      <div className="flex items-center justify-between shrink-0">
+        <h2 className="text-2xl font-bold tracking-tight">About</h2>
+      </div>
 
-        <div className="flex gap-2 border-b shrink-0">
-            <Button variant={activeTab === "bug_report" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("bug_report")} className="rounded-b-none">
-                <Bug className="h-4 w-4"/>
-                Bug Report
-            </Button>
-            <Button variant={activeTab === "feature_request" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("feature_request")} className="rounded-b-none">
-                <Lightbulb className="h-4 w-4"/>
-                Feature Request
-            </Button>
-            <Button variant={activeTab === "faq" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("faq")} className="rounded-b-none">
-                <CircleHelp className="h-4 w-4"/>
-                FAQ
-            </Button>
-            <Button variant={activeTab === "projects" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("projects")} className="rounded-b-none">
-                <Blocks className="h-4 w-4"/>
-                Other Projects
-            </Button>
-        </div>
+      <div className="flex gap-2 border-b shrink-0">
+        <Button variant={activeTab === "bug_report" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("bug_report")} className="rounded-b-none">
+          <Bug className="h-4 w-4"/>
+          Bug Report
+        </Button>
+        <Button variant={activeTab === "feature_request" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("feature_request")} className="rounded-b-none">
+          <Lightbulb className="h-4 w-4"/>
+          Feature Request
+        </Button>
+        <Button variant={activeTab === "faq" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("faq")} className="rounded-b-none">
+          <CircleHelp className="h-4 w-4"/>
+          FAQ
+        </Button>
+        <Button variant={activeTab === "projects" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("projects")} className="rounded-b-none">
+          <Blocks className="h-4 w-4"/>
+          Other Projects
+        </Button>
+        <Button variant={activeTab === "support" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("support")} className="rounded-b-none">
+          <Heart className="h-4 w-4"/>
+          Support Me
+        </Button>
+      </div>
 
-        <div className={`flex-1 min-h-0 ${activeTab === "faq" ? "overflow-hidden" : ""}`}>
-            {activeTab === "bug_report" && (<div className="flex flex-col">
-                    <div className="space-y-4 pt-4 flex flex-col">
-                        <div className="mt-4 pr-2">
-                           <div className="grid md:grid-cols-3 gap-6">
-                                    <div className="space-y-2 flex flex-col">
-                                        <Label>Problem</Label>
-                                        <Textarea className="h-56 resize-none" placeholder="Describe the problem..." value={problem} onChange={e => setProblem(e.target.value)}/>
-                                    </div>
-                                    <div className="space-y-2 flex flex-col">
-                                        <Label>Additional Context</Label>
-                                        <DragDropMedia className="min-h-[14rem]" value={bugContext} onChange={setBugContext}/>
-                                    </div>
-                                    <div className="space-y-4 flex flex-col">
-                                        <div className="space-y-2">
-                                            <Label>Type</Label>
-                                            <ToggleGroup type="single" value={bugType} onValueChange={(val) => {
+      <div className={`flex-1 min-h-0 ${activeTab === "faq" ? "overflow-hidden" : ""}`}>
+        {activeTab === "bug_report" && (<div className="flex flex-col">
+            <div className="space-y-4 pt-4 flex flex-col">
+              <div className="mt-4 pr-2">
+                <div className="grid md:grid-cols-3 gap-6">
+                  <div className="space-y-2 flex flex-col">
+                    <Label>Problem</Label>
+                    <Textarea className="h-56 resize-none" placeholder="Describe the problem..." value={problem} onChange={(e) => setProblem(e.target.value)}/>
+                  </div>
+                  <div className="space-y-2 flex flex-col">
+                    <Label>Additional Context</Label>
+                    <DragDropMedia className="min-h-[14rem]" value={bugContext} onChange={setBugContext}/>
+                  </div>
+                  <div className="space-y-4 flex flex-col">
+                    <div className="space-y-2">
+                      <Label>Type</Label>
+                      <ToggleGroup type="single" value={bugType} onValueChange={(val) => {
                 if (val)
                     setBugType(val);
             }} className="justify-start w-full cursor-pointer">
-                                                <ToggleGroupItem value="Track" className="flex-1 cursor-pointer" aria-label="Toggle track">Track</ToggleGroupItem>
-                                                <ToggleGroupItem value="Album" className="flex-1 cursor-pointer" aria-label="Toggle album">Album</ToggleGroupItem>
-                                                <ToggleGroupItem value="Playlist" className="flex-1 cursor-pointer" aria-label="Toggle playlist">Playlist</ToggleGroupItem>
-                                                <ToggleGroupItem value="Artist" className="flex-1 cursor-pointer" aria-label="Toggle artist">Artist</ToggleGroupItem>
-                                            </ToggleGroup>
-                                        </div>
-                                        <div className="space-y-2">
-                                            <Label>Spotify URL</Label>
-                                            <Input placeholder="https://open.spotify.com/..." value={spotifyUrl} onChange={e => setSpotifyUrl(e.target.value)}/>
-                                        </div>
-                                    </div>
-                                </div>
-                            </div>
+                        <ToggleGroupItem value="Track" className="flex-1 cursor-pointer" aria-label="Toggle track">
+                          Track
+                        </ToggleGroupItem>
+                        <ToggleGroupItem value="Album" className="flex-1 cursor-pointer" aria-label="Toggle album">
+                          Album
+                        </ToggleGroupItem>
+                        <ToggleGroupItem value="Playlist" className="flex-1 cursor-pointer" aria-label="Toggle playlist">
+                          Playlist
+                        </ToggleGroupItem>
+                        <ToggleGroupItem value="Artist" className="flex-1 cursor-pointer" aria-label="Toggle artist">
+                          Artist
+                        </ToggleGroupItem>
+                      </ToggleGroup>
                     </div>
-                    <div className="flex justify-center pt-4 shrink-0">
-                        <Button className="w-[200px] cursor-pointer gap-2" onClick={handleSubmit}>
-                            <ExternalLink className="h-4 w-4"/> Create Issue on GitHub
-                        </Button>
+                    <div className="space-y-2">
+                      <Label>Spotify URL</Label>
+                      <Input placeholder="https://open.spotify.com/..." value={spotifyUrl} onChange={(e) => setSpotifyUrl(e.target.value)}/>
                     </div>
-                </div>)}
+                  </div>
+                </div>
+              </div>
+            </div>
+            <div className="flex justify-center pt-4 shrink-0">
+              <Button className="w-[200px] cursor-pointer gap-2" onClick={handleSubmit}>
+                <ExternalLink className="h-4 w-4"/> Create Issue on GitHub
+              </Button>
+            </div>
+          </div>)}
 
-            {activeTab === "feature_request" && (<div className="flex flex-col">
-                    <div className="space-y-4 pt-4 flex flex-col">
-                        <div className="mt-4 pr-2">
-                            <div className="grid md:grid-cols-3 gap-6">
-                                    <div className="space-y-2 flex flex-col">
-                                        <Label>Description</Label>
-                                        <Textarea className="h-56 resize-none" placeholder="Describe your feature request..." value={featureDesc} onChange={e => setFeatureDesc(e.target.value)}/>
-                                    </div>
-                                    <div className="space-y-2 flex-col">
-                                        <Label>Use Case</Label>
-                                        <Textarea className="h-56 resize-none" placeholder="How would this feature be useful?" value={useCase} onChange={e => setUseCase(e.target.value)}/>
-                                    </div>
-                                    <div className="space-y-2 flex-col">
-                                        <Label>Additional Context</Label>
-                                        <DragDropMedia className="min-h-[14rem]" value={featureContext} onChange={setFeatureContext}/>
-                                    </div>
-                                </div>
-                            </div>
-                    </div>
-                    <div className="flex justify-center pt-4 shrink-0">
-                        <Button className="w-[200px] cursor-pointer gap-2" onClick={handleSubmit}>
-                            <ExternalLink className="h-4 w-4"/> Create Issue on GitHub
-                        </Button>
-                    </div>
-                </div>)}
+        {activeTab === "feature_request" && (<div className="flex flex-col">
+            <div className="space-y-4 pt-4 flex flex-col">
+              <div className="mt-4 pr-2">
+                <div className="grid md:grid-cols-3 gap-6">
+                  <div className="space-y-2 flex flex-col">
+                    <Label>Description</Label>
+                    <Textarea className="h-56 resize-none" placeholder="Describe your feature request..." value={featureDesc} onChange={(e) => setFeatureDesc(e.target.value)}/>
+                  </div>
+                  <div className="space-y-2 flex-col">
+                    <Label>Use Case</Label>
+                    <Textarea className="h-56 resize-none" placeholder="How would this feature be useful?" value={useCase} onChange={(e) => setUseCase(e.target.value)}/>
+                  </div>
+                  <div className="space-y-2 flex-col">
+                    <Label>Additional Context</Label>
+                    <DragDropMedia className="min-h-[14rem]" value={featureContext} onChange={setFeatureContext}/>
+                  </div>
+                </div>
+              </div>
+            </div>
+            <div className="flex justify-center pt-4 shrink-0">
+              <Button className="w-[200px] cursor-pointer gap-2" onClick={handleSubmit}>
+                <ExternalLink className="h-4 w-4"/> Create Issue on GitHub
+              </Button>
+            </div>
+          </div>)}
 
-            {activeTab === "faq" && (<ScrollArea className="h-full">
-                     <div className="p-1 pr-4">
-                        <Card>
-                            <CardHeader>
-                                <CardTitle>Frequently Asked Questions</CardTitle>
-                            </CardHeader>
-                            <CardContent className="space-y-6">
-                                {faqs.map((faq, index) => (<div key={index} className="space-y-2">
-                                    <h3 className="font-medium text-base text-foreground/90">{faq.q}</h3>
-                                    <p className="text-sm text-muted-foreground leading-relaxed">{faq.a}</p>
-                                </div>))}
-                            </CardContent>
-                        </Card>
-                    </div>
-                </ScrollArea>)}
+        {activeTab === "faq" && (<ScrollArea className="h-full">
+            <div className="p-1 pr-4">
+              <Card>
+                <CardHeader>
+                  <CardTitle>Frequently Asked Questions</CardTitle>
+                </CardHeader>
+                <CardContent className="space-y-6">
+                  {faqs.map((faq, index) => (<div key={index} className="space-y-2">
+                      <h3 className="font-medium text-base text-foreground/90">
+                        {faq.q}
+                      </h3>
+                      <p className="text-sm text-muted-foreground leading-relaxed">
+                        {faq.a}
+                      </p>
+                    </div>))}
+                </CardContent>
+              </Card>
+            </div>
+          </ScrollArea>)}
 
-            {activeTab === "projects" && (<div className="p-1 pr-2">
-                    <div className="grid gap-2 grid-cols-4">
-                            <div className="flex flex-col gap-2 h-full">
-                                <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer flex-1" onClick={() => openExternal("https://exyezed.cc/")}>
-                                    <CardHeader>
-                                        <CardTitle>Browser Extensions & Scripts</CardTitle>
-                                        <CardDescription className="flex gap-3 pt-2">
-                                            <img src={AudioTTSProIcon} className="h-8 w-8 rounded-md shadow-sm" alt="AudioTTS Pro"/>
-                                            <img src={ChatGPTTTSIcon} className="h-8 w-8 rounded-md shadow-sm" alt="ChatGPT TTS"/>
-                                            <img src={XProIcon} className="h-8 w-8 rounded-md shadow-sm" alt="X Pro"/>
-                                        </CardDescription>
-                                    </CardHeader>
-                                </Card>
-                                <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer flex-1" onClick={() => openExternal("https://spotubedl.com/")}>
-                                    <CardHeader>
-                                        <CardTitle className="flex items-center gap-2"><img src={SpotubeDLIcon} className="h-5 w-5" alt="SpotubeDL"/> SpotubeDL</CardTitle>
-                                        <CardDescription>Download Spotify Tracks, Albums, Playlists as MP3/OGG/Opus with High Quality.</CardDescription>
-                                    </CardHeader>
-                                </Card>
-                            </div>
-                            <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/afkarxyz/SpotiDownloader")}>
-                                <CardHeader>
-                                    <CardTitle className="flex items-center gap-2"><img src={SpotiDownloaderIcon} className="h-5 w-5" alt="SpotiDownloader"/> SpotiDownloader</CardTitle>
-                                    <CardDescription>Get Spotify tracks in MP3 and FLAC via spotidownloader.com</CardDescription>
-                                </CardHeader>
-                                {repoStats['SpotiDownloader'] && (<CardContent className="space-y-3">
-                                    <div className="flex flex-wrap gap-2 text-xs">
-                                        {repoStats['SpotiDownloader'].languages?.map((lang: string) => (<span key={lang} className="px-2 py-0.5 rounded-full font-medium" style={{ backgroundColor: getLangColor(lang) + '20', color: getLangColor(lang) }}>{lang}</span>))}
-                                    </div>
-                                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
-                                        <span className="flex items-center gap-1"><Star className="h-3.5 w-3.5 fill-amber-500 text-amber-500"/> {formatNumber(repoStats['SpotiDownloader'].stars)}</span>
-                                        <span className="flex items-center gap-1"><GitFork className="h-3.5 w-3.5"/> {repoStats['SpotiDownloader'].forks}</span>
-                                        <span className="flex items-center gap-1"><Clock className="h-3.5 w-3.5"/> {formatTimeAgo(repoStats['SpotiDownloader'].createdAt)}</span>
-                                    </div>
-                                    <div className="flex flex-col gap-1 text-xs text-muted-foreground items-start">
-                                        <span className="flex items-center gap-1"><Download className="h-3.5 w-3.5"/> TOTAL: {formatNumber(repoStats['SpotiDownloader'].totalDownloads)}</span>
-                                        <span className="flex items-center gap-1 text-green-600 dark:text-green-400"><Download className="h-3.5 w-3.5"/> LATEST: {formatNumber(repoStats['SpotiDownloader'].latestDownloads)}</span>
-                                    </div>
-                                </CardContent>)}
-                            </Card>
-                            <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/spotiverse/SpotiFLAC-Next")}>
-                                <CardHeader>
-                                    <CardTitle className="flex items-center gap-2"><img src={SpotiFLACNextIcon} className="h-5 w-5" alt="SpotiFLAC Next"/> SpotiFLAC Next</CardTitle>
-                                    <CardDescription>Get Spotify tracks in Hi-Res lossless FLACs — no account required.</CardDescription>
-                                </CardHeader>
-                                {repoStats['SpotiFLAC-Next'] && (<CardContent className="space-y-3">
-                                    <div className="flex flex-wrap gap-2 text-xs">
-                                        {repoStats['SpotiFLAC-Next'].languages?.map((lang: string) => (<span key={lang} className="px-2 py-0.5 rounded-full font-medium" style={{ backgroundColor: getLangColor(lang) + '20', color: getLangColor(lang) }}>{lang}</span>))}
-                                    </div>
-                                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
-                                        <span className="flex items-center gap-1"><Star className="h-3.5 w-3.5 fill-amber-500 text-amber-500"/> {formatNumber(repoStats['SpotiFLAC-Next'].stars)}</span>
-                                        <span className="flex items-center gap-1"><GitFork className="h-3.5 w-3.5"/> {repoStats['SpotiFLAC-Next'].forks}</span>
-                                        <span className="flex items-center gap-1"><Clock className="h-3.5 w-3.5"/> {formatTimeAgo(repoStats['SpotiFLAC-Next'].createdAt)}</span>
-                                    </div>
-                                    <div className="flex flex-col gap-1 text-xs text-muted-foreground items-start">
-                                        <span className="flex items-center gap-1"><Download className="h-3.5 w-3.5"/> TOTAL: {formatNumber(repoStats['SpotiFLAC-Next'].totalDownloads)}</span>
-                                        <span className="flex items-center gap-1 text-green-600 dark:text-green-400"><Download className="h-3.5 w-3.5"/> LATEST: {formatNumber(repoStats['SpotiFLAC-Next'].latestDownloads)}</span>
-                                    </div>
-                                </CardContent>)}
-                            </Card>
-                            <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/afkarxyz/Twitter-X-Media-Batch-Downloader")}>
-                                <CardHeader>
-                                    <CardTitle className="flex items-center gap-2"><img src={XBatchDLIcon} className="h-5 w-5" alt="Twitter/X Media Batch Downloader"/> Twitter/X Media Batch Downloader</CardTitle>
-                                    <CardDescription>A GUI tool to download original-quality images and videos from Twitter/X accounts, powered by gallery-dl by @mikf</CardDescription>
-                                </CardHeader>
-                                {repoStats['Twitter-X-Media-Batch-Downloader'] && (<CardContent className="space-y-3">
-                                    <div className="flex flex-wrap gap-2 text-xs">
-                                        {repoStats['Twitter-X-Media-Batch-Downloader'].languages?.map((lang: string) => (<span key={lang} className="px-2 py-0.5 rounded-full font-medium" style={{ backgroundColor: getLangColor(lang) + '20', color: getLangColor(lang) }}>{lang}</span>))}
-                                    </div>
-                                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
-                                        <span className="flex items-center gap-1"><Star className="h-3.5 w-3.5 fill-amber-500 text-amber-500"/> {formatNumber(repoStats['Twitter-X-Media-Batch-Downloader'].stars)}</span>
-                                        <span className="flex items-center gap-1"><GitFork className="h-3.5 w-3.5"/> {repoStats['Twitter-X-Media-Batch-Downloader'].forks}</span>
-                                        <span className="flex items-center gap-1"><Clock className="h-3.5 w-3.5"/> {formatTimeAgo(repoStats['Twitter-X-Media-Batch-Downloader'].createdAt)}</span>
-                                    </div>
-                                    <div className="flex flex-col gap-1 text-xs text-muted-foreground items-start">
-                                        <span className="flex items-center gap-1"><Download className="h-3.5 w-3.5"/> TOTAL: {formatNumber(repoStats['Twitter-X-Media-Batch-Downloader'].totalDownloads)}</span>
-                                        <span className="flex items-center gap-1 text-green-600 dark:text-green-400"><Download className="h-3.5 w-3.5"/> LATEST: {formatNumber(repoStats['Twitter-X-Media-Batch-Downloader'].latestDownloads)}</span>
-                                    </div>
-                                </CardContent>)}
-                            </Card>
-                        </div>
-                    </div>)}
-        </div>
+        {activeTab === "projects" && (<div className="p-1 pr-2">
+            <div className="grid gap-2 grid-cols-4">
+              <div className="flex flex-col gap-2 h-full">
+                <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer flex-1" onClick={() => openExternal("https://exyezed.cc/")}>
+                  <CardHeader>
+                    <CardTitle>Browser Extensions & Scripts</CardTitle>
+                    <CardDescription className="flex gap-3 pt-2">
+                      <img src={AudioTTSProIcon} className="h-8 w-8 rounded-md shadow-sm" alt="AudioTTS Pro"/>
+                      <img src={ChatGPTTTSIcon} className="h-8 w-8 rounded-md shadow-sm" alt="ChatGPT TTS"/>
+                      <img src={XProIcon} className="h-8 w-8 rounded-md shadow-sm" alt="X Pro"/>
+                    </CardDescription>
+                  </CardHeader>
+                </Card>
+                <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer flex-1" onClick={() => openExternal("https://spotubedl.com/")}>
+                  <CardHeader>
+                    <CardTitle className="flex items-center gap-2">
+                      <img src={SpotubeDLIcon} className="h-5 w-5" alt="SpotubeDL"/>{" "}
+                      SpotubeDL
+                    </CardTitle>
+                    <CardDescription>
+                      Download Spotify Tracks, Albums, Playlists as MP3/OGG/Opus
+                      with High Quality.
+                    </CardDescription>
+                  </CardHeader>
+                </Card>
+              </div>
+              <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/afkarxyz/SpotiDownloader")}>
+                <CardHeader>
+                  <CardTitle className="flex items-center gap-2">
+                    <img src={SpotiDownloaderIcon} className="h-5 w-5" alt="SpotiDownloader"/>{" "}
+                    SpotiDownloader
+                  </CardTitle>
+                  <CardDescription>
+                    Get Spotify tracks in MP3 and FLAC via spotidownloader.com
+                  </CardDescription>
+                </CardHeader>
+                {repoStats["SpotiDownloader"] && (<CardContent className="space-y-3">
+                    <div className="flex flex-wrap gap-2 text-xs">
+                      {repoStats["SpotiDownloader"].languages?.map((lang: string) => (<span key={lang} className="px-2 py-0.5 rounded-full font-medium" style={{
+                        backgroundColor: getLangColor(lang) + "20",
+                        color: getLangColor(lang),
+                    }}>
+                            {lang}
+                          </span>))}
+                    </div>
+                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
+                      <span className="flex items-center gap-1">
+                        <Star className="h-3.5 w-3.5 fill-amber-500 text-amber-500"/>{" "}
+                        {formatNumber(repoStats["SpotiDownloader"].stars)}
+                      </span>
+                      <span className="flex items-center gap-1">
+                        <GitFork className="h-3.5 w-3.5"/>{" "}
+                        {repoStats["SpotiDownloader"].forks}
+                      </span>
+                      <span className="flex items-center gap-1">
+                        <Clock className="h-3.5 w-3.5"/>{" "}
+                        {formatTimeAgo(repoStats["SpotiDownloader"].createdAt)}
+                      </span>
+                    </div>
+                    <div className="flex flex-col gap-1 text-xs text-muted-foreground items-start">
+                      <span className="flex items-center gap-1">
+                        <Download className="h-3.5 w-3.5"/> TOTAL:{" "}
+                        {formatNumber(repoStats["SpotiDownloader"].totalDownloads)}
+                      </span>
+                      <span className="flex items-center gap-1 text-green-600 dark:text-green-400">
+                        <Download className="h-3.5 w-3.5"/> LATEST:{" "}
+                        {formatNumber(repoStats["SpotiDownloader"].latestDownloads)}
+                      </span>
+                    </div>
+                  </CardContent>)}
+              </Card>
+              <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/spotiverse/SpotiFLAC-Next")}>
+                <CardHeader>
+                  <CardTitle className="flex items-center gap-2">
+                    <img src={SpotiFLACNextIcon} className="h-5 w-5" alt="SpotiFLAC Next"/>{" "}
+                    SpotiFLAC Next
+                  </CardTitle>
+                  <CardDescription>
+                    Get Spotify tracks in Hi-Res lossless FLACs — no account
+                    required.
+                  </CardDescription>
+                </CardHeader>
+                {repoStats["SpotiFLAC-Next"] && (<CardContent className="space-y-3">
+                    <div className="flex flex-wrap gap-2 text-xs">
+                      {repoStats["SpotiFLAC-Next"].languages?.map((lang: string) => (<span key={lang} className="px-2 py-0.5 rounded-full font-medium" style={{
+                        backgroundColor: getLangColor(lang) + "20",
+                        color: getLangColor(lang),
+                    }}>
+                            {lang}
+                          </span>))}
+                    </div>
+                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
+                      <span className="flex items-center gap-1">
+                        <Star className="h-3.5 w-3.5 fill-amber-500 text-amber-500"/>{" "}
+                        {formatNumber(repoStats["SpotiFLAC-Next"].stars)}
+                      </span>
+                      <span className="flex items-center gap-1">
+                        <GitFork className="h-3.5 w-3.5"/>{" "}
+                        {repoStats["SpotiFLAC-Next"].forks}
+                      </span>
+                      <span className="flex items-center gap-1">
+                        <Clock className="h-3.5 w-3.5"/>{" "}
+                        {formatTimeAgo(repoStats["SpotiFLAC-Next"].createdAt)}
+                      </span>
+                    </div>
+                    <div className="flex flex-col gap-1 text-xs text-muted-foreground items-start">
+                      <span className="flex items-center gap-1">
+                        <Download className="h-3.5 w-3.5"/> TOTAL:{" "}
+                        {formatNumber(repoStats["SpotiFLAC-Next"].totalDownloads)}
+                      </span>
+                      <span className="flex items-center gap-1 text-green-600 dark:text-green-400">
+                        <Download className="h-3.5 w-3.5"/> LATEST:{" "}
+                        {formatNumber(repoStats["SpotiFLAC-Next"].latestDownloads)}
+                      </span>
+                    </div>
+                  </CardContent>)}
+              </Card>
+              <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/afkarxyz/Twitter-X-Media-Batch-Downloader")}>
+                <CardHeader>
+                  <CardTitle className="flex items-center gap-2">
+                    <img src={XBatchDLIcon} className="h-5 w-5" alt="Twitter/X Media Batch Downloader"/>{" "}
+                    Twitter/X Media Batch Downloader
+                  </CardTitle>
+                  <CardDescription>
+                    A GUI tool to download original-quality images and videos
+                    from Twitter/X accounts, powered by gallery-dl by @mikf
+                  </CardDescription>
+                </CardHeader>
+                {repoStats["Twitter-X-Media-Batch-Downloader"] && (<CardContent className="space-y-3">
+                    <div className="flex flex-wrap gap-2 text-xs">
+                      {repoStats["Twitter-X-Media-Batch-Downloader"].languages?.map((lang: string) => (<span key={lang} className="px-2 py-0.5 rounded-full font-medium" style={{
+                        backgroundColor: getLangColor(lang) + "20",
+                        color: getLangColor(lang),
+                    }}>
+                          {lang}
+                        </span>))}
+                    </div>
+                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
+                      <span className="flex items-center gap-1">
+                        <Star className="h-3.5 w-3.5 fill-amber-500 text-amber-500"/>{" "}
+                        {formatNumber(repoStats["Twitter-X-Media-Batch-Downloader"].stars)}
+                      </span>
+                      <span className="flex items-center gap-1">
+                        <GitFork className="h-3.5 w-3.5"/>{" "}
+                        {repoStats["Twitter-X-Media-Batch-Downloader"].forks}
+                      </span>
+                      <span className="flex items-center gap-1">
+                        <Clock className="h-3.5 w-3.5"/>{" "}
+                        {formatTimeAgo(repoStats["Twitter-X-Media-Batch-Downloader"]
+                    .createdAt)}
+                      </span>
+                    </div>
+                    <div className="flex flex-col gap-1 text-xs text-muted-foreground items-start">
+                      <span className="flex items-center gap-1">
+                        <Download className="h-3.5 w-3.5"/> TOTAL:{" "}
+                        {formatNumber(repoStats["Twitter-X-Media-Batch-Downloader"]
+                    .totalDownloads)}
+                      </span>
+                      <span className="flex items-center gap-1 text-green-600 dark:text-green-400">
+                        <Download className="h-3.5 w-3.5"/> LATEST:{" "}
+                        {formatNumber(repoStats["Twitter-X-Media-Batch-Downloader"]
+                    .latestDownloads)}
+                      </span>
+                    </div>
+                  </CardContent>)}
+              </Card>
+            </div>
+          </div>)}
+
+        {activeTab === "support" && (<div className="flex flex-col items-center justify-center p-8 space-y-8">
+            <div className="text-center space-y-2">
+              <h3 className="text-2xl font-bold tracking-tight">Support Me</h3>
+              <p className="text-muted-foreground max-w-[500px]">
+                If this software is useful and brings you value, consider
+                supporting the project on Ko-fi. Your support helps keep
+                development going.
+              </p>
+            </div>
+
+            <div className="flex justify-center w-full max-w-lg">
+              <Button size="lg" className="h-16 text-lg font-semibold text-white gap-3 group" style={{ backgroundColor: "#72a4f2" }} onClick={() => openExternal("https://ko-fi.com/afkarxyz")}>
+                <img src={KofiLogo} className="h-8 w-8 transition-transform group-hover:scale-110" alt="Ko-fi"/>
+                Support me on Ko-fi
+              </Button>
+            </div>
+          </div>)}
+      </div>
     </div>);
 }

frontend/src/components/AlbumInfo.tsx

@@ -48,9 +48,9 @@ interface AlbumInfoProps {
     isBulkDownloadingLyrics?: boolean;
     onSearchChange: (value: string) => void;
     onSortChange: (value: string) => void;
-    onToggleTrack: (isrc: string) => void;
+    onToggleTrack: (id: string) => void;
     onToggleSelectAll: (tracks: TrackMetadata[]) => void;
-    onDownloadTrack: (isrc: string, name: string, artists: string, albumName: string, spotifyId?: string, folderName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
+    onDownloadTrack: (id: string, name: string, artists: string, albumName: string, spotifyId?: string, folderName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
     onDownloadLyrics?: (spotifyId: string, name: string, artists: string, albumName: string, folderName?: string, isArtistDiscography?: boolean, position?: number, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
     onDownloadCover?: (coverUrl: string, trackName: string, artistName: string, albumName: string, folderName?: string, isArtistDiscography?: boolean, position?: number, trackId?: string, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
     onCheckAvailability?: (spotifyId: string) => void;

frontend/src/components/ArtistInfo.tsx

@@ -67,9 +67,9 @@ interface ArtistInfoProps {
     isBulkDownloadingLyrics?: boolean;
     onSearchChange: (value: string) => void;
     onSortChange: (value: string) => void;
-    onToggleTrack: (isrc: string) => void;
+    onToggleTrack: (id: string) => void;
     onToggleSelectAll: (tracks: TrackMetadata[]) => void;
-    onDownloadTrack: (isrc: string, name: string, artists: string, albumName: string, spotifyId?: string, folderName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
+    onDownloadTrack: (id: string, name: string, artists: string, albumName: string, spotifyId?: string, folderName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
     onDownloadLyrics?: (spotifyId: string, name: string, artists: string, albumName: string, folderName?: string, isArtistDiscography?: boolean, position?: number, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
     onDownloadCover?: (coverUrl: string, trackName: string, artistName: string, albumName: string, folderName?: string, isArtistDiscography?: boolean, position?: number, trackId?: string, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
     onCheckAvailability?: (spotifyId: string) => void;
@@ -317,7 +317,7 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
                       <h2 className="text-4xl font-bold text-white">{artistInfo.name}</h2>
                       {artistInfo.verified && (<BadgeCheck className="h-6 w-6 text-white fill-blue-400 shrink-0"/>)}
                     </div>
-                    {artistInfo.biography && (<p className="text-sm text-white/90">{artistInfo.biography}</p>)}
+                    {artistInfo.biography && (<p className="text-sm text-white/90 line-clamp-4">{artistInfo.biography}</p>)}
                     <div className="flex items-center gap-2 text-sm flex-wrap text-white/90">
                       {artistInfo.rank && (<>
                           <span>#{artistInfo.rank} rank</span>
@@ -370,7 +370,7 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
                   <h2 className="text-4xl font-bold">{artistInfo.name}</h2>
                   {artistInfo.verified && (<BadgeCheck className="h-6 w-6 text-white fill-blue-500 shrink-0"/>)}
                 </div>
-                {artistInfo.biography && (<p className="text-sm text-muted-foreground">{artistInfo.biography}</p>)}
+                {artistInfo.biography && (<p className="text-sm text-muted-foreground line-clamp-4">{artistInfo.biography}</p>)}
                 <div className="flex items-center gap-2 text-sm flex-wrap">
                   {artistInfo.rank && (<>
                       <span>#{artistInfo.rank} rank</span>
@@ -446,14 +446,35 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
         </div>)}
 
       {activeTab === "albums" && albumList.length > 0 && (<div className="space-y-4">
-          <h3 className="text-2xl font-bold">Discography</h3>
+          <div className="flex items-center justify-between flex-wrap gap-2">
+            <h3 className="text-2xl font-bold">Discography</h3>
+            <div className="flex gap-2">
+                <Button onClick={onDownloadAll} size="sm" disabled={isDownloading}>
+                    {isDownloading && bulkDownloadType === "all" ? (<Spinner />) : (<Download className="h-4 w-4"/>)}
+                    Download Discography
+                </Button>
+                {selectedTracks.length > 0 && (<Button onClick={onDownloadSelected} size="sm" variant="secondary" disabled={isDownloading}>
+                        {isDownloading && bulkDownloadType === "selected" ? (<Spinner />) : (<Download className="h-4 w-4"/>)}
+                        Download Selected ({selectedTracks.length})
+                    </Button>)}
+            </div>
+          </div>
           <div className="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 gap-4">
-            {albumList.map((album) => (<div key={album.id} className="group cursor-pointer" onClick={() => onAlbumClick({
-                    id: album.id,
-                    name: album.name,
-                    external_urls: album.external_urls,
-                })}>
+            {albumList.map((album) => {
+                const albumTracks = trackList.filter(t => t.album_name === album.name);
+                const tracksWithId = albumTracks.filter(t => t.spotify_id);
+                const isSelected = tracksWithId.length > 0 && tracksWithId.every(t => selectedTracks.includes(t.spotify_id!));
+                const hasTracks = tracksWithId.length > 0;
+                return (<div key={album.id} className="group cursor-pointer relative" onClick={() => onAlbumClick({
+                        id: album.id,
+                        name: album.name,
+                        external_urls: album.external_urls,
+                    })}>
                 <div className="relative mb-2">
+                  
+                  {hasTracks && (<div className={`absolute top-2 left-2 z-20 ${isSelected ? 'opacity-100' : 'opacity-0 group-hover:opacity-100'} transition-opacity`} onClick={(e) => e.stopPropagation()}>
+                        <Checkbox checked={isSelected} onCheckedChange={() => onToggleSelectAll(albumTracks)} className="bg-black/50 border-white/70 data-[state=checked]:bg-primary data-[state=checked]:border-primary"/>
+                    </div>)}
                   {album.images && (<img src={album.images} alt={album.name} className="w-full aspect-square object-cover rounded-md shadow-md transition-shadow group-hover:shadow-xl"/>)}
                   <div className="absolute bottom-2 right-2">
                     <span className="text-[10px] uppercase font-bold px-1.5 py-0.5 rounded bg-black/60 text-white backdrop-blur-[2px]">
@@ -469,7 +490,8 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
                             <span>{album.total_tracks} {album.total_tracks === 1 ? "track" : "tracks"}</span>
                         </>)}
                 </div>
-              </div>))}
+              </div>);
+            })}
           </div>
         </div>)}
 
@@ -491,8 +513,8 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
                       <ScrollArea className="flex-1 pr-4">
                           <div className="space-y-4">
                               {filteredAlbumGroups.map(([albumName, data]) => {
-                const tracksWithIsrc = data.tracks.filter(t => t.isrc);
-                const isSelected = tracksWithIsrc.length > 0 && tracksWithIsrc.every(t => selectedTracks.includes(t.isrc!));
+                const tracksWithId = data.tracks.filter(t => t.spotify_id);
+                const isSelected = tracksWithId.length > 0 && tracksWithId.every(t => selectedTracks.includes(t.spotify_id!));
                 return (<div key={albumName} className="flex items-start space-x-3 p-2 hover:bg-muted/50 rounded-md transition-colors">
                                           <Checkbox id={`album-select-${albumName}`} checked={isSelected} onCheckedChange={() => onToggleSelectAll(data.tracks)} className="mt-1"/>
                                           <div className="grid gap-1.5 leading-none flex-1">

frontend/src/components/AudioConverterPage.tsx

@@ -4,7 +4,7 @@ import { Label } from "@/components/ui/label";
 import { ToggleGroup, ToggleGroupItem, } from "@/components/ui/toggle-group";
 import { Upload, X, CheckCircle2, AlertCircle, Trash2, FileMusic, WandSparkles, } from "lucide-react";
 import { Spinner } from "@/components/ui/spinner";
-import { ConvertAudio, SelectAudioFiles, } from "../../wailsjs/go/main/App";
+import { ConvertAudio, SelectAudioFiles, SelectFolder, ListAudioFilesInDir, } from "../../wailsjs/go/main/App";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
 import { OnFileDrop, OnFileDropOff } from "../../wailsjs/runtime/runtime";
 interface AudioFile {
@@ -152,6 +152,27 @@ export function AudioConverterPage() {
             });
         }
     };
+    const handleSelectFolder = async () => {
+        try {
+            const selectedFolder = await SelectFolder("");
+            if (selectedFolder) {
+                const folderFiles = await ListAudioFilesInDir(selectedFolder);
+                if (folderFiles && folderFiles.length > 0) {
+                    addFiles(folderFiles.map((f) => f.path));
+                }
+                else {
+                    toast.info("No audio files found", {
+                        description: "No FLAC or MP3 files found in the selected folder.",
+                    });
+                }
+            }
+        }
+        catch (err) {
+            toast.error("Folder Selection Failed", {
+                description: err instanceof Error ? err.message : "Failed to select folder",
+            });
+        }
+    };
     const addFiles = useCallback(async (paths: string[]) => {
         const validExtensions = [".mp3", ".flac"];
         const m4aFiles = paths.filter((path) => {
@@ -243,7 +264,7 @@ export function AudioConverterPage() {
                 codec: outputFormat === "m4a" ? m4aCodec : "",
             });
             setFiles((prev) => prev.map((f) => {
-                const result = results.find((r) => r.input_file === f.path);
+                const result = results.find((r) => r.input_file === f.path || r.input_file.toLowerCase() === f.path.toLowerCase());
                 if (result) {
                     return {
                         ...f,
@@ -298,7 +319,11 @@ export function AudioConverterPage() {
             {files.length > 0 && (<div className="flex gap-2">
                 <Button variant="outline" size="sm" onClick={handleSelectFiles}>
                     <Upload className="h-4 w-4"/>
-                    Add More
+                    Add Files
+                </Button>
+                <Button variant="outline" size="sm" onClick={handleSelectFolder}>
+                    <Upload className="h-4 w-4"/>
+                    Add Folder
                 </Button>
                 <Button variant="outline" size="sm" onClick={clearFiles} disabled={converting}>
                     <Trash2 className="h-4 w-4"/>
@@ -329,10 +354,16 @@ export function AudioConverterPage() {
                 ? "Drop your audio files here"
                 : "Drag and drop audio files here, or click the button below to select"}
                 </p>
-                <Button onClick={handleSelectFiles} size="lg">
-                    <Upload className="h-5 w-5"/>
-                    Select Files
-                </Button>
+                <div className="flex gap-3">
+                    <Button onClick={handleSelectFiles} size="lg">
+                        <Upload className="h-5 w-5"/>
+                        Select Files
+                    </Button>
+                    <Button onClick={handleSelectFolder} size="lg" variant="outline">
+                        <Upload className="h-5 w-5"/>
+                        Select Folder
+                    </Button>
+                </div>
                 <p className="text-xs text-muted-foreground mt-4 text-center">
                     Supported formats: FLAC, MP3
                 </p>

frontend/src/components/DebugLoggerPage.tsx

@@ -1,7 +1,9 @@
 import { useState, useEffect, useRef } from "react";
-import { Trash2, Copy, Check } from "lucide-react";
+import { Trash2, Copy, Check, FileDown } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { logger, type LogEntry } from "@/lib/logger";
+import { ExportFailedDownloads } from "../../wailsjs/go/main/App";
+import { toastWithSound as toast } from "@/lib/toast-with-sound";
 const levelColors: Record<string, string> = {
     info: "text-blue-500",
     success: "text-green-500",
@@ -51,10 +53,29 @@ export function DebugLoggerPage() {
             console.error("Failed to copy logs:", err);
         }
     };
+    const handleExportFailed = async () => {
+        try {
+            const message = await ExportFailedDownloads();
+            if (message.startsWith("Successfully")) {
+                toast.success(message);
+            }
+            else if (message !== "Export cancelled") {
+                toast.info(message);
+            }
+        }
+        catch (error) {
+            console.error("Failed to export:", error);
+            toast.error(`Failed to export: ${error}`);
+        }
+    };
     return (<div className="space-y-6">
       <div className="flex items-center justify-between">
         <h1 className="text-2xl font-bold">Debug Logs</h1>
         <div className="flex items-center gap-2">
+          <Button variant="outline" size="sm" className="gap-1.5" onClick={handleExportFailed}>
+            <FileDown className="h-4 w-4"/>
+            Export Failed
+          </Button>
           <Button variant="outline" size="sm" className="gap-1.5" onClick={handleCopy} disabled={logs.length === 0}>
             {copied ? <Check className="h-4 w-4"/> : <Copy className="h-4 w-4"/>}
             Copy

frontend/src/components/DownloadQueue.tsx

@@ -1,9 +1,9 @@
 import { useEffect, useState } from "react";
-import { X, Download, CheckCircle2, XCircle, Clock, FileCheck, Trash2, HardDrive, Zap, Timer } from "lucide-react";
+import { X, Download, CheckCircle2, XCircle, Clock, FileCheck, Trash2, HardDrive, Zap, Timer, FileDown } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Dialog, DialogContent, DialogHeader, DialogTitle, } from "@/components/ui/dialog";
 import { Badge } from "@/components/ui/badge";
-import { GetDownloadQueue, ClearCompletedDownloads, ClearAllDownloads } from "../../wailsjs/go/main/App";
+import { GetDownloadQueue, ClearCompletedDownloads, ClearAllDownloads, ExportFailedDownloads } from "../../wailsjs/go/main/App";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
 import { backend } from "../../wailsjs/go/models";
 interface DownloadQueueProps {
@@ -59,6 +59,21 @@ export function DownloadQueue({ isOpen, onClose }: DownloadQueueProps) {
             console.error("Failed to reset queue:", error);
         }
     };
+    const handleExportFailed = async () => {
+        try {
+            const message = await ExportFailedDownloads();
+            if (message.startsWith("Successfully")) {
+                toast.success(message);
+            }
+            else if (message !== "Export cancelled") {
+                toast.info(message);
+            }
+        }
+        catch (error) {
+            console.error("Failed to export:", error);
+            toast.error(`Failed to export: ${error}`);
+        }
+    };
     const getStatusIcon = (status: string) => {
         switch (status) {
             case "downloading":
@@ -105,6 +120,15 @@ export function DownloadQueue({ isOpen, onClose }: DownloadQueueProps) {
             return `${seconds}s`;
         }
     };
+    const [filterStatus, setFilterStatus] = useState<string>("all");
+    const toggleFilter = (status: string) => {
+        setFilterStatus(prev => prev === status ? "all" : status);
+    };
+    const filteredQueue = queueInfo.queue.filter((item: any) => {
+        if (filterStatus === "all")
+            return true;
+        return item.status === filterStatus;
+    });
     return (<Dialog open={isOpen} onOpenChange={onClose}>
     <DialogContent className="max-w-[1200px] w-[95vw] max-h-[80vh] flex flex-col p-0 gap-0 [&>button]:hidden">
       <DialogHeader className="px-6 pt-6 pb-4 border-b space-y-0">
@@ -115,6 +139,10 @@ export function DownloadQueue({ isOpen, onClose }: DownloadQueueProps) {
               <Trash2 className="h-3 w-3"/>
               Clear History
             </Button>)}
+            {queueInfo.failed_count > 0 && (<Button variant="ghost" size="sm" className="h-7 text-xs gap-1.5" onClick={handleExportFailed}>
+              <FileDown className="h-3 w-3"/>
+              Export Failures
+            </Button>)}
             <Button variant="ghost" size="icon" className="h-7 w-7 rounded-full hover:bg-muted" onClick={onClose}>
               <X className="h-4 w-4"/>
             </Button>
@@ -123,22 +151,22 @@ export function DownloadQueue({ isOpen, onClose }: DownloadQueueProps) {
 
 
         <div className="flex items-center gap-4 text-sm">
-          <div className="flex items-center gap-1.5">
+          <div className={`flex items-center gap-1.5 cursor-pointer hover:opacity-80 transition-all select-none ${filterStatus === 'queued' ? 'bg-secondary px-2 py-0.5 rounded-md ring-1 ring-border' : ''}`} onClick={() => toggleFilter('queued')}>
             <Clock className="h-3.5 w-3.5 text-muted-foreground"/>
             <span className="text-muted-foreground">Queued:</span>
             <span className="font-semibold">{queueInfo.queued_count}</span>
           </div>
-          <div className="flex items-center gap-1.5">
+          <div className={`flex items-center gap-1.5 cursor-pointer hover:opacity-80 transition-all select-none ${filterStatus === 'completed' ? 'bg-green-500/10 px-2 py-0.5 rounded-md ring-1 ring-green-500/20' : ''}`} onClick={() => toggleFilter('completed')}>
             <CheckCircle2 className="h-3.5 w-3.5 text-green-500"/>
             <span className="text-muted-foreground">Completed:</span>
             <span className="font-semibold">{queueInfo.completed_count}</span>
           </div>
-          <div className="flex items-center gap-1.5">
+          <div className={`flex items-center gap-1.5 cursor-pointer hover:opacity-80 transition-all select-none ${filterStatus === 'skipped' ? 'bg-yellow-500/10 px-2 py-0.5 rounded-md ring-1 ring-yellow-500/20' : ''}`} onClick={() => toggleFilter('skipped')}>
             <FileCheck className="h-3.5 w-3.5 text-yellow-500"/>
             <span className="text-muted-foreground">Skipped:</span>
             <span className="font-semibold">{queueInfo.skipped_count}</span>
           </div>
-          <div className="flex items-center gap-1.5">
+          <div className={`flex items-center gap-1.5 cursor-pointer hover:opacity-80 transition-all select-none ${filterStatus === 'failed' ? 'bg-red-500/10 px-2 py-0.5 rounded-md ring-1 ring-red-500/20' : ''}`} onClick={() => toggleFilter('failed')}>
             <XCircle className="h-3.5 w-3.5 text-red-500"/>
             <span className="text-muted-foreground">Failed:</span>
             <span className="font-semibold">{queueInfo.failed_count}</span>
@@ -180,7 +208,10 @@ export function DownloadQueue({ isOpen, onClose }: DownloadQueueProps) {
           {queueInfo.queue.length === 0 ? (<div className="text-center py-12 text-muted-foreground">
             <Download className="h-12 w-12 mx-auto mb-3 opacity-20"/>
             <p>No downloads in queue</p>
-          </div>) : (queueInfo.queue.map((item) => (<div key={item.id} className="border rounded-lg p-3 hover:bg-muted/30 transition-colors">
+          </div>) : filteredQueue.length === 0 ? (<div className="text-center py-12 text-muted-foreground">
+             <p>No downloads with status "{filterStatus}"</p>
+             <Button variant="link" onClick={() => setFilterStatus("all")}>Clear filter</Button>
+            </div>) : (filteredQueue.map((item: any) => (<div key={item.id} className="border rounded-lg p-3 hover:bg-muted/30 transition-colors">
             <div className="flex items-start gap-3">
               <div className="mt-1">{getStatusIcon(item.status)}</div>
 

frontend/src/components/Header.tsx

@@ -35,7 +35,7 @@ export function Header({ version, hasUpdate, releaseDate }: HeaderProps) {
           </div>
         </div>
         <p className="text-muted-foreground">
-          Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account required.
+          Get Spotify tracks in true FLAC from Tidal, Qobuz, Amazon Music & Deezer — no account required.
         </p>
       </div>
     </div>);

frontend/src/components/HistoryPage.tsx

@@ -130,8 +130,10 @@ export function HistoryPage({ onHistorySelect }: HistoryPageProps) {
             }
         });
         setFilteredDownloadHistory(result);
-        setDownloadCurrentPage(1);
     }, [downloadHistory, downloadSearchQuery, downloadSortBy]);
+    useEffect(() => {
+        setDownloadCurrentPage(1);
+    }, [downloadSearchQuery, downloadSortBy]);
     useEffect(() => {
         let result = [...fetchHistory];
         if (activeFetchTab !== "all") {
@@ -144,8 +146,10 @@ export function HistoryPage({ onHistorySelect }: HistoryPageProps) {
         }
         result.sort((a, b) => b.timestamp - a.timestamp);
         setFilteredFetchHistory(result);
-        setFetchCurrentPage(1);
     }, [fetchHistory, fetchSearchQuery, activeFetchTab]);
+    useEffect(() => {
+        setFetchCurrentPage(1);
+    }, [fetchSearchQuery, activeFetchTab]);
     const handlePreview = async (id: string, spotifyId: string) => {
         if (playingPreviewId === id) {
             audioRef.current?.pause();
@@ -299,7 +303,7 @@ export function HistoryPage({ onHistorySelect }: HistoryPageProps) {
                                          <td className="p-3 align-middle text-left hidden lg:table-cell">
                                             <div className="flex flex-col items-start gap-1">
                                                 <span className="text-xs font-bold text-foreground">
-                                                    {['HI_RES_LOSSLESS', 'LOSSLESS'].includes(item.format) ? 'FLAC' : item.format}
+                                                    {['HI_RES_LOSSLESS', 'LOSSLESS', 'flac', '6', '7', '27'].includes(item.format?.toLowerCase() || '') ? 'FLAC' : item.format?.toUpperCase()}
                                                 </span>
                                                 {item.quality && <span className="text-[11px] text-muted-foreground leading-none whitespace-nowrap">{item.quality}</span>}
                                             </div>

frontend/src/components/PlatformIcons.tsx

@@ -16,3 +16,8 @@ export const AmazonIcon = ({ className = "w-4 h-4" }: {
     <path fillRule="evenodd" d="M15.62 11.13c-.15.1-.37.18-.64.18-.42 0-.82-.05-1.21-.18l-.22-.04c-.08 0-.1.04-.1.14v.25c0 .08.02.12.05.17.02.03.07.08.15.1.4.18.84.25 1.33.25.52 0 .91-.12 1.24-.37.32-.25.47-.57.47-.99 0-.3-.08-.52-.23-.72-.15-.17-.4-.34-.74-.47l-.7-.27c-.26-.1-.46-.2-.53-.3a.47.47 0 0 1-.15-.36c0-.38.27-.57.84-.57.32 0 .64.05.94.15l.2.04c.07 0 .12-.04.12-.14v-.25c0-.08-.03-.12-.05-.17-.03-.05-.08-.08-.15-.1-.37-.13-.74-.2-1.11-.2-.47 0-.87.12-1.16.35-.3.22-.45.54-.45.91 0 .57.32.99.97 1.24l.74.27c.24.1.4.17.5.27.09.1.12.2.12.35 0 .2-.08.37-.23.46Zm-3.88-3.55v3.28c-.42.28-.84.42-1.26.42-.27 0-.47-.07-.6-.22-.11-.15-.16-.37-.16-.7V7.59c0-.13-.05-.18-.18-.18h-.52c-.12 0-.17.05-.17.18v3.06c0 .42.1.77.32.99.22.22.55.35.97.35.56 0 1.13-.2 1.68-.6l.05.3c0 .07.02.1.07.12.02.03.07.03.15.03h.37c.12 0 .17-.05.17-.18V7.58c0-.13-.05-.18-.17-.18h-.52c-.15 0-.2.08-.2.18Zm-4.69 4.27h.52c.12 0 .17-.05.17-.17v-3.1c0-.41-.1-.73-.32-.95a1.25 1.25 0 0 0-.94-.35c-.57 0-1.16.2-1.73.62-.2-.42-.57-.62-1.11-.62-.55 0-1.1.2-1.64.57l-.04-.27c0-.08-.03-.1-.08-.13-.02-.02-.07-.02-.12-.02h-.4c-.12 0-.17.05-.17.17v4.1c0 .13.05.18.17.18h.52c.12 0 .17-.05.17-.18V8.37c.42-.25.84-.4 1.29-.4.25 0 .42.08.52.22.1.15.17.35.17.65v2.84c0 .12.05.17.17.17h.52c.13 0 .18-.05.18-.17V8.37c.44-.27.86-.4 1.28-.4.25 0 .42.08.52.22.1.15.17.35.17.65v2.84c0 .12.05.17.18.17Zm13.47 3.29a21.8 21.8 0 0 1-8.3 1.7c-3.96 0-7.8-1.08-10.88-2.89a.35.35 0 0 0-.15-.05c-.17 0-.27.2-.1.37a16.11 16.11 0 0 0 10.87 4.16c3.02 0 6.5-.94 8.9-2.72.42-.3.08-.74-.34-.57Zm-.08-6.74c.22-.26.57-.38 1.06-.38.25 0 .5.03.72.1l.15.02c.07 0 .12-.04.12-.17v-.25c0-.07-.02-.14-.05-.17a.54.54 0 0 0-.12-.1c-.32-.07-.64-.15-.94-.15-.7 0-1.21.2-1.6.62-.38.4-.57 1-.57 1.73 0 .74.17 1.31.54 1.7.37.4.89.6 1.58.6.37 0 .72-.05.99-.17.07-.03.12-.05.15-.1.02-.03.02-.1.02-.17v-.25c0-.13-.05-.17-.12-.17-.03 0-.07 0-.12.02-.28.07-.55.12-.8.12-.46 0-.81-.12-1.03-.37-.23-.24-.32-.64-.32-1.16v-.12c.02-.55.12-.94.34-1.19Z" clipRule="evenodd"></path>
     <path fillRule="evenodd" d="M21.55 17.46c1.29-1.09 1.64-3.33 1.36-3.68-.12-.15-.71-.3-1.45-.3-.8 0-1.73.18-2.45.67-.22.15-.17.35.05.32.76-.1 2.5-.3 2.82.1.3.4-.35 2.03-.65 2.74-.07.23.1.3.32.15ZM18.12 7.4h-.52c-.12 0-.17.05-.17.18v4.1c0 .12.05.17.17.17h.52c.12 0 .17-.05.17-.17v-4.1c0-.1-.05-.18-.17-.18Zm.15-1.68a.58.58 0 0 0-.42-.15c-.18 0-.3.05-.4.15a.5.5 0 0 0-.15.37c0 .15.05.3.15.37.1.1.22.15.4.15.17 0 .3-.05.4-.15a.5.5 0 0 0 .14-.37c0-.15-.02-.3-.12-.37Z" clipRule="evenodd"></path>
   </svg>);
+export const DeezerIcon = ({ className = "w-4 h-4" }: {
+    className?: string;
+}) => (<svg viewBox="0 0 512 512" className={`${className} fill-current`}>
+    <path d="M14.8 101.1C6.6 101.1 0 127.6 0 160.3s6.6 59.2 14.8 59.2s14.8-26.5 14.8-59.2s-6.6-59.2-14.8-59.2m433.9-60.2c-7.7 0-14.5 17.1-19.4 44.1c-7.7-46.7-20.2-77-34.2-77c-16.8 0-31.1 42.9-38 105.4c-6.6-45.4-16.8-74.2-28.3-74.2c-16.1 0-29.6 56.9-34.7 136.2c-9.4-40.8-23.2-66.3-38.3-66.3s-28.8 25.5-38.3 66.3c-5.1-79.3-18.6-136.2-34.7-136.2c-11.5 0-21.7 28.8-28.3 74.2C147.9 50.9 133.3 8 116.7 8c-14 0-26.5 30.4-34.2 77c-4.8-27-11.7-44.1-19.4-44.1c-14.3 0-26 59.2-26 132.1S49 305.2 63.3 305.2c5.9 0 11.5-9.9 15.8-26.8c6.9 61.7 21.2 104.1 38 104.1c13 0 24.5-25.5 32.1-65.6c5.4 76.3 18.6 130.4 34.2 130.4c9.7 0 18.6-21.4 25.3-56.4c7.9 72.2 26.3 122.7 47.7 122.7s39.5-50.5 47.7-122.7c6.6 35 15.6 56.4 25.3 56.4c15.6 0 28.8-54.1 34.2-130.4c7.7 40.1 19.4 65.6 32.1 65.6c16.6 0 30.9-42.3 38-104.1c4.3 16.8 9.7 26.8 15.8 26.8c14.3 0 26-59.2 26-132.1S463 40.9 448.7 40.9m48.5 60.2c-8.2 0-14.8 26.5-14.8 59.2s6.6 59.2 14.8 59.2S512 193 512 160.3s-6.6-59.2-14.8-59.2"/>
+  </svg>);

frontend/src/components/PlaylistInfo.tsx

@@ -54,9 +54,9 @@ interface PlaylistInfoProps {
     isBulkDownloadingLyrics?: boolean;
     onSearchChange: (value: string) => void;
     onSortChange: (value: string) => void;
-    onToggleTrack: (isrc: string) => void;
+    onToggleTrack: (id: string) => void;
     onToggleSelectAll: (tracks: TrackMetadata[]) => void;
-    onDownloadTrack: (isrc: string, name: string, artists: string, albumName: string, spotifyId?: string, folderName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
+    onDownloadTrack: (id: string, name: string, artists: string, albumName: string, spotifyId?: string, folderName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
     onDownloadLyrics?: (spotifyId: string, name: string, artists: string, albumName: string, folderName?: string, isArtistDiscography?: boolean, position?: number, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
     onDownloadCover?: (coverUrl: string, trackName: string, artistName: string, albumName: string, folderName?: string, isArtistDiscography?: boolean, position?: number, trackId?: string, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
     onCheckAvailability?: (spotifyId: string) => void;

frontend/src/components/SearchAndSort.tsx

@@ -33,6 +33,7 @@ export function SearchAndSort({ searchQuery, sortBy, onSearchChange, onSortChang
           <SelectItem value="plays-desc">Plays (High)</SelectItem>
           <SelectItem value="downloaded">Downloaded</SelectItem>
           <SelectItem value="not-downloaded">Not Downloaded</SelectItem>
+          <SelectItem value="failed">Failed Downloads</SelectItem>
         </SelectContent>
       </Select>
     </div>);

frontend/src/components/SearchBar.tsx

@@ -1,7 +1,7 @@
 import { useState, useEffect, useRef } from "react";
 import { Button } from "@/components/ui/button";
 import { InputWithContext } from "@/components/ui/input-with-context";
-import { CloudDownload, XCircle, Link, Search, X, ChevronDown } from "lucide-react";
+import { CloudDownload, XCircle, Link, Search, X, ChevronDown, } from "lucide-react";
 import { Spinner } from "@/components/ui/spinner";
 import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip";
 import { FetchHistory } from "@/components/FetchHistory";
@@ -10,12 +10,13 @@ import { SearchSpotify, SearchSpotifyByType } from "../../wailsjs/go/main/App";
 import { backend } from "../../wailsjs/go/models";
 import { cn } from "@/lib/utils";
 import { useTypingEffect } from "@/hooks/useTypingEffect";
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from "@/components/ui/select";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@/components/ui/dialog";
 const FETCH_PLACEHOLDERS = [
     "https://open.spotify.com/track/...",
     "https://open.spotify.com/album/...",
     "https://open.spotify.com/playlist/...",
-    "https://open.spotify.com/artist/..."
+    "https://open.spotify.com/artist/...",
 ];
 const SEARCH_PLACEHOLDERS = [
     "Golden",
@@ -23,10 +24,194 @@ const SEARCH_PLACEHOLDERS = [
     "The Weeknd",
     "Starboy",
     "Joji",
-    "Die For You"
+    "Die For You",
 ];
-const REGIONS = ["AD", "AE", "AG", "AL", "AM", "AO", "AR", "AT", "AU", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BN", "BO", "BR", "BS", "BT", "BW", "BZ", "CA", "CD", "CG", "CH", "CI", "CL", "CM", "CO", "CR", "CV", "CW", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", "EG", "ES", "ET", "FI", "FJ", "FM", "FR", "GA", "GB", "GD", "GE", "GH", "GM", "GN", "GQ", "GR", "GT", "GW", "GY", "HK", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IN", "IQ", "IS", "IT", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KR", "KW", "KZ", "LA", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "ME", "MG", "MH", "MK", "ML", "MN", "MO", "MR", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NE", "NG", "NI", "NL", "NO", "NP", "NR", "NZ", "OM", "PA", "PE", "PG", "PH", "PK", "PL", "PS", "PT", "PW", "PY", "QA", "RO", "RS", "RW", "SA", "SB", "SC", "SE", "SG", "SI", "SK", "SL", "SM", "SN", "SR", "ST", "SV", "SZ", "TD", "TG", "TH", "TJ", "TL", "TN", "TO", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "US", "UY", "UZ", "VC", "VE", "VN", "VU", "WS", "XK", "ZA", "ZM", "ZW"];
-const regionNames = new Intl.DisplayNames(['en'], { type: 'region' });
+const REGIONS = [
+    "AD",
+    "AE",
+    "AG",
+    "AL",
+    "AM",
+    "AO",
+    "AR",
+    "AT",
+    "AU",
+    "AZ",
+    "BA",
+    "BB",
+    "BD",
+    "BE",
+    "BF",
+    "BG",
+    "BH",
+    "BI",
+    "BJ",
+    "BN",
+    "BO",
+    "BR",
+    "BS",
+    "BT",
+    "BW",
+    "BZ",
+    "CA",
+    "CD",
+    "CG",
+    "CH",
+    "CI",
+    "CL",
+    "CM",
+    "CO",
+    "CR",
+    "CV",
+    "CW",
+    "CY",
+    "CZ",
+    "DE",
+    "DJ",
+    "DK",
+    "DM",
+    "DO",
+    "DZ",
+    "EC",
+    "EE",
+    "EG",
+    "ES",
+    "ET",
+    "FI",
+    "FJ",
+    "FM",
+    "FR",
+    "GA",
+    "GB",
+    "GD",
+    "GE",
+    "GH",
+    "GM",
+    "GN",
+    "GQ",
+    "GR",
+    "GT",
+    "GW",
+    "GY",
+    "HK",
+    "HN",
+    "HR",
+    "HT",
+    "HU",
+    "ID",
+    "IE",
+    "IL",
+    "IN",
+    "IQ",
+    "IS",
+    "IT",
+    "JM",
+    "JO",
+    "JP",
+    "KE",
+    "KG",
+    "KH",
+    "KI",
+    "KM",
+    "KN",
+    "KR",
+    "KW",
+    "KZ",
+    "LA",
+    "LB",
+    "LC",
+    "LI",
+    "LK",
+    "LR",
+    "LS",
+    "LT",
+    "LU",
+    "LV",
+    "LY",
+    "MA",
+    "MC",
+    "MD",
+    "ME",
+    "MG",
+    "MH",
+    "MK",
+    "ML",
+    "MN",
+    "MO",
+    "MR",
+    "MT",
+    "MU",
+    "MV",
+    "MW",
+    "MX",
+    "MY",
+    "MZ",
+    "NA",
+    "NE",
+    "NG",
+    "NI",
+    "NL",
+    "NO",
+    "NP",
+    "NR",
+    "NZ",
+    "OM",
+    "PA",
+    "PE",
+    "PG",
+    "PH",
+    "PK",
+    "PL",
+    "PS",
+    "PT",
+    "PW",
+    "PY",
+    "QA",
+    "RO",
+    "RS",
+    "RW",
+    "SA",
+    "SB",
+    "SC",
+    "SE",
+    "SG",
+    "SI",
+    "SK",
+    "SL",
+    "SM",
+    "SN",
+    "SR",
+    "ST",
+    "SV",
+    "SZ",
+    "TD",
+    "TG",
+    "TH",
+    "TJ",
+    "TL",
+    "TN",
+    "TO",
+    "TR",
+    "TT",
+    "TV",
+    "TW",
+    "TZ",
+    "UA",
+    "UG",
+    "US",
+    "UY",
+    "UZ",
+    "VC",
+    "VE",
+    "VN",
+    "VU",
+    "WS",
+    "XK",
+    "ZA",
+    "ZM",
+    "ZW",
+];
+const regionNames = new Intl.DisplayNames(["en"], { type: "region" });
 const getRegionName = (code: string) => {
     try {
         if (code === "XK")
@@ -56,7 +241,7 @@ interface SearchBarProps {
     region: string;
     onRegionChange: (region: string) => void;
 }
-export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, history, onHistorySelect, onHistoryRemove, hasResult, searchMode, onSearchModeChange, region, onRegionChange }: SearchBarProps) {
+export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, history, onHistorySelect, onHistoryRemove, hasResult, searchMode, onSearchModeChange, region, onRegionChange, }: SearchBarProps) {
     const [searchQuery, setSearchQuery] = useState("");
     const [searchResults, setSearchResults] = useState<backend.SearchResponse | null>(null);
     const [isSearching, setIsSearching] = useState(false);
@@ -70,6 +255,8 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
         artists: false,
         playlists: false,
     });
+    const [showInvalidUrlDialog, setShowInvalidUrlDialog] = useState(false);
+    const [invalidUrl, setInvalidUrl] = useState("");
     const searchTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
     const placeholders = searchMode ? SEARCH_PLACEHOLDERS : FETCH_PLACEHOLDERS;
     const placeholderText = useTypingEffect(placeholders);
@@ -125,7 +312,10 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
         searchTimeoutRef.current = setTimeout(async () => {
             setIsSearching(true);
             try {
-                const results = await SearchSpotify({ query: searchQuery, limit: SEARCH_LIMIT });
+                const results = await SearchSpotify({
+                    query: searchQuery,
+                    limit: SEARCH_LIMIT,
+                });
                 setSearchResults(results);
                 setLastSearchedQuery(searchQuery.trim());
                 saveRecentSearch(searchQuery.trim());
@@ -181,10 +371,18 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
                     if (!prev)
                         return prev;
                     const updated = new backend.SearchResponse({
-                        tracks: activeTab === "tracks" ? [...prev.tracks, ...moreResults] : prev.tracks,
-                        albums: activeTab === "albums" ? [...prev.albums, ...moreResults] : prev.albums,
-                        artists: activeTab === "artists" ? [...prev.artists, ...moreResults] : prev.artists,
-                        playlists: activeTab === "playlists" ? [...prev.playlists, ...moreResults] : prev.playlists,
+                        tracks: activeTab === "tracks"
+                            ? [...prev.tracks, ...moreResults]
+                            : prev.tracks,
+                        albums: activeTab === "albums"
+                            ? [...prev.albums, ...moreResults]
+                            : prev.albums,
+                        artists: activeTab === "artists"
+                            ? [...prev.artists, ...moreResults]
+                            : prev.artists,
+                        playlists: activeTab === "playlists"
+                            ? [...prev.playlists, ...moreResults]
+                            : prev.playlists,
                     });
                     return updated;
                 });
@@ -201,6 +399,35 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
             setIsLoadingMore(false);
         }
     };
+    const isSpotifyUrl = (text: string) => {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return true;
+        const isUrl = /^(https?:\/\/|www\.)/i.test(trimmed) || /^spotify:/i.test(trimmed);
+        if (!isUrl)
+            return true;
+        return (trimmed.includes("spotify.com") ||
+            trimmed.includes("spotify.link") ||
+            trimmed.startsWith("spotify:"));
+    };
+    const handlePaste = (e: React.ClipboardEvent<HTMLInputElement>) => {
+        if (searchMode)
+            return;
+        const pastedText = e.clipboardData.getData("text");
+        if (pastedText && !isSpotifyUrl(pastedText)) {
+            e.preventDefault();
+            setInvalidUrl(pastedText);
+            setShowInvalidUrlDialog(true);
+        }
+    };
+    const handleFetchWithValidation = () => {
+        if (!isSpotifyUrl(url)) {
+            setInvalidUrl(url);
+            setShowInvalidUrlDialog(true);
+            return;
+        }
+        onFetch();
+    };
     const handleResultClick = (externalUrl: string) => {
         onSearchModeChange(false);
         onFetchUrl(externalUrl);
@@ -210,18 +437,23 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
         const seconds = Math.floor((ms % 60000) / 1000);
         return `${minutes}:${seconds.toString().padStart(2, "0")}`;
     };
-    const hasAnyResults = searchResults && (searchResults.tracks.length > 0 ||
-        searchResults.albums.length > 0 ||
-        searchResults.artists.length > 0 ||
-        searchResults.playlists.length > 0);
+    const hasAnyResults = searchResults &&
+        (searchResults.tracks.length > 0 ||
+            searchResults.albums.length > 0 ||
+            searchResults.artists.length > 0 ||
+            searchResults.playlists.length > 0);
     const getTabCount = (tab: ResultTab): number => {
         if (!searchResults)
             return 0;
         switch (tab) {
-            case "tracks": return searchResults.tracks.length;
-            case "albums": return searchResults.albums.length;
-            case "artists": return searchResults.artists.length;
-            case "playlists": return searchResults.playlists.length;
+            case "tracks":
+                return searchResults.tracks.length;
+            case "albums":
+                return searchResults.albums.length;
+            case "artists":
+                return searchResults.artists.length;
+            case "playlists":
+                return searchResults.playlists.length;
         }
     };
     const tabs: {
@@ -234,167 +466,201 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
         { key: "playlists", label: "Playlists" },
     ];
     return (<div className="space-y-4">
-            <div className="flex gap-2">
-                <Tooltip>
-                    <TooltipTrigger asChild>
-                        <Button variant="outline" size="icon" className="shrink-0" onClick={() => onSearchModeChange(!searchMode)}>
-                            {searchMode ? <Link className="h-4 w-4"/> : <Search className="h-4 w-4"/>}
-                        </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>
-                        <p>{searchMode ? "Fetch Mode" : "Search Mode"}</p>
-                    </TooltipContent>
-                </Tooltip>
+      <div className="flex gap-2">
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button variant="outline" size="icon" className="shrink-0" onClick={() => onSearchModeChange(!searchMode)}>
+              {searchMode ? (<Link className="h-4 w-4"/>) : (<Search className="h-4 w-4"/>)}
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>
+            <p>{searchMode ? "Fetch Mode" : "Search Mode"}</p>
+          </TooltipContent>
+        </Tooltip>
 
-                <div className="relative flex-1">
-                    {!searchMode ? (<>
-                            <InputWithContext id="spotify-url" placeholder={placeholderText} value={url} onChange={(e) => onUrlChange(e.target.value)} onKeyDown={(e) => e.key === "Enter" && onFetch()} className="pr-8"/>
-                            {url && (<button type="button" className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors cursor-pointer" onClick={() => onUrlChange("")}>
-                                    <XCircle className="h-4 w-4"/>
-                                </button>)}
-                        </>) : (<>
-                            <InputWithContext id="spotify-search" placeholder={placeholderText} value={searchQuery} onChange={(e) => setSearchQuery(e.target.value)} className="pr-8"/>
-                            {searchQuery && (<button type="button" className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors cursor-pointer" onClick={() => {
+        <div className="relative flex-1">
+          {!searchMode ? (<>
+              <InputWithContext id="spotify-url" placeholder={placeholderText} value={url} onChange={(e) => onUrlChange(e.target.value)} onPaste={handlePaste} onKeyDown={(e) => e.key === "Enter" && handleFetchWithValidation()} className="pr-8"/>
+              {url && (<button type="button" className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors cursor-pointer" onClick={() => onUrlChange("")}>
+                  <XCircle className="h-4 w-4"/>
+                </button>)}
+            </>) : (<>
+              <InputWithContext id="spotify-search" placeholder={placeholderText} value={searchQuery} onChange={(e) => setSearchQuery(e.target.value)} className="pr-8"/>
+              {searchQuery && (<button type="button" className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors cursor-pointer" onClick={() => {
                     setSearchQuery("");
                     setSearchResults(null);
                     setLastSearchedQuery("");
                 }}>
-                                    <XCircle className="h-4 w-4"/>
-                                </button>)}
-                        </>)}
-                </div>
+                  <XCircle className="h-4 w-4"/>
+                </button>)}
+            </>)}
+        </div>
 
-                {!searchMode && (<>
-                        <Select value={region} onValueChange={onRegionChange}>
-                            <SelectTrigger className="w-[70px] shrink-0">
-                                <SelectValue placeholder="Region"/>
-                            </SelectTrigger>
-                            <SelectContent className="max-h-[300px]">
-                                {REGIONS.map((r) => (<SelectItem key={r} value={r} textValue={r}>
-                                        {r} <span className="text-muted-foreground">({getRegionName(r)})</span>
-                                    </SelectItem>))}
-                            </SelectContent>
-                        </Select>
-                        <Button onClick={onFetch} disabled={loading}>
-                            {loading ? (<>
-                                    <Spinner />
-                                    Fetching...
-                                </>) : (<>
-                                    <CloudDownload className="h-4 w-4"/>
-                                    Fetch
-                                </>)}
-                        </Button>
-                    </>)}
-            </div>
+        {!searchMode && (<>
+            <Select value={region} onValueChange={onRegionChange}>
+              <SelectTrigger className="w-[70px] shrink-0">
+                <SelectValue placeholder="Region"/>
+              </SelectTrigger>
+              <SelectContent className="max-h-[300px]">
+                {REGIONS.map((r) => (<SelectItem key={r} value={r} textValue={r}>
+                    {r}{" "}
+                    <span className="text-muted-foreground">
+                      ({getRegionName(r)})
+                    </span>
+                  </SelectItem>))}
+              </SelectContent>
+            </Select>
+            <Button onClick={handleFetchWithValidation} disabled={loading}>
+              {loading ? (<>
+                  <Spinner />
+                  Fetching...
+                </>) : (<>
+                  <CloudDownload className="h-4 w-4"/>
+                  Fetch
+                </>)}
+            </Button>
+          </>)}
+      </div>
 
-            {!searchMode && !hasResult && (<FetchHistory history={history} onSelect={onHistorySelect} onRemove={onHistoryRemove}/>)}
+      {!searchMode && !hasResult && (<FetchHistory history={history} onSelect={onHistorySelect} onRemove={onHistoryRemove}/>)}
 
-            {searchMode && (<div className="space-y-4">
-                    {!searchQuery && !searchResults && recentSearches.length > 0 && (<div className="space-y-2">
-                            <p className="text-sm text-muted-foreground">Recent Searches</p>
-                            <div className="flex flex-wrap gap-2">
-                                {recentSearches.map((query) => (<div key={query} className="group relative flex items-center px-3 py-1.5 bg-muted hover:bg-accent rounded-full text-sm cursor-pointer transition-colors" onClick={() => setSearchQuery(query)}>
-                                        <span>{query}</span>
-                                        <button type="button" className="absolute -top-1.5 -right-1.5 z-10 w-5 h-5 rounded-full bg-red-500 hover:bg-red-600 flex items-center justify-center opacity-0 group-hover:opacity-100 transition-all cursor-pointer shadow-sm" onClick={(e) => {
+      {searchMode && (<div className="space-y-4">
+          {!searchQuery && !searchResults && recentSearches.length > 0 && (<div className="space-y-2">
+              <p className="text-sm text-muted-foreground">Recent Searches</p>
+              <div className="flex flex-wrap gap-2">
+                {recentSearches.map((query) => (<div key={query} className="group relative flex items-center px-3 py-1.5 bg-muted hover:bg-accent rounded-full text-sm cursor-pointer transition-colors" onClick={() => setSearchQuery(query)}>
+                    <span>{query}</span>
+                    <button type="button" className="absolute -top-1.5 -right-1.5 z-10 w-5 h-5 rounded-full bg-red-500 hover:bg-red-600 flex items-center justify-center opacity-0 group-hover:opacity-100 transition-all cursor-pointer shadow-sm" onClick={(e) => {
                         e.stopPropagation();
                         removeRecentSearch(query);
                     }}>
-                                            <X className="h-3 w-3 text-red-900" strokeWidth={3}/>
-                                        </button>
-                                    </div>))}
-                            </div>
-                        </div>)}
+                      <X className="h-3 w-3 text-red-900" strokeWidth={3}/>
+                    </button>
+                  </div>))}
+              </div>
+            </div>)}
 
-                    {isSearching && (<div className="flex items-center justify-center py-8">
-                            <Spinner />
-                            <span className="ml-2 text-muted-foreground">Searching...</span>
-                        </div>)}
+          {isSearching && (<div className="flex items-center justify-center py-8">
+              <Spinner />
+              <span className="ml-2 text-muted-foreground">Searching...</span>
+            </div>)}
 
-                    {!isSearching && searchQuery && !hasAnyResults && (<div className="text-center py-8 text-muted-foreground">
-                            No results found for "{searchQuery}"
-                        </div>)}
+          {!isSearching && searchQuery && !hasAnyResults && (<div className="text-center py-8 text-muted-foreground">
+              No results found for "{searchQuery}"
+            </div>)}
 
-                    {!isSearching && hasAnyResults && (<>
-                            <div className="flex gap-1 border-b">
-                                {tabs.map((tab) => {
+          {!isSearching && hasAnyResults && (<>
+              <div className="flex gap-1 border-b">
+                {tabs.map((tab) => {
                     const count = getTabCount(tab.key);
                     if (count === 0)
                         return null;
                     return (<button key={tab.key} type="button" onClick={() => setActiveTab(tab.key)} className={cn("px-4 py-2 text-sm font-medium transition-colors cursor-pointer border-b-2 -mb-px", activeTab === tab.key
                             ? "border-primary text-foreground"
                             : "border-transparent text-muted-foreground hover:text-foreground")}>
-                                            {tab.label} ({count})
-                                        </button>);
+                      {tab.label} ({count})
+                    </button>);
                 })}
-                            </div>
+              </div>
 
-                            <div className="grid gap-2">
-                                {activeTab === "tracks" &&
+              <div className="grid gap-2">
+                {activeTab === "tracks" &&
                     searchResults?.tracks.map((track) => (<button key={track.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(track.external_urls)}>
-                                            {track.images ? (<img src={track.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
-                                            <div className="flex-1 min-w-0">
-                                                <div className="flex items-center gap-1.5 min-w-0">
-                                                    <p className="font-medium truncate">{track.name}</p>
-                                                    {track.is_explicit && (<span className="flex items-center justify-center min-w-[16px] h-[16px] rounded bg-red-600 text-[10px] font-bold text-white leading-none shrink-0" title="Explicit">
-                                                            E
-                                                        </span>)}
-                                                </div>
-                                                <p className="text-sm text-muted-foreground truncate">
-                                                    {track.artists}
-                                                </p>
-                                            </div>
-                                            <span className="text-sm text-muted-foreground shrink-0">
-                                                {formatDuration(track.duration_ms || 0)}
-                                            </span>
-                                        </button>))}
+                      {track.images ? (<img src={track.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
+                      <div className="flex-1 min-w-0">
+                        <div className="flex items-center gap-1.5 min-w-0">
+                          <p className="font-medium truncate">{track.name}</p>
+                          {track.is_explicit && (<span className="flex items-center justify-center min-w-[16px] h-[16px] rounded bg-red-600 text-[10px] font-bold text-white leading-none shrink-0" title="Explicit">
+                              E
+                            </span>)}
+                        </div>
+                        <p className="text-sm text-muted-foreground truncate">
+                          {track.artists}
+                        </p>
+                      </div>
+                      <span className="text-sm text-muted-foreground shrink-0">
+                        {formatDuration(track.duration_ms || 0)}
+                      </span>
+                    </button>))}
 
-                                {activeTab === "albums" &&
+                {activeTab === "albums" &&
                     searchResults?.albums.map((album) => (<button key={album.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(album.external_urls)}>
-                                            {album.images ? (<img src={album.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
-                                            <div className="flex-1 min-w-0">
-                                                <p className="font-medium truncate">{album.name}</p>
-                                                <p className="text-sm text-muted-foreground truncate">
-                                                    {album.artists}
-                                                </p>
-                                            </div>
-                                            <span className="text-sm text-muted-foreground shrink-0">
-                                                {album.release_date || ""}
-                                            </span>
-                                        </button>))}
+                      {album.images ? (<img src={album.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
+                      <div className="flex-1 min-w-0">
+                        <p className="font-medium truncate">{album.name}</p>
+                        <p className="text-sm text-muted-foreground truncate">
+                          {album.artists}
+                        </p>
+                      </div>
+                      <span className="text-sm text-muted-foreground shrink-0">
+                        {album.release_date || ""}
+                      </span>
+                    </button>))}
 
-                                {activeTab === "artists" &&
+                {activeTab === "artists" &&
                     searchResults?.artists.map((artist) => (<button key={artist.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(artist.external_urls)}>
-                                            {artist.images ? (<img src={artist.images} alt="" className="w-12 h-12 rounded-full object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded-full bg-muted shrink-0"/>)}
-                                            <div className="flex-1 min-w-0">
-                                                <p className="font-medium truncate">{artist.name}</p>
-                                                <p className="text-sm text-muted-foreground">Artist</p>
-                                            </div>
-                                        </button>))}
+                      {artist.images ? (<img src={artist.images} alt="" className="w-12 h-12 rounded-full object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded-full bg-muted shrink-0"/>)}
+                      <div className="flex-1 min-w-0">
+                        <p className="font-medium truncate">{artist.name}</p>
+                        <p className="text-sm text-muted-foreground">Artist</p>
+                      </div>
+                    </button>))}
 
-                                {activeTab === "playlists" &&
+                {activeTab === "playlists" &&
                     searchResults?.playlists.map((playlist) => (<button key={playlist.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(playlist.external_urls)}>
-                                            {playlist.images ? (<img src={playlist.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
-                                            <div className="flex-1 min-w-0">
-                                                <p className="font-medium truncate">{playlist.name}</p>
-                                                <p className="text-sm text-muted-foreground truncate">
-                                                    {playlist.owner || ""}
-                                                </p>
-                                            </div>
-                                        </button>))}
-                            </div>
+                      {playlist.images ? (<img src={playlist.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
+                      <div className="flex-1 min-w-0">
+                        <p className="font-medium truncate">{playlist.name}</p>
+                        <p className="text-sm text-muted-foreground truncate">
+                          {playlist.owner || ""}
+                        </p>
+                      </div>
+                    </button>))}
+              </div>
 
-                            {hasMore[activeTab] && (<div className="flex justify-center pt-2">
-                                    <Button variant="outline" onClick={handleLoadMore} disabled={isLoadingMore}>
-                                        {isLoadingMore ? (<>
-                                                <Spinner />
-                                                Loading...
-                                            </>) : (<>
-                                                <ChevronDown className="h-4 w-4"/>
-                                                Load More
-                                            </>)}
-                                    </Button>
-                                </div>)}
-                        </>)}
+              {hasMore[activeTab] && (<div className="flex justify-center pt-2">
+                  <Button variant="outline" onClick={handleLoadMore} disabled={isLoadingMore}>
+                    {isLoadingMore ? (<>
+                        <Spinner />
+                        Loading...
+                      </>) : (<>
+                        <ChevronDown className="h-4 w-4"/>
+                        Load More
+                      </>)}
+                  </Button>
                 </div>)}
-        </div>);
+            </>)}
+        </div>)}
+
+      <Dialog open={showInvalidUrlDialog} onOpenChange={setShowInvalidUrlDialog}>
+        <DialogContent className="sm:max-w-[425px]">
+          <DialogHeader>
+            <DialogTitle>Invalid URL</DialogTitle>
+            <DialogDescription>
+              Only Spotify links are allowed in Fetch mode.
+            </DialogDescription>
+          </DialogHeader>
+
+          {invalidUrl && (<div className="p-3 bg-muted rounded-md border text-xs font-mono break-all opacity-70">
+              {invalidUrl}
+            </div>)}
+
+          <DialogFooter>
+            <Button variant="outline" onClick={() => {
+            setShowInvalidUrlDialog(false);
+            setInvalidUrl("");
+        }}>
+              Cancel
+            </Button>
+            <Button onClick={() => {
+            onSearchModeChange(true);
+            setShowInvalidUrlDialog(false);
+            setInvalidUrl("");
+        }}>
+              Switch to Search
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>);
 }

frontend/src/components/Sidebar.tsx

@@ -17,108 +17,106 @@ interface SidebarProps {
 }
 export function Sidebar({ currentPage, onPageChange }: SidebarProps) {
     return (<div className="fixed left-0 top-0 h-full w-14 bg-card border-r border-border flex flex-col items-center py-14 z-30">
-    <div className="flex flex-col gap-2 flex-1">
+      <div className="flex flex-col gap-2 flex-1">
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant={currentPage === "main" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "main" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("main")}>
+              <HomeIcon size={20}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>Home</p>
+          </TooltipContent>
+        </Tooltip>
 
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant={currentPage === "main" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "main" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("main")}>
-            <HomeIcon size={20}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>Home</p>
-        </TooltipContent>
-      </Tooltip>
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant={currentPage === "history" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "history" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("history")}>
+              <HistoryIcon size={20}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>History</p>
+          </TooltipContent>
+        </Tooltip>
 
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant={currentPage === "history" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "history" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("history")}>
-            <HistoryIcon size={20}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>History</p>
-        </TooltipContent>
-      </Tooltip>
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant={currentPage === "audio-analysis" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "audio-analysis" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("audio-analysis")}>
+              <ActivityIcon size={20}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>Audio Quality Analyzer</p>
+          </TooltipContent>
+        </Tooltip>
 
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant={currentPage === "audio-analysis" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "audio-analysis" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("audio-analysis")}>
-            <ActivityIcon size={20}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>Audio Quality Analyzer</p>
-        </TooltipContent>
-      </Tooltip>
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant={currentPage === "audio-converter" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "audio-converter" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("audio-converter")}>
+              <FileMusicIcon size={20}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>Audio Converter</p>
+          </TooltipContent>
+        </Tooltip>
 
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant={currentPage === "audio-converter" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "audio-converter" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("audio-converter")}>
-            <FileMusicIcon size={20}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>Audio Converter</p>
-        </TooltipContent>
-      </Tooltip>
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant={currentPage === "file-manager" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "file-manager" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("file-manager")}>
+              <FilePenIcon size={20}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>File Manager</p>
+          </TooltipContent>
+        </Tooltip>
 
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant={currentPage === "file-manager" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "file-manager" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("file-manager")}>
-            <FilePenIcon size={20}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>File Manager</p>
-        </TooltipContent>
-      </Tooltip>
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant={currentPage === "debug" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "debug" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("debug")}>
+              <TerminalIcon size={20} loop={true}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>Debug Logs</p>
+          </TooltipContent>
+        </Tooltip>
 
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant={currentPage === "debug" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "debug" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("debug")}>
-            <TerminalIcon size={20} loop={true}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>Debug Logs</p>
-        </TooltipContent>
-      </Tooltip>
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant={currentPage === "settings" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "settings" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("settings")}>
+              <SettingsIcon size={20}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>Settings</p>
+          </TooltipContent>
+        </Tooltip>
+      </div>
 
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant={currentPage === "settings" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "settings" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("settings")}>
-            <SettingsIcon size={20}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>Settings</p>
-        </TooltipContent>
-      </Tooltip>
-    </div>
-
-
-    <div className="mt-auto flex flex-col gap-2">
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant={currentPage === "about" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "about" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("about")}>
-            <BadgeAlertIcon size={20}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>About</p>
-        </TooltipContent>
-      </Tooltip>
-      <Tooltip delayDuration={0}>
-        <TooltipTrigger asChild>
-          <Button variant="ghost" size="icon" className="h-10 w-10 hover:bg-primary/10 hover:text-primary" onClick={() => openExternal("https://ko-fi.com/afkarxyz")}>
-            <CoffeeIcon size={20} loop={true}/>
-          </Button>
-        </TooltipTrigger>
-        <TooltipContent side="right">
-          <p>Every coffee helps me keep going</p>
-        </TooltipContent>
-      </Tooltip>
-    </div>
-  </div>);
+      <div className="mt-auto flex flex-col gap-2">
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant={currentPage === "about" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "about" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("about")}>
+              <BadgeAlertIcon size={20}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>About</p>
+          </TooltipContent>
+        </Tooltip>
+        <Tooltip delayDuration={0}>
+          <TooltipTrigger asChild>
+            <Button variant="ghost" size="icon" className="h-10 w-10 hover:bg-primary/10 hover:text-primary" onClick={() => openExternal("https://ko-fi.com/afkarxyz")}>
+              <CoffeeIcon size={20} loop={true}/>
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            <p>Support me on Ko-fi</p>
+          </TooltipContent>
+        </Tooltip>
+      </div>
+    </div>);
 }

frontend/src/components/TitleBar.tsx

@@ -1,6 +1,30 @@
-import { X, Minus, Maximize } from "lucide-react";
+import { X, Minus, Maximize, Settings, Info } from "lucide-react";
 import { WindowMinimise, WindowToggleMaximise, Quit } from "../../wailsjs/runtime/runtime";
+import { Menubar, MenubarContent, MenubarMenu, MenubarItem, MenubarTrigger, MenubarLabel, MenubarSeparator } from "@/components/ui/menubar";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
+import { getSettings, updateSettings } from "@/lib/settings";
+import { useState, useEffect } from "react";
 export function TitleBar() {
+    const [useSpotFetchAPI, setUseSpotFetchAPI] = useState(false);
+    useEffect(() => {
+        const settings = getSettings();
+        if (settings) {
+            setUseSpotFetchAPI(settings.useSpotFetchAPI || false);
+        }
+        const handleSettingsUpdate = (event: any) => {
+            const updatedSettings = event.detail;
+            if (updatedSettings && typeof updatedSettings.useSpotFetchAPI !== 'undefined') {
+                setUseSpotFetchAPI(updatedSettings.useSpotFetchAPI);
+            }
+        };
+        window.addEventListener('settingsUpdated', handleSettingsUpdate);
+        return () => window.removeEventListener('settingsUpdated', handleSettingsUpdate);
+    }, []);
+    const handleSpotFetchAPIToggle = () => {
+        const newValue = !useSpotFetchAPI;
+        setUseSpotFetchAPI(newValue);
+        updateSettings({ useSpotFetchAPI: newValue });
+    };
     const handleMinimize = () => {
         WindowMinimise();
     };
@@ -15,7 +39,35 @@ export function TitleBar() {
       <div className="fixed top-0 left-14 right-0 h-10 z-40 bg-background/80 backdrop-blur-sm" style={{ "--wails-draggable": "drag" } as React.CSSProperties} onDoubleClick={handleMaximize}/>
 
 
-      <div className="fixed top-1.5 right-2 z-50 flex h-7 gap-0.5">
+      <div className="fixed top-1.5 right-2 z-50 flex h-7 gap-0.5 items-center">
+        <Menubar className="border-none bg-transparent shadow-none px-0 mr-1" style={{ "--wails-draggable": "no-drag" } as React.CSSProperties}>
+            <MenubarMenu>
+                <MenubarTrigger className="cursor-pointer w-8 h-7 p-0 flex items-center justify-center hover:bg-muted transition-colors rounded data-[state=open]:bg-muted">
+                    <Settings className="w-3.5 h-3.5"/>
+                </MenubarTrigger>
+                <MenubarContent align="end" className="min-w-[200px]">
+                    <div className="flex items-center gap-1.5 px-2 py-1.5">
+                        <MenubarLabel className="p-0">SpotFetch API</MenubarLabel>
+                        <TooltipProvider delayDuration={300}>
+                            <Tooltip>
+                                <TooltipTrigger asChild>
+                                    <Info className="w-3.5 h-3.5 cursor-help text-muted-foreground"/>
+                                </TooltipTrigger>
+                                <TooltipContent side="left" className="max-w-xs">
+                                    <p className="font-semibold mb-2">Spotify Blocked Countries:</p>
+                                    <p className="text-xs">Afghanistan, Antarctica, Central African Republic, China, Cuba, Eritrea, Iran, Myanmar, North Korea, Russia, Somalia, South Sudan, Sudan, Syria, Turkmenistan, Yemen</p>
+                                </TooltipContent>
+                            </Tooltip>
+                        </TooltipProvider>
+                    </div>
+                    <MenubarSeparator />
+                    <MenubarItem onClick={handleSpotFetchAPIToggle} className="justify-between">
+                        <span>Use SpotFetch API</span>
+                        <span className="ml-4">{useSpotFetchAPI ? "✓" : ""}</span>
+                    </MenubarItem>
+                </MenubarContent>
+            </MenubarMenu>
+        </Menubar>
         <button onClick={handleMinimize} className="w-8 h-7 flex items-center justify-center hover:bg-muted transition-colors rounded" style={{ "--wails-draggable": "no-drag" } as React.CSSProperties} aria-label="Minimize">
           <Minus className="w-3.5 h-3.5"/>
         </button>

frontend/src/components/TrackInfo.tsx

@@ -4,7 +4,7 @@ import { Download, FolderOpen, CheckCircle, XCircle, FileText, FileCheck, Globe,
 import { Spinner } from "@/components/ui/spinner";
 import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip";
 import type { TrackMetadata, TrackAvailability } from "@/types/api";
-import { TidalIcon, QobuzIcon, AmazonIcon } from "./PlatformIcons";
+import { TidalIcon, QobuzIcon, AmazonIcon, DeezerIcon } from "./PlatformIcons";
 import { usePreview } from "@/hooks/usePreview";
 interface TrackInfoProps {
     track: TrackMetadata & {
@@ -26,9 +26,9 @@ interface TrackInfoProps {
     downloadedCover?: boolean;
     failedCover?: boolean;
     skippedCover?: boolean;
-    onDownload: (isrc: string, name: string, artists: string, albumName?: string, spotifyId?: string, playlistName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
+    onDownload: (id: string, name: string, artists: string, albumName?: string, spotifyId?: string, playlistName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
     onDownloadLyrics?: (spotifyId: string, name: string, artists: string, albumName?: string, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
-    onCheckAvailability?: (spotifyId: string, isrc?: string) => void;
+    onCheckAvailability?: (spotifyId: string) => void;
     onDownloadCover?: (coverUrl: string, trackName: string, artistName: string, albumName?: string, playlistName?: string, position?: number, trackId?: string, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
     onOpenFolder: () => void;
     onBack?: () => void;
@@ -95,9 +95,9 @@ export function TrackInfo({ track, isDownloading, downloadingTrack, isDownloaded
               </div>)}
             </div>
           </div>
-          {track.isrc && (<div className="flex gap-2 flex-wrap">
-            <Button onClick={() => onDownload(track.isrc, track.name, track.artists, track.album_name, track.spotify_id, undefined, track.duration_ms, track.track_number, track.album_artist, track.release_date, track.images, track.track_number, track.disc_number, track.total_tracks, track.total_discs, track.copyright, track.publisher)} disabled={isDownloading || downloadingTrack === track.isrc}>
-              {downloadingTrack === track.isrc ? (<Spinner />) : (<>
+          {track.spotify_id && (<div className="flex gap-2 flex-wrap">
+            <Button onClick={() => onDownload(track.spotify_id || "", track.name, track.artists, track.album_name, track.spotify_id, undefined, track.duration_ms, track.track_number, track.album_artist, track.release_date, track.images, track.track_number, track.disc_number, track.total_tracks, track.total_discs, track.copyright, track.publisher)} disabled={isDownloading || downloadingTrack === track.spotify_id}>
+              {downloadingTrack === track.spotify_id ? (<Spinner />) : (<>
                 <Download className="h-4 w-4"/>
                 Download
               </>)}
@@ -134,7 +134,7 @@ export function TrackInfo({ track, isDownloading, downloadingTrack, isDownloaded
             </Tooltip>)}
             {track.spotify_id && onCheckAvailability && (<Tooltip>
               <TooltipTrigger asChild>
-                <Button onClick={() => onCheckAvailability(track.spotify_id!, track.isrc)} variant="outline" size="icon" disabled={checkingAvailability}>
+                <Button onClick={() => onCheckAvailability(track.spotify_id!)} variant="outline" size="icon" disabled={checkingAvailability}>
                   {checkingAvailability ? (<Spinner />) : availability ? (<CheckCircle className="h-4 w-4 text-green-500"/>) : (<Globe className="h-4 w-4"/>)}
                 </Button>
               </TooltipTrigger>
@@ -143,6 +143,7 @@ export function TrackInfo({ track, isDownloading, downloadingTrack, isDownloaded
                   <TidalIcon className={`w-4 h-4 ${availability.tidal ? "text-green-500" : "text-red-500"}`}/>
                   <QobuzIcon className={`w-4 h-4 ${availability.qobuz ? "text-green-500" : "text-red-500"}`}/>
                   <AmazonIcon className={`w-4 h-4 ${availability.amazon ? "text-green-500" : "text-red-500"}`}/>
+                  <DeezerIcon className={`w-4 h-4 ${availability.deezer ? "text-green-500" : "text-red-500"}`}/>
                 </div>) : (<p>Check Availability</p>)}
               </TooltipContent>
             </Tooltip>)}

frontend/src/components/TrackList.tsx

@@ -5,7 +5,7 @@ import { Spinner } from "@/components/ui/spinner";
 import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip";
 import { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, } from "@/components/ui/pagination";
 import type { TrackMetadata, TrackAvailability } from "@/types/api";
-import { TidalIcon, QobuzIcon, AmazonIcon } from "./PlatformIcons";
+import { TidalIcon, QobuzIcon, AmazonIcon, DeezerIcon } from "./PlatformIcons";
 import { usePreview } from "@/hooks/usePreview";
 interface TrackListProps {
     tracks: TrackMetadata[];
@@ -33,11 +33,11 @@ interface TrackListProps {
     failedCovers?: Set<string>;
     skippedCovers?: Set<string>;
     downloadingCoverTrack?: string | null;
-    onToggleTrack: (isrc: string) => void;
+    onToggleTrack: (id: string) => void;
     onToggleSelectAll: (tracks: TrackMetadata[]) => void;
-    onDownloadTrack: (isrc: string, name: string, artists: string, albumName: string, spotifyId?: string, folderName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
+    onDownloadTrack: (id: string, name: string, artists: string, albumName: string, spotifyId?: string, folderName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => void;
     onDownloadLyrics?: (spotifyId: string, name: string, artists: string, albumName: string, folderName?: string, isArtistDiscography?: boolean, position?: number, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
-    onCheckAvailability?: (spotifyId: string, isrc?: string) => void;
+    onCheckAvailability?: (spotifyId: string) => void;
     onDownloadCover?: (coverUrl: string, trackName: string, artistName: string, albumName: string, folderName?: string, isArtistDiscography?: boolean, position?: number, trackId?: string, albumArtist?: string, releaseDate?: string, discNumber?: number) => void;
     onPageChange: (page: number) => void;
     onAlbumClick?: (album: {
@@ -104,18 +104,25 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
     }
     else if (sortBy === "downloaded") {
         filteredTracks = [...filteredTracks].sort((a, b) => {
-            const aDownloaded = downloadedTracks.has(a.isrc);
-            const bDownloaded = downloadedTracks.has(b.isrc);
+            const aDownloaded = a.spotify_id ? downloadedTracks.has(a.spotify_id) : false;
+            const bDownloaded = b.spotify_id ? downloadedTracks.has(b.spotify_id) : false;
             return (bDownloaded ? 1 : 0) - (aDownloaded ? 1 : 0);
         });
     }
     else if (sortBy === "not-downloaded") {
         filteredTracks = [...filteredTracks].sort((a, b) => {
-            const aDownloaded = downloadedTracks.has(a.isrc);
-            const bDownloaded = downloadedTracks.has(b.isrc);
+            const aDownloaded = a.spotify_id ? downloadedTracks.has(a.spotify_id) : false;
+            const bDownloaded = b.spotify_id ? downloadedTracks.has(b.spotify_id) : false;
             return (aDownloaded ? 1 : 0) - (bDownloaded ? 1 : 0);
         });
     }
+    else if (sortBy === "failed") {
+        filteredTracks = [...filteredTracks].sort((a, b) => {
+            const aFailed = a.spotify_id ? failedTracks.has(a.spotify_id) : false;
+            const bFailed = b.spotify_id ? failedTracks.has(b.spotify_id) : false;
+            return (bFailed ? 1 : 0) - (aFailed ? 1 : 0);
+        });
+    }
     const totalPages = Math.ceil(filteredTracks.length / itemsPerPage);
     const startIndex = (currentPage - 1) * itemsPerPage;
     const endIndex = startIndex + itemsPerPage;
@@ -149,9 +156,9 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
         }
         return pages;
     };
-    const tracksWithIsrc = filteredTracks.filter((track) => track.isrc);
-    const allSelected = tracksWithIsrc.length > 0 &&
-        tracksWithIsrc.every((track) => selectedTracks.includes(track.isrc));
+    const tracksWithId = filteredTracks.filter((track) => track.spotify_id);
+    const allSelected = tracksWithId.length > 0 &&
+        tracksWithId.every((track) => selectedTracks.includes(track.spotify_id!));
     const formatDuration = (ms: number) => {
         const minutes = Math.floor(ms / 60000);
         const seconds = Math.floor((ms % 60000) / 1000);
@@ -197,7 +204,7 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
           <tbody>
             {paginatedTracks.map((track, index) => (<tr key={index} className="border-b transition-colors hover:bg-muted/50">
               {showCheckboxes && (<td className="p-4 align-middle">
-                {track.isrc && (<Checkbox checked={selectedTracks.includes(track.isrc)} onCheckedChange={() => onToggleTrack(track.isrc)}/>)}
+                {track.spotify_id && (<Checkbox checked={selectedTracks.includes(track.spotify_id)} onCheckedChange={() => onToggleTrack(track.spotify_id!)}/>)}
               </td>)}
               <td className="p-4 align-middle text-sm text-muted-foreground">
                 <div className="flex flex-col items-center gap-0.5">
@@ -223,7 +230,7 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
                       </span>) : (<span className="font-medium">{track.name}</span>)}
                       {track.is_explicit && (<span className="inline-flex items-center justify-center bg-red-600 text-white text-[10px] h-4 w-4 rounded shrink-0" title="Explicit">E</span>)}
 
-                      {skippedTracks.has(track.isrc) ? (<FileCheck className="h-4 w-4 text-yellow-500 shrink-0"/>) : downloadedTracks.has(track.isrc) ? (<CheckCircle className="h-4 w-4 text-green-500 shrink-0"/>) : failedTracks.has(track.isrc) ? (<XCircle className="h-4 w-4 text-red-500 shrink-0"/>) : null}
+                      {track.spotify_id && skippedTracks.has(track.spotify_id) ? (<FileCheck className="h-4 w-4 text-yellow-500 shrink-0"/>) : track.spotify_id && downloadedTracks.has(track.spotify_id) ? (<CheckCircle className="h-4 w-4 text-green-500 shrink-0"/>) : track.spotify_id && failedTracks.has(track.spotify_id) ? (<XCircle className="h-4 w-4 text-red-500 shrink-0"/>) : null}
                     </div>
                     <span className="text-sm text-muted-foreground">
                       {track.artists_data && track.artists_data.length > 0 ? ((() => {
@@ -270,14 +277,14 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
               </td>
               <td className="p-4 align-middle text-center">
                 <div className="flex items-center justify-center gap-1">
-                  {track.isrc && (<Tooltip>
+                  {track.spotify_id && (<Tooltip>
                     <TooltipTrigger asChild>
-                      <Button onClick={() => onDownloadTrack(track.isrc, track.name, track.artists, track.album_name, track.spotify_id, folderName, track.duration_ms, startIndex + index + 1, track.album_artist, track.release_date, track.images, track.track_number, track.disc_number, track.total_tracks, track.total_discs, track.copyright, track.publisher)} size="icon" disabled={isDownloading || downloadingTrack === track.isrc}>
-                        {downloadingTrack === track.isrc ? (<Spinner />) : skippedTracks.has(track.isrc) ? (<FileCheck className="h-4 w-4"/>) : downloadedTracks.has(track.isrc) ? (<CheckCircle className="h-4 w-4"/>) : failedTracks.has(track.isrc) ? (<XCircle className="h-4 w-4"/>) : (<Download className="h-4 w-4"/>)}
+                      <Button onClick={() => onDownloadTrack(track.spotify_id!, track.name, track.artists, track.album_name, track.spotify_id, folderName, track.duration_ms, startIndex + index + 1, track.album_artist, track.release_date, track.images, track.track_number, track.disc_number, track.total_tracks, track.total_discs, track.copyright, track.publisher)} size="icon" disabled={isDownloading || downloadingTrack === track.spotify_id}>
+                        {downloadingTrack === track.spotify_id ? (<Spinner />) : skippedTracks.has(track.spotify_id) ? (<FileCheck className="h-4 w-4"/>) : downloadedTracks.has(track.spotify_id) ? (<CheckCircle className="h-4 w-4"/>) : failedTracks.has(track.spotify_id) ? (<XCircle className="h-4 w-4"/>) : (<Download className="h-4 w-4"/>)}
                       </Button>
                     </TooltipTrigger>
                     <TooltipContent>
-                      {downloadingTrack === track.isrc ? (<p>Downloading...</p>) : skippedTracks.has(track.isrc) ? (<p>Already exists</p>) : downloadedTracks.has(track.isrc) ? (<p>Downloaded</p>) : failedTracks.has(track.isrc) ? (<p>Failed</p>) : (<p>Download Track</p>)}
+                      {downloadingTrack === track.spotify_id ? (<p>Downloading...</p>) : skippedTracks.has(track.spotify_id) ? (<p>Already exists</p>) : downloadedTracks.has(track.spotify_id) ? (<p>Downloaded</p>) : failedTracks.has(track.spotify_id) ? (<p>Failed</p>) : (<p>Download Track</p>)}
                     </TooltipContent>
                   </Tooltip>)}
                   {track.spotify_id && (<Tooltip>
@@ -315,7 +322,7 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
                   </Tooltip>)}
                   {track.spotify_id && onCheckAvailability && (<Tooltip>
                     <TooltipTrigger asChild>
-                      <Button onClick={() => onCheckAvailability(track.spotify_id!, track.isrc)} size="icon" variant="outline" disabled={checkingAvailabilityTrack === track.spotify_id}>
+                      <Button onClick={() => onCheckAvailability(track.spotify_id!)} size="icon" variant="outline" disabled={checkingAvailabilityTrack === track.spotify_id}>
                         {checkingAvailabilityTrack === track.spotify_id ? (<Spinner />) : availabilityMap?.has(track.spotify_id) ? (<CheckCircle className="h-4 w-4 text-green-500"/>) : (<Globe className="h-4 w-4"/>)}
                       </Button>
                     </TooltipTrigger>
@@ -324,6 +331,7 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
                         <TidalIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.tidal ? "text-green-500" : "text-red-500"}`}/>
                         <QobuzIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.qobuz ? "text-green-500" : "text-red-500"}`}/>
                         <AmazonIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.amazon ? "text-green-500" : "text-red-500"}`}/>
+                        <DeezerIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.deezer ? "text-green-500" : "text-red-500"}`}/>
                       </div>) : (<p>Check Availability</p>)}
                     </TooltipContent>
                   </Tooltip>)}

frontend/src/components/ui/menubar.tsx

@@ -0,0 +1,60 @@
+"use client";
+import * as React from "react";
+import * as MenubarPrimitive from "@radix-ui/react-menubar";
+import { Check, ChevronRight, Circle } from "lucide-react";
+import { cn } from "@/lib/utils";
+const Menubar = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.Root>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Root>>(({ className, ...props }, ref) => (<MenubarPrimitive.Root ref={ref} className={cn("flex h-9 items-center space-x-1 rounded-md border bg-background p-1 shadow-sm", className)} {...props}/>));
+Menubar.displayName = MenubarPrimitive.Root.displayName;
+const MenubarMenu = MenubarPrimitive.Menu;
+const MenubarGroup = MenubarPrimitive.Group;
+const MenubarPortal = MenubarPrimitive.Portal;
+const MenubarSub = MenubarPrimitive.Sub;
+const MenubarRadioGroup = MenubarPrimitive.RadioGroup;
+const MenubarTrigger = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.Trigger>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Trigger>>(({ className, ...props }, ref) => (<MenubarPrimitive.Trigger ref={ref} className={cn("flex cursor-default select-none items-center rounded-sm px-3 py-1 text-sm font-medium outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground", className)} {...props}/>));
+MenubarTrigger.displayName = MenubarPrimitive.Trigger.displayName;
+const MenubarSubTrigger = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.SubTrigger>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubTrigger> & {
+    inset?: boolean;
+}>(({ className, inset, children, ...props }, ref) => (<MenubarPrimitive.SubTrigger ref={ref} className={cn("flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground", inset && "pl-8", className)} {...props}>
+    {children}
+    <ChevronRight className="ml-auto h-4 w-4"/>
+  </MenubarPrimitive.SubTrigger>));
+MenubarSubTrigger.displayName = MenubarPrimitive.SubTrigger.displayName;
+const MenubarSubContent = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.SubContent>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubContent>>(({ className, ...props }, ref) => (<MenubarPrimitive.SubContent ref={ref} className={cn("z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className)} {...props}/>));
+MenubarSubContent.displayName = MenubarPrimitive.SubContent.displayName;
+const MenubarContent = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.Content>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Content>>(({ className, align = "start", alignOffset = -4, sideOffset = 8, ...props }, ref) => (<MenubarPrimitive.Portal>
+    <MenubarPrimitive.Content ref={ref} align={align} alignOffset={alignOffset} sideOffset={sideOffset} className={cn("z-50 min-w-[12rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md animate-in slide-in-from-top-1", className)} {...props}/>
+  </MenubarPrimitive.Portal>));
+MenubarContent.displayName = MenubarPrimitive.Content.displayName;
+const MenubarItem = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.Item>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Item> & {
+    inset?: boolean;
+}>(({ className, inset, ...props }, ref) => (<MenubarPrimitive.Item ref={ref} className={cn("relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", inset && "pl-8", className)} {...props}/>));
+MenubarItem.displayName = MenubarPrimitive.Item.displayName;
+const MenubarCheckboxItem = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.CheckboxItem>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.CheckboxItem>>(({ className, children, checked, ...props }, ref) => (<MenubarPrimitive.CheckboxItem ref={ref} className={cn("relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className)} checked={checked} {...props}>
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <MenubarPrimitive.ItemIndicator>
+        <Check className="h-4 w-4"/>
+      </MenubarPrimitive.ItemIndicator>
+    </span>
+    {children}
+  </MenubarPrimitive.CheckboxItem>));
+MenubarCheckboxItem.displayName = MenubarPrimitive.CheckboxItem.displayName;
+const MenubarRadioItem = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.RadioItem>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.RadioItem>>(({ className, children, ...props }, ref) => (<MenubarPrimitive.RadioItem ref={ref} className={cn("relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className)} {...props}>
+    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
+      <MenubarPrimitive.ItemIndicator>
+        <Circle className="h-2 w-2 fill-current"/>
+      </MenubarPrimitive.ItemIndicator>
+    </span>
+    {children}
+  </MenubarPrimitive.RadioItem>));
+MenubarRadioItem.displayName = MenubarPrimitive.RadioItem.displayName;
+const MenubarLabel = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.Label>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Label> & {
+    inset?: boolean;
+}>(({ className, inset, ...props }, ref) => (<MenubarPrimitive.Label ref={ref} className={cn("px-2 py-1.5 text-sm font-semibold", inset && "pl-8", className)} {...props}/>));
+MenubarLabel.displayName = MenubarPrimitive.Label.displayName;
+const MenubarSeparator = React.forwardRef<React.ElementRef<typeof MenubarPrimitive.Separator>, React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Separator>>(({ className, ...props }, ref) => (<MenubarPrimitive.Separator ref={ref} className={cn("-mx-1 my-1 h-px bg-muted", className)} {...props}/>));
+MenubarSeparator.displayName = MenubarPrimitive.Separator.displayName;
+const MenubarShortcut = ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>) => {
+    return (<span className={cn("ml-auto text-xs tracking-widest text-muted-foreground", className)} {...props}/>);
+};
+MenubarShortcut.displayname = "MenubarShortcut";
+export { Menubar, MenubarMenu, MenubarTrigger, MenubarContent, MenubarItem, MenubarSeparator, MenubarLabel, MenubarCheckboxItem, MenubarRadioGroup, MenubarRadioItem, MenubarPortal, MenubarSubContent, MenubarSubTrigger, MenubarSub, MenubarGroup, MenubarShortcut, };

frontend/src/hooks/useAvailability.ts

@@ -7,7 +7,7 @@ export function useAvailability() {
     const [checkingTrackId, setCheckingTrackId] = useState<string | null>(null);
     const [availabilityMap, setAvailabilityMap] = useState<Map<string, TrackAvailability>>(new Map());
     const [error, setError] = useState<string | null>(null);
-    const checkAvailability = useCallback(async (spotifyId: string, isrc?: string) => {
+    const checkAvailability = useCallback(async (spotifyId: string) => {
         if (!spotifyId) {
             setError("No Spotify ID provided");
             return null;
@@ -20,7 +20,7 @@ export function useAvailability() {
         setError(null);
         try {
             logger.info(`Checking availability for track: ${spotifyId}`);
-            const response = await CheckTrackAvailability(spotifyId, isrc || "");
+            const response = await CheckTrackAvailability(spotifyId);
             const availability: TrackAvailability = JSON.parse(response);
             setAvailabilityMap((prev) => {
                 const newMap = new Map(prev);

frontend/src/hooks/useCover.ts

@@ -2,7 +2,7 @@ import { useState, useRef } from "react";
 import { downloadCover } from "@/lib/api";
 import { getSettings, parseTemplate, type TemplateData } from "@/lib/settings";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
-import { joinPath, sanitizePath } from "@/lib/utils";
+import { joinPath, sanitizePath, getFirstArtist } from "@/lib/utils";
 import { logger } from "@/lib/logger";
 import type { TrackMetadata } from "@/types/api";
 export function useCover() {
@@ -28,11 +28,17 @@ export function useCover() {
             const os = settings.operatingSystem;
             let outputDir = settings.downloadPath;
             const placeholder = "__SLASH_PLACEHOLDER__";
+            const yearValue = releaseDate?.substring(0, 4);
+            const displayArtist = settings.useFirstArtistOnly && artistName ? getFirstArtist(artistName) : artistName;
+            const displayAlbumArtist = settings.useFirstArtistOnly && albumArtist ? getFirstArtist(albumArtist) : albumArtist;
             const templateData: TemplateData = {
-                artist: artistName?.replace(/\//g, placeholder),
+                artist: displayArtist?.replace(/\//g, placeholder),
                 album: albumName?.replace(/\//g, placeholder),
+                album_artist: displayAlbumArtist?.replace(/\//g, placeholder) || displayArtist?.replace(/\//g, placeholder),
                 title: trackName?.replace(/\//g, placeholder),
                 track: position,
+                year: yearValue,
+                date: releaseDate,
                 playlist: playlistName?.replace(/\//g, placeholder),
             };
             const folderTemplate = settings.folderTemplate || "";
@@ -53,9 +59,9 @@ export function useCover() {
             const response = await downloadCover({
                 cover_url: coverUrl,
                 track_name: trackName,
-                artist_name: artistName,
+                artist_name: displayArtist,
                 album_name: albumName || "",
-                album_artist: albumArtist || "",
+                album_artist: displayAlbumArtist || "",
                 release_date: releaseDate || "",
                 output_dir: outputDir,
                 filename_format: settings.filenameTemplate || "{title}",
@@ -124,11 +130,17 @@ export function useCover() {
                 const placeholder = "__SLASH_PLACEHOLDER__";
                 const useAlbumTrackNumber = settings.folderTemplate?.includes("{album}") || false;
                 const trackPosition = useAlbumTrackNumber ? (track.track_number || i + 1) : (i + 1);
+                const yearValue = track.release_date?.substring(0, 4);
+                const displayArtist = settings.useFirstArtistOnly && track.artists ? getFirstArtist(track.artists) : track.artists;
+                const displayAlbumArtist = settings.useFirstArtistOnly && track.album_artist ? getFirstArtist(track.album_artist) : track.album_artist;
                 const templateData: TemplateData = {
-                    artist: track.artists?.replace(/\//g, placeholder),
+                    artist: displayArtist?.replace(/\//g, placeholder),
                     album: track.album_name?.replace(/\//g, placeholder),
+                    album_artist: displayAlbumArtist?.replace(/\//g, placeholder) || displayArtist?.replace(/\//g, placeholder),
                     title: track.name?.replace(/\//g, placeholder),
                     track: trackPosition,
+                    year: yearValue,
+                    date: track.release_date,
                     playlist: playlistName?.replace(/\//g, placeholder),
                 };
                 const folderTemplate = settings.folderTemplate || "";
@@ -149,9 +161,9 @@ export function useCover() {
                 const response = await downloadCover({
                     cover_url: track.images,
                     track_name: track.name,
-                    artist_name: track.artists,
+                    artist_name: displayArtist,
                     album_name: track.album_name,
-                    album_artist: track.album_artist,
+                    album_artist: displayAlbumArtist,
                     release_date: track.release_date,
                     output_dir: outputDir,
                     filename_format: settings.filenameTemplate || "{title}",

frontend/src/hooks/useDownload.ts

@@ -2,7 +2,7 @@ import { useState, useRef } from "react";
 import { downloadTrack, fetchSpotifyMetadata } from "@/lib/api";
 import { getSettings, parseTemplate, type TemplateData } from "@/lib/settings";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
-import { joinPath, sanitizePath } from "@/lib/utils";
+import { joinPath, sanitizePath, getFirstArtist } from "@/lib/utils";
 import { logger } from "@/lib/logger";
 import type { TrackMetadata } from "@/types/api";
 interface CheckFileExistenceRequest {
@@ -28,8 +28,9 @@ interface FileExistenceResult {
     track_name?: string;
     artist_name?: string;
 }
-const CheckFilesExistence = (outputDir: string, tracks: CheckFileExistenceRequest[]): Promise<FileExistenceResult[]> => (window as any)["go"]["main"]["App"]["CheckFilesExistence"](outputDir, tracks);
+const CheckFilesExistence = (outputDir: string, rootDir: string, tracks: CheckFileExistenceRequest[]): Promise<FileExistenceResult[]> => (window as any)["go"]["main"]["App"]["CheckFilesExistence"](outputDir, rootDir, tracks);
 const SkipDownloadItem = (itemID: string, filePath: string): Promise<void> => (window as any)["go"]["main"]["App"]["SkipDownloadItem"](itemID, filePath);
+const CreateM3U8File = (playlistName: string, outputDir: string, filePaths: string[]): Promise<void> => (window as any)["go"]["main"]["App"]["CreateM3U8File"](playlistName, outputDir, filePaths);
 export function useDownload(region: string) {
     const [downloadProgress, setDownloadProgress] = useState<number>(0);
     const [isDownloading, setIsDownloading] = useState(false);
@@ -43,7 +44,7 @@ export function useDownload(region: string) {
         artists: string;
     } | null>(null);
     const shouldStopDownloadRef = useRef(false);
-    const downloadWithAutoFallback = async (isrc: string, settings: any, trackName?: string, artistName?: string, albumName?: string, playlistName?: string, position?: number, spotifyId?: string, durationMs?: number, releaseYear?: string, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => {
+    const downloadWithAutoFallback = async (id: string, settings: any, trackName?: string, artistName?: string, albumName?: string, playlistName?: string, position?: number, spotifyId?: string, durationMs?: number, releaseYear?: string, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => {
         const service = settings.downloader;
         const query = trackName && artistName ? `${trackName} ${artistName} ` : undefined;
         const os = settings.operatingSystem;
@@ -74,18 +75,25 @@ export function useDownload(region: string) {
         if (hasSubfolder) {
             useAlbumTrackNumber = true;
         }
+        const displayArtist = settings.useFirstArtistOnly && artistName
+            ? getFirstArtist(artistName)
+            : artistName;
+        const displayAlbumArtist = settings.useFirstArtistOnly && albumArtist
+            ? getFirstArtist(albumArtist)
+            : albumArtist;
         const templateData: TemplateData = {
-            artist: artistName?.replace(/\//g, placeholder),
+            artist: displayArtist?.replace(/\//g, placeholder),
             album: albumName?.replace(/\//g, placeholder),
-            album_artist: albumArtist?.replace(/\//g, placeholder) || artistName?.replace(/\//g, placeholder),
+            album_artist: displayAlbumArtist?.replace(/\//g, placeholder) || displayArtist?.replace(/\//g, placeholder),
             title: trackName?.replace(/\//g, placeholder),
             track: trackNumberForTemplate,
             year: yearValue,
+            date: releaseDate,
             playlist: playlistName?.replace(/\//g, placeholder),
         };
         const folderTemplate = settings.folderTemplate || "";
         const useAlbumSubfolder = folderTemplate.includes("{album}") || folderTemplate.includes("{album_artist}") || folderTemplate.includes("{playlist}");
-        if (playlistName && !useAlbumSubfolder) {
+        if (settings.createPlaylistFolder && playlistName && !useAlbumSubfolder) {
             outputDir = joinPath(os, outputDir, sanitizePath(playlistName.replace(/\//g, " "), os));
         }
         if (settings.folderTemplate) {
@@ -103,11 +111,11 @@ export function useDownload(region: string) {
         if (trackName && artistName) {
             try {
                 const checkRequest: CheckFileExistenceRequest = {
-                    spotify_id: spotifyId || isrc,
+                    spotify_id: spotifyId || id,
                     track_name: trackName,
-                    artist_name: artistName,
+                    artist_name: displayArtist || "",
                     album_name: albumName,
-                    album_artist: albumArtist,
+                    album_artist: displayAlbumArtist,
                     release_date: finalReleaseDate || releaseDate,
                     track_number: finalTrackNumber || spotifyTrackNumber || 0,
                     disc_number: spotifyDiscNumber || 0,
@@ -117,7 +125,7 @@ export function useDownload(region: string) {
                     include_track_number: settings.trackNumber || false,
                     audio_format: serviceForCheck,
                 };
-                const existenceResults = await CheckFilesExistence(outputDir, [checkRequest]);
+                const existenceResults = await CheckFilesExistence(outputDir, settings.downloadPath, [checkRequest]);
                 if (existenceResults.length > 0 && existenceResults[0].exists) {
                     fileExists = true;
                     return {
@@ -135,7 +143,7 @@ export function useDownload(region: string) {
         const { AddToDownloadQueue } = await import("../../wailsjs/go/main/App");
         let itemID: string | undefined;
         if (!fileExists) {
-            itemID = await AddToDownloadQueue(isrc, trackName || "", artistName || "", albumName || "");
+            itemID = await AddToDownloadQueue(id, trackName || "", displayArtist || "", albumName || "");
         }
         if (service === "auto") {
             let streamingURLs: any = null;
@@ -152,21 +160,21 @@ export function useDownload(region: string) {
             const durationSeconds = durationMs ? Math.round(durationMs / 1000) : undefined;
             const order = (settings.autoOrder || "tidal-amazon-qobuz").split("-");
             let lastResponse: any = { success: false, error: "No matching services found" };
+            const fallbackErrors: string[] = [];
             const is24Bit = (settings.autoQuality || "24") === "24";
             const tidalQuality = is24Bit ? "HI_RES_LOSSLESS" : "LOSSLESS";
-            const qobuzQuality = is24Bit ? "7" : "6";
+            const qobuzQuality = is24Bit ? "27" : "6";
             for (const s of order) {
                 if (s === "tidal" && streamingURLs?.tidal_url) {
                     try {
                         logger.debug(`trying tidal for: ${trackName} - ${artistName}`);
                         const response = await downloadTrack({
-                            isrc,
                             service: "tidal",
                             query,
                             track_name: trackName,
-                            artist_name: artistName,
+                            artist_name: displayArtist,
                             album_name: albumName,
-                            album_artist: albumArtist,
+                            album_artist: displayAlbumArtist,
                             release_date: finalReleaseDate || releaseDate,
                             cover_url: coverUrl,
                             output_dir: outputDir,
@@ -187,16 +195,22 @@ export function useDownload(region: string) {
                             spotify_total_discs: spotifyTotalDiscs,
                             copyright: copyright,
                             publisher: publisher,
+                            use_first_artist_only: settings.useFirstArtistOnly,
+                            use_single_genre: settings.useSingleGenre,
+                            embed_genre: settings.embedGenre,
                         });
                         if (response.success) {
                             logger.success(`tidal: ${trackName} - ${artistName}`);
                             return response;
                         }
+                        const errMsg = response.error || response.message || "Failed";
+                        fallbackErrors.push(`[Tidal] ${errMsg}`);
                         lastResponse = response;
                         logger.warning(`tidal failed, trying next...`);
                     }
                     catch (err) {
                         logger.error(`tidal error: ${err}`);
+                        fallbackErrors.push(`[Tidal] ${String(err)}`);
                         lastResponse = { success: false, error: String(err) };
                     }
                 }
@@ -204,13 +218,12 @@ export function useDownload(region: string) {
                     try {
                         logger.debug(`trying amazon for: ${trackName} - ${artistName}`);
                         const response = await downloadTrack({
-                            isrc,
                             service: "amazon",
                             query,
                             track_name: trackName,
-                            artist_name: artistName,
+                            artist_name: displayArtist,
                             album_name: albumName,
-                            album_artist: albumArtist,
+                            album_artist: displayAlbumArtist,
                             release_date: finalReleaseDate || releaseDate,
                             cover_url: coverUrl,
                             output_dir: outputDir,
@@ -229,16 +242,21 @@ export function useDownload(region: string) {
                             spotify_total_discs: spotifyTotalDiscs,
                             copyright: copyright,
                             publisher: publisher,
+                            use_single_genre: settings.useSingleGenre,
+                            embed_genre: settings.embedGenre,
                         });
                         if (response.success) {
                             logger.success(`amazon: ${trackName} - ${artistName}`);
                             return response;
                         }
+                        const errMsg = response.error || response.message || "Failed";
+                        fallbackErrors.push(`[Amazon] ${errMsg}`);
                         lastResponse = response;
                         logger.warning(`amazon failed, trying next...`);
                     }
                     catch (err) {
                         logger.error(`amazon error: ${err}`);
+                        fallbackErrors.push(`[Amazon] ${String(err)}`);
                         lastResponse = { success: false, error: String(err) };
                     }
                 }
@@ -246,13 +264,12 @@ export function useDownload(region: string) {
                     try {
                         logger.debug(`trying qobuz for: ${trackName} - ${artistName}`);
                         const response = await downloadTrack({
-                            isrc,
                             service: "qobuz",
                             query,
                             track_name: trackName,
-                            artist_name: artistName,
+                            artist_name: displayArtist,
                             album_name: albumName,
-                            album_artist: albumArtist,
+                            album_artist: displayAlbumArtist,
                             release_date: finalReleaseDate || releaseDate,
                             cover_url: coverUrl,
                             output_dir: outputDir,
@@ -271,23 +288,77 @@ export function useDownload(region: string) {
                             spotify_total_discs: spotifyTotalDiscs,
                             copyright: copyright,
                             publisher: publisher,
+                            use_single_genre: settings.useSingleGenre,
+                            embed_genre: settings.embedGenre,
                         });
                         if (response.success) {
                             logger.success(`qobuz: ${trackName} - ${artistName}`);
                             return response;
                         }
+                        const errMsg = response.error || response.message || "Failed";
+                        fallbackErrors.push(`[Qobuz] ${errMsg}`);
                         lastResponse = response;
                         logger.warning(`qobuz failed, trying next...`);
                     }
                     catch (err) {
                         logger.error(`qobuz error: ${err}`);
+                        fallbackErrors.push(`[Qobuz] ${String(err)}`);
+                        lastResponse = { success: false, error: String(err) };
+                    }
+                }
+                else if (s === "deezer") {
+                    try {
+                        logger.debug(`trying deezer for: ${trackName} - ${artistName}`);
+                        const response = await downloadTrack({
+                            service: "deezer",
+                            query,
+                            track_name: trackName,
+                            artist_name: displayArtist,
+                            album_name: albumName,
+                            album_artist: displayAlbumArtist,
+                            release_date: finalReleaseDate || releaseDate,
+                            cover_url: coverUrl,
+                            output_dir: outputDir,
+                            filename_format: settings.filenameTemplate,
+                            track_number: settings.trackNumber,
+                            position,
+                            use_album_track_number: useAlbumTrackNumber,
+                            spotify_id: spotifyId,
+                            embed_lyrics: settings.embedLyrics,
+                            embed_max_quality_cover: settings.embedMaxQualityCover,
+                            duration: durationSeconds,
+                            item_id: itemID,
+                            audio_format: "flac",
+                            spotify_track_number: spotifyTrackNumber,
+                            spotify_disc_number: spotifyDiscNumber,
+                            spotify_total_tracks: spotifyTotalTracks,
+                            spotify_total_discs: spotifyTotalDiscs,
+                            copyright: copyright,
+                            publisher: publisher,
+                            use_first_artist_only: settings.useFirstArtistOnly,
+                            use_single_genre: settings.useSingleGenre,
+                            embed_genre: settings.embedGenre,
+                        });
+                        if (response.success) {
+                            logger.success(`deezer: ${trackName} - ${artistName}`);
+                            return response;
+                        }
+                        const errMsg = response.error || response.message || "Failed";
+                        fallbackErrors.push(`[Deezer] ${errMsg}`);
+                        lastResponse = response;
+                        logger.warning(`deezer failed, trying next...`);
+                    }
+                    catch (err) {
+                        logger.error(`deezer error: ${err}`);
+                        fallbackErrors.push(`[Deezer] ${String(err)}`);
                         lastResponse = { success: false, error: String(err) };
                     }
                 }
             }
             if (itemID) {
                 const { MarkDownloadItemFailed } = await import("../../wailsjs/go/main/App");
-                await MarkDownloadItemFailed(itemID, lastResponse.error || "All services failed");
+                const finalError = fallbackErrors.length > 0 ? fallbackErrors.join(" | ") : (lastResponse.error || "All services failed");
+                await MarkDownloadItemFailed(itemID, finalError);
             }
             return lastResponse;
         }
@@ -299,14 +370,17 @@ export function useDownload(region: string) {
         else if (service === "qobuz") {
             audioFormat = settings.qobuzQuality || "6";
         }
+        else if (service === "deezer") {
+            audioFormat = "flac";
+        }
+        logger.debug(`trying ${service} for: ${trackName} - ${artistName}`);
         const singleServiceResponse = await downloadTrack({
-            isrc,
-            service: service as "tidal" | "qobuz" | "amazon",
+            service: service as "tidal" | "qobuz" | "amazon" | "deezer",
             query,
             track_name: trackName,
-            artist_name: artistName,
+            artist_name: displayArtist,
             album_name: albumName,
-            album_artist: albumArtist,
+            album_artist: displayAlbumArtist,
             release_date: finalReleaseDate || releaseDate,
             cover_url: coverUrl,
             output_dir: outputDir,
@@ -326,6 +400,8 @@ export function useDownload(region: string) {
             spotify_total_discs: spotifyTotalDiscs,
             copyright: copyright,
             publisher: publisher,
+            use_single_genre: settings.useSingleGenre,
+            embed_genre: settings.embedGenre,
         });
         if (!singleServiceResponse.success && itemID) {
             const { MarkDownloadItemFailed } = await import("../../wailsjs/go/main/App");
@@ -333,7 +409,7 @@ export function useDownload(region: string) {
         }
         return singleServiceResponse;
     };
-    const downloadWithItemID = async (isrc: string, settings: any, itemID: string, trackName?: string, artistName?: string, albumName?: string, folderName?: string, position?: number, spotifyId?: string, durationMs?: number, isAlbum?: boolean, releaseYear?: string, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => {
+    const downloadWithItemID = async (settings: any, itemID: string, trackName?: string, artistName?: string, albumName?: string, folderName?: string, position?: number, spotifyId?: string, durationMs?: number, isAlbum?: boolean, releaseYear?: string, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => {
         const service = settings.downloader;
         const query = trackName && artistName ? `${trackName} ${artistName}` : undefined;
         const os = settings.operatingSystem;
@@ -361,21 +437,25 @@ export function useDownload(region: string) {
         const yearValue = releaseYear || finalReleaseDate?.substring(0, 4);
         const hasSubfolder = settings.folderTemplate && settings.folderTemplate.trim() !== "";
         const trackNumberForTemplate = (hasSubfolder && finalTrackNumber > 0) ? finalTrackNumber : (position || 0);
-        if (hasSubfolder) {
-            useAlbumTrackNumber = true;
-        }
+        const displayArtist = settings.useFirstArtistOnly && artistName
+            ? getFirstArtist(artistName)
+            : artistName;
+        const displayAlbumArtist = settings.useFirstArtistOnly && albumArtist
+            ? getFirstArtist(albumArtist)
+            : albumArtist;
         const templateData: TemplateData = {
-            artist: artistName?.replace(/\//g, placeholder),
+            artist: displayArtist?.replace(/\//g, placeholder),
             album: albumName?.replace(/\//g, placeholder),
-            album_artist: albumArtist?.replace(/\//g, placeholder) || artistName?.replace(/\//g, placeholder),
+            album_artist: displayAlbumArtist?.replace(/\//g, placeholder) || displayArtist?.replace(/\//g, placeholder),
             title: trackName?.replace(/\//g, placeholder),
             track: trackNumberForTemplate,
             year: yearValue,
+            date: releaseDate,
             playlist: folderName?.replace(/\//g, placeholder),
         };
         const folderTemplate = settings.folderTemplate || "";
         const useAlbumSubfolder = folderTemplate.includes("{album}") || folderTemplate.includes("{album_artist}") || folderTemplate.includes("{playlist}");
-        if (folderName && (!isAlbum || !useAlbumSubfolder)) {
+        if (settings.createPlaylistFolder && folderName && (!isAlbum || !useAlbumSubfolder)) {
             outputDir = joinPath(os, outputDir, sanitizePath(folderName.replace(/\//g, " "), os));
         }
         if (settings.folderTemplate) {
@@ -403,20 +483,21 @@ export function useDownload(region: string) {
             const durationSeconds = durationMs ? Math.round(durationMs / 1000) : undefined;
             const order = (settings.autoOrder || "tidal-amazon-qobuz").split("-");
             let lastResponse: any = { success: false, error: "No matching services found" };
+            const fallbackErrors: string[] = [];
             const is24Bit = (settings.autoQuality || "24") === "24";
             const tidalQuality = is24Bit ? "HI_RES_LOSSLESS" : "LOSSLESS";
-            const qobuzQuality = is24Bit ? "7" : "6";
+            const qobuzQuality = is24Bit ? "27" : "6";
             for (const s of order) {
                 if (s === "tidal" && streamingURLs?.tidal_url) {
                     try {
+                        logger.debug(`trying tidal for: ${trackName} - ${artistName}`);
                         const response = await downloadTrack({
-                            isrc,
                             service: "tidal",
                             query,
                             track_name: trackName,
-                            artist_name: artistName,
+                            artist_name: displayArtist,
                             album_name: albumName,
-                            album_artist: albumArtist,
+                            album_artist: displayAlbumArtist,
                             release_date: finalReleaseDate || releaseDate,
                             cover_url: coverUrl,
                             output_dir: outputDir,
@@ -437,27 +518,35 @@ export function useDownload(region: string) {
                             spotify_total_discs: spotifyTotalDiscs,
                             copyright: copyright,
                             publisher: publisher,
+                            use_first_artist_only: settings.useFirstArtistOnly,
+                            use_single_genre: settings.useSingleGenre,
+                            embed_genre: settings.embedGenre,
                         });
                         if (response.success) {
+                            logger.success(`tidal: ${trackName} - ${artistName}`);
                             return response;
                         }
+                        const errMsg = response.error || response.message || "Failed";
+                        fallbackErrors.push(`[Tidal] ${errMsg}`);
                         lastResponse = response;
+                        logger.warning(`tidal failed, trying next...`);
                     }
                     catch (err) {
-                        console.error("Tidal error:", err);
+                        logger.error(`tidal error: ${err}`);
+                        fallbackErrors.push(`[Tidal] ${String(err)}`);
                         lastResponse = { success: false, error: String(err) };
                     }
                 }
                 else if (s === "amazon" && streamingURLs?.amazon_url) {
                     try {
+                        logger.debug(`trying amazon for: ${trackName} - ${artistName}`);
                         const response = await downloadTrack({
-                            isrc,
                             service: "amazon",
                             query,
                             track_name: trackName,
-                            artist_name: artistName,
+                            artist_name: displayArtist,
                             album_name: albumName,
-                            album_artist: albumArtist,
+                            album_artist: displayAlbumArtist,
                             release_date: finalReleaseDate || releaseDate,
                             cover_url: coverUrl,
                             output_dir: outputDir,
@@ -476,27 +565,35 @@ export function useDownload(region: string) {
                             spotify_total_discs: spotifyTotalDiscs,
                             copyright: copyright,
                             publisher: publisher,
+                            use_first_artist_only: settings.useFirstArtistOnly,
+                            use_single_genre: settings.useSingleGenre,
+                            embed_genre: settings.embedGenre,
                         });
                         if (response.success) {
+                            logger.success(`amazon: ${trackName} - ${artistName}`);
                             return response;
                         }
+                        const errMsg = response.error || response.message || "Failed";
+                        fallbackErrors.push(`[Amazon] ${errMsg}`);
                         lastResponse = response;
+                        logger.warning(`amazon failed, trying next...`);
                     }
                     catch (err) {
-                        console.error("Amazon error:", err);
+                        logger.error(`amazon error: ${err}`);
+                        fallbackErrors.push(`[Amazon] ${String(err)}`);
                         lastResponse = { success: false, error: String(err) };
                     }
                 }
                 else if (s === "qobuz") {
                     try {
+                        logger.debug(`trying qobuz for: ${trackName} - ${artistName}`);
                         const response = await downloadTrack({
-                            isrc,
                             service: "qobuz",
                             query,
                             track_name: trackName,
-                            artist_name: artistName,
+                            artist_name: displayArtist,
                             album_name: albumName,
-                            album_artist: albumArtist,
+                            album_artist: displayAlbumArtist,
                             release_date: finalReleaseDate || releaseDate,
                             cover_url: coverUrl,
                             output_dir: outputDir,
@@ -516,21 +613,78 @@ export function useDownload(region: string) {
                             spotify_total_discs: spotifyTotalDiscs,
                             copyright: copyright,
                             publisher: publisher,
+                            use_first_artist_only: settings.useFirstArtistOnly,
+                            use_single_genre: settings.useSingleGenre,
+                            embed_genre: settings.embedGenre,
                         });
                         if (response.success) {
+                            logger.success(`qobuz: ${trackName} - ${artistName}`);
                             return response;
                         }
+                        const errMsg = response.error || response.message || "Failed";
+                        fallbackErrors.push(`[Qobuz] ${errMsg}`);
                         lastResponse = response;
+                        logger.warning(`qobuz failed, trying next...`);
                     }
                     catch (err) {
-                        console.error("Qobuz error:", err);
+                        logger.error(`qobuz error: ${err}`);
+                        fallbackErrors.push(`[Qobuz] ${String(err)}`);
+                        lastResponse = { success: false, error: String(err) };
+                    }
+                }
+                else if (s === "deezer") {
+                    try {
+                        logger.debug(`trying deezer for: ${trackName} - ${artistName}`);
+                        const response = await downloadTrack({
+                            service: "deezer",
+                            query,
+                            track_name: trackName,
+                            artist_name: displayArtist,
+                            album_name: albumName,
+                            album_artist: displayAlbumArtist,
+                            release_date: finalReleaseDate || releaseDate,
+                            cover_url: coverUrl,
+                            output_dir: outputDir,
+                            filename_format: settings.filenameTemplate,
+                            track_number: settings.trackNumber,
+                            position: trackNumberForTemplate,
+                            use_album_track_number: useAlbumTrackNumber,
+                            spotify_id: spotifyId,
+                            embed_lyrics: settings.embedLyrics,
+                            embed_max_quality_cover: settings.embedMaxQualityCover,
+                            duration: durationSeconds,
+                            item_id: itemID,
+                            audio_format: "flac",
+                            spotify_track_number: spotifyTrackNumber,
+                            spotify_disc_number: spotifyDiscNumber,
+                            spotify_total_tracks: spotifyTotalTracks,
+                            spotify_total_discs: spotifyTotalDiscs,
+                            copyright: copyright,
+                            publisher: publisher,
+                            use_first_artist_only: settings.useFirstArtistOnly,
+                            use_single_genre: settings.useSingleGenre,
+                            embed_genre: settings.embedGenre,
+                        });
+                        if (response.success) {
+                            logger.success(`deezer: ${trackName} - ${artistName}`);
+                            return response;
+                        }
+                        const errMsg = response.error || response.message || "Failed";
+                        fallbackErrors.push(`[Deezer] ${errMsg}`);
+                        lastResponse = response;
+                        logger.warning(`deezer failed, trying next...`);
+                    }
+                    catch (err) {
+                        logger.error(`deezer error: ${err}`);
+                        fallbackErrors.push(`[Deezer] ${String(err)}`);
                         lastResponse = { success: false, error: String(err) };
                     }
                 }
             }
             if (!lastResponse.success && itemID) {
                 const { MarkDownloadItemFailed } = await import("../../wailsjs/go/main/App");
-                await MarkDownloadItemFailed(itemID, lastResponse.error || "All services failed");
+                const finalError = fallbackErrors.length > 0 ? fallbackErrors.join(" | ") : (lastResponse.error || "All services failed");
+                await MarkDownloadItemFailed(itemID, finalError);
             }
             return lastResponse;
         }
@@ -542,14 +696,16 @@ export function useDownload(region: string) {
         else if (service === "qobuz") {
             audioFormat = settings.qobuzQuality || "6";
         }
+        else if (service === "deezer") {
+            audioFormat = "flac";
+        }
         const singleServiceResponse = await downloadTrack({
-            isrc,
-            service: service as "tidal" | "qobuz" | "amazon",
+            service: service as "tidal" | "qobuz" | "amazon" | "deezer",
             query,
             track_name: trackName,
-            artist_name: artistName,
+            artist_name: displayArtist,
             album_name: albumName,
-            album_artist: albumArtist,
+            album_artist: displayAlbumArtist,
             release_date: finalReleaseDate || releaseDate,
             cover_url: coverUrl,
             output_dir: outputDir,
@@ -569,6 +725,9 @@ export function useDownload(region: string) {
             spotify_total_discs: spotifyTotalDiscs,
             copyright: copyright,
             publisher: publisher,
+            use_first_artist_only: settings.useFirstArtistOnly,
+            use_single_genre: settings.useSingleGenre,
+            embed_genre: settings.embedGenre,
         });
         if (!singleServiceResponse.success && itemID) {
             const { MarkDownloadItemFailed } = await import("../../wailsjs/go/main/App");
@@ -576,40 +735,41 @@ export function useDownload(region: string) {
         }
         return singleServiceResponse;
     };
-    const handleDownloadTrack = async (isrc: string, trackName?: string, artistName?: string, albumName?: string, spotifyId?: string, playlistName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => {
-        if (!isrc) {
-            toast.error("No ISRC found for this track");
+    const handleDownloadTrack = async (id: string, trackName?: string, artistName?: string, albumName?: string, spotifyId?: string, playlistName?: string, durationMs?: number, position?: number, albumArtist?: string, releaseDate?: string, coverUrl?: string, spotifyTrackNumber?: number, spotifyDiscNumber?: number, spotifyTotalTracks?: number, spotifyTotalDiscs?: number, copyright?: string, publisher?: string) => {
+        if (!id) {
+            toast.error("No ID found for this track");
             return;
         }
-        logger.info(`starting download: ${trackName} - ${artistName}`);
         const settings = getSettings();
-        setDownloadingTrack(isrc);
+        const displayArtist = settings.useFirstArtistOnly && artistName ? getFirstArtist(artistName) : artistName;
+        logger.info(`starting download: ${trackName} - ${displayArtist}`);
+        setDownloadingTrack(id);
         try {
             const releaseYear = releaseDate?.substring(0, 4);
-            const response = await downloadWithAutoFallback(isrc, settings, trackName, artistName, albumName, playlistName, position, spotifyId, durationMs, releaseYear, albumArtist || "", releaseDate, coverUrl, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, spotifyTotalDiscs, copyright, publisher);
+            const response = await downloadWithAutoFallback(id, settings, trackName, artistName, albumName, playlistName, position, spotifyId, durationMs, releaseYear, albumArtist || "", releaseDate, coverUrl, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, spotifyTotalDiscs, copyright, publisher);
             if (response.success) {
                 if (response.already_exists) {
                     toast.info(response.message);
-                    setSkippedTracks((prev) => new Set(prev).add(isrc));
+                    setSkippedTracks((prev) => new Set(prev).add(id));
                 }
                 else {
                     toast.success(response.message);
                 }
-                setDownloadedTracks((prev) => new Set(prev).add(isrc));
+                setDownloadedTracks((prev) => new Set(prev).add(id));
                 setFailedTracks((prev) => {
                     const newSet = new Set(prev);
-                    newSet.delete(isrc);
+                    newSet.delete(id);
                     return newSet;
                 });
             }
             else {
                 toast.error(response.error || "Download failed");
-                setFailedTracks((prev) => new Set(prev).add(isrc));
+                setFailedTracks((prev) => new Set(prev).add(id));
             }
         }
         catch (err) {
             toast.error(err instanceof Error ? err.message : "Download failed");
-            setFailedTracks((prev) => new Set(prev).add(isrc));
+            setFailedTracks((prev) => new Set(prev).add(id));
         }
         finally {
             setDownloadingTrack(null);
@@ -628,22 +788,24 @@ export function useDownload(region: string) {
         let outputDir = settings.downloadPath;
         const os = settings.operatingSystem;
         const useAlbumTag = settings.folderTemplate?.includes("{album}");
-        if (folderName && (!isAlbum || !useAlbumTag)) {
+        if (settings.createPlaylistFolder && folderName && (!isAlbum || !useAlbumTag)) {
             outputDir = joinPath(os, outputDir, sanitizePath(folderName.replace(/\//g, " "), os));
         }
         const selectedTrackObjects = selectedTracks
-            .map((isrc) => allTracks.find((t) => t.isrc === isrc))
+            .map((id) => allTracks.find((t) => t.spotify_id === id))
             .filter((t): t is TrackMetadata => t !== undefined);
         logger.info(`checking existing files in parallel...`);
         const useAlbumTrackNumber = settings.folderTemplate?.includes("{album}") || false;
         const audioFormat = "flac";
         const existenceChecks = selectedTrackObjects.map((track, index) => {
+            const displayArtist = settings.useFirstArtistOnly && track.artists ? getFirstArtist(track.artists) : track.artists;
+            const displayAlbumArtist = settings.useFirstArtistOnly && track.album_artist ? getFirstArtist(track.album_artist) : track.album_artist;
             return {
-                spotify_id: track.spotify_id || track.isrc,
+                spotify_id: track.spotify_id || "",
                 track_name: track.name || "",
-                artist_name: track.artists || "",
+                artist_name: displayArtist || "",
                 album_name: track.album_name || "",
-                album_artist: track.album_artist || "",
+                album_artist: displayAlbumArtist || "",
                 release_date: track.release_date || "",
                 track_number: track.track_number || 0,
                 disc_number: track.disc_number || 0,
@@ -654,32 +816,37 @@ export function useDownload(region: string) {
                 audio_format: audioFormat,
             };
         });
-        const existenceResults = await CheckFilesExistence(outputDir, existenceChecks);
+        const existenceResults = await CheckFilesExistence(outputDir, settings.downloadPath, existenceChecks);
         const existingSpotifyIDs = new Set<string>();
         const existingFilePaths = new Map<string, string>();
+        const finalFilePaths = new Map<string, string>();
         for (const result of existenceResults) {
             if (result.exists) {
                 existingSpotifyIDs.add(result.spotify_id);
                 existingFilePaths.set(result.spotify_id, result.file_path || "");
+                finalFilePaths.set(result.spotify_id, result.file_path || "");
             }
         }
         logger.info(`found ${existingSpotifyIDs.size} existing files`);
         const { AddToDownloadQueue } = await import("../../wailsjs/go/main/App");
         const itemIDs: string[] = [];
-        for (const isrc of selectedTracks) {
-            const track = allTracks.find((t) => t.isrc === isrc);
-            const trackID = track?.spotify_id || isrc;
-            const itemID = await AddToDownloadQueue(trackID, track?.name || "", track?.artists || "", track?.album_name || "");
+        for (const id of selectedTracks) {
+            const track = allTracks.find((t) => t.spotify_id === id);
+            if (!track)
+                continue;
+            const trackID = track.spotify_id || id;
+            const displayArtist = settings.useFirstArtistOnly && track.artists ? getFirstArtist(track.artists) : track.artists;
+            const itemID = await AddToDownloadQueue(trackID, track.name || "", displayArtist || "", track.album_name || "");
             itemIDs.push(itemID);
             if (existingSpotifyIDs.has(trackID)) {
                 const filePath = existingFilePaths.get(trackID) || "";
                 setTimeout(() => SkipDownloadItem(itemID, filePath), 10);
-                setSkippedTracks((prev) => new Set(prev).add(isrc));
-                setDownloadedTracks((prev) => new Set(prev).add(isrc));
+                setSkippedTracks((prev) => new Set(prev).add(id));
+                setDownloadedTracks((prev) => new Set(prev).add(id));
             }
         }
         const tracksToDownload = selectedTrackObjects.filter((track) => {
-            const trackID = track.spotify_id || track.isrc;
+            const trackID = track.spotify_id || "";
             return !existingSpotifyIDs.has(trackID);
         });
         let successCount = 0;
@@ -693,41 +860,46 @@ export function useDownload(region: string) {
                 break;
             }
             const track = tracksToDownload[i];
-            const isrc = track.isrc;
-            const originalIndex = selectedTracks.indexOf(isrc);
+            const id = track.spotify_id || "";
+            const originalIndex = selectedTracks.indexOf(id);
             const itemID = itemIDs[originalIndex];
-            setDownloadingTrack(isrc);
-            setCurrentDownloadInfo({ name: track.name, artists: track.artists });
+            setDownloadingTrack(id);
+            const displayArtist = settings.useFirstArtistOnly && track.artists ? getFirstArtist(track.artists) : track.artists;
+            setCurrentDownloadInfo({ name: track.name, artists: displayArtist || "" });
             try {
                 const releaseYear = track.release_date?.substring(0, 4);
-                const response = await downloadWithItemID(isrc, settings, itemID, track.name, track.artists, track.album_name, folderName, originalIndex + 1, track.spotify_id, track.duration_ms, isAlbum, releaseYear, track.album_artist || "", track.release_date, track.images, track.track_number, track.disc_number, track.total_tracks, track.total_discs, track.copyright, track.publisher);
+                const response = await downloadWithItemID(settings, itemID, track.name, track.artists, track.album_name, folderName, originalIndex + 1, track.spotify_id, track.duration_ms, isAlbum, releaseYear, track.album_artist || "", track.release_date, track.images, track.track_number, track.disc_number, track.total_tracks, track.total_discs, track.copyright, track.publisher);
                 if (response.success) {
                     if (response.already_exists) {
                         skippedCount++;
-                        logger.info(`skipped: ${track.name} - ${track.artists} (already exists)`);
-                        setSkippedTracks((prev) => new Set(prev).add(isrc));
+                        logger.info(`skipped: ${track.name} - ${displayArtist} (already exists)`);
+                        setSkippedTracks((prev) => new Set(prev).add(id));
                     }
                     else {
                         successCount++;
-                        logger.success(`downloaded: ${track.name} - ${track.artists}`);
+                        logger.success(`downloaded: ${track.name} - ${displayArtist}`);
                     }
-                    setDownloadedTracks((prev) => new Set(prev).add(isrc));
+                    if (response.file) {
+                        finalFilePaths.set(id, response.file);
+                        finalFilePaths.set(track.spotify_id || id, response.file);
+                    }
+                    setDownloadedTracks((prev) => new Set(prev).add(id));
                     setFailedTracks((prev) => {
                         const newSet = new Set(prev);
-                        newSet.delete(isrc);
+                        newSet.delete(id);
                         return newSet;
                     });
                 }
                 else {
                     errorCount++;
-                    logger.error(`failed: ${track.name} - ${track.artists}`);
-                    setFailedTracks((prev) => new Set(prev).add(isrc));
+                    logger.error(`failed: ${track.name} - ${displayArtist}`);
+                    setFailedTracks((prev) => new Set(prev).add(id));
                 }
             }
             catch (err) {
                 errorCount++;
                 logger.error(`error: ${track.name} - ${err}`);
-                setFailedTracks((prev) => new Set(prev).add(isrc));
+                setFailedTracks((prev) => new Set(prev).add(id));
                 if (itemID) {
                     const { MarkDownloadItemFailed } = await import("../../wailsjs/go/main/App");
                     await MarkDownloadItemFailed(itemID, err instanceof Error ? err.message : String(err));
@@ -743,6 +915,20 @@ export function useDownload(region: string) {
         shouldStopDownloadRef.current = false;
         const { CancelAllQueuedItems } = await import("../../wailsjs/go/main/App");
         await CancelAllQueuedItems();
+        if (settings.createM3u8File && folderName) {
+            const paths = selectedTrackObjects.map((t) => finalFilePaths.get(t.spotify_id || "") || "").filter((p) => p !== "");
+            if (paths.length > 0) {
+                try {
+                    logger.info(`creating m3u8 playlist: ${folderName}`);
+                    await CreateM3U8File(folderName, outputDir, paths);
+                    toast.success("M3U8 playlist created");
+                }
+                catch (err) {
+                    logger.error(`failed to create m3u8 playlist: ${err}`);
+                    toast.error(`Failed to create M3U8 playlist: ${err}`);
+                }
+            }
+        }
         logger.info(`batch complete: ${successCount} downloaded, ${skippedCount} skipped, ${errorCount} failed`);
         if (errorCount === 0 && skippedCount === 0) {
             toast.success(`Downloaded ${successCount} tracks successfully`);
@@ -764,12 +950,12 @@ export function useDownload(region: string) {
         }
     };
     const handleDownloadAll = async (tracks: TrackMetadata[], folderName?: string, isAlbum?: boolean) => {
-        const tracksWithIsrc = tracks.filter((track) => track.isrc);
-        if (tracksWithIsrc.length === 0) {
+        const tracksWithId = tracks.filter((track) => track.spotify_id);
+        if (tracksWithId.length === 0) {
             toast.error("No tracks available for download");
             return;
         }
-        logger.info(`starting batch download: ${tracksWithIsrc.length} tracks`);
+        logger.info(`starting batch download: ${tracksWithId.length} tracks`);
         const settings = getSettings();
         setIsDownloading(true);
         setBulkDownloadType("all");
@@ -777,19 +963,21 @@ export function useDownload(region: string) {
         let outputDir = settings.downloadPath;
         const os = settings.operatingSystem;
         const useAlbumTag = settings.folderTemplate?.includes("{album}");
-        if (folderName && (!isAlbum || !useAlbumTag)) {
+        if (settings.createPlaylistFolder && folderName && (!isAlbum || !useAlbumTag)) {
             outputDir = joinPath(os, outputDir, sanitizePath(folderName.replace(/\//g, " "), os));
         }
         logger.info(`checking existing files in parallel...`);
         const useAlbumTrackNumber = settings.folderTemplate?.includes("{album}") || false;
         const audioFormat = "flac";
-        const existenceChecks = tracksWithIsrc.map((track, index) => {
+        const existenceChecks = tracksWithId.map((track, index) => {
+            const displayArtist = settings.useFirstArtistOnly && track.artists ? getFirstArtist(track.artists) : track.artists;
+            const displayAlbumArtist = settings.useFirstArtistOnly && track.album_artist ? getFirstArtist(track.album_artist) : track.album_artist;
             return {
-                spotify_id: track.spotify_id || track.isrc,
+                spotify_id: track.spotify_id || "",
                 track_name: track.name || "",
-                artist_name: track.artists || "",
+                artist_name: displayArtist || "",
                 album_name: track.album_name || "",
-                album_artist: track.album_artist || "",
+                album_artist: displayAlbumArtist || "",
                 release_date: track.release_date || "",
                 track_number: track.track_number || 0,
                 disc_number: track.disc_number || 0,
@@ -800,37 +988,41 @@ export function useDownload(region: string) {
                 audio_format: audioFormat,
             };
         });
-        const existenceResults = await CheckFilesExistence(outputDir, existenceChecks);
+        const existenceResults = await CheckFilesExistence(outputDir, settings.downloadPath, existenceChecks);
+        const finalFilePaths: string[] = new Array(tracksWithId.length).fill("");
         const existingSpotifyIDs = new Set<string>();
         const existingFilePaths = new Map<string, string>();
-        for (const result of existenceResults) {
+        for (let i = 0; i < existenceResults.length; i++) {
+            const result = existenceResults[i];
             if (result.exists) {
                 existingSpotifyIDs.add(result.spotify_id);
                 existingFilePaths.set(result.spotify_id, result.file_path || "");
+                finalFilePaths[i] = result.file_path || "";
             }
         }
         logger.info(`found ${existingSpotifyIDs.size} existing files`);
         const { AddToDownloadQueue } = await import("../../wailsjs/go/main/App");
         const itemIDs: string[] = [];
-        for (const track of tracksWithIsrc) {
-            const itemID = await AddToDownloadQueue(track.isrc, track.name, track.artists, track.album_name || "");
+        for (const track of tracksWithId) {
+            const displayArtist = settings.useFirstArtistOnly && track.artists ? getFirstArtist(track.artists) : track.artists;
+            const itemID = await AddToDownloadQueue(track.spotify_id || "", track.name || "", displayArtist || "", track.album_name || "");
             itemIDs.push(itemID);
-            const trackID = track.spotify_id || track.isrc;
+            const trackID = track.spotify_id || "";
             if (existingSpotifyIDs.has(trackID)) {
                 const filePath = existingFilePaths.get(trackID) || "";
                 setTimeout(() => SkipDownloadItem(itemID, filePath), 10);
-                setSkippedTracks((prev) => new Set(prev).add(track.isrc));
-                setDownloadedTracks((prev) => new Set(prev).add(track.isrc));
+                setSkippedTracks((prev: Set<string>) => new Set(prev).add(trackID));
+                setDownloadedTracks((prev: Set<string>) => new Set(prev).add(trackID));
             }
         }
-        const tracksToDownload = tracksWithIsrc.filter((track) => {
-            const trackID = track.spotify_id || track.isrc;
+        const tracksToDownload = tracksWithId.filter((track) => {
+            const trackID = track.spotify_id || "";
             return !existingSpotifyIDs.has(trackID);
         });
         let successCount = 0;
         let errorCount = 0;
         let skippedCount = existingSpotifyIDs.size;
-        const total = tracksWithIsrc.length;
+        const total = tracksWithId.length;
         setDownloadProgress(Math.round((skippedCount / total) * 100));
         for (let i = 0; i < tracksToDownload.length; i++) {
             if (shouldStopDownloadRef.current) {
@@ -838,40 +1030,45 @@ export function useDownload(region: string) {
                 break;
             }
             const track = tracksToDownload[i];
-            const originalIndex = tracksWithIsrc.findIndex((t) => t.isrc === track.isrc);
+            const originalIndex = tracksWithId.findIndex((t) => t.spotify_id === track.spotify_id);
             const itemID = itemIDs[originalIndex];
-            setDownloadingTrack(track.isrc);
-            setCurrentDownloadInfo({ name: track.name, artists: track.artists });
+            const trackId = track.spotify_id || "";
+            setDownloadingTrack(trackId);
+            const displayArtist = settings.useFirstArtistOnly && track.artists ? getFirstArtist(track.artists) : track.artists;
+            setCurrentDownloadInfo({ name: track.name || "", artists: displayArtist || "" });
             try {
                 const releaseYear = track.release_date?.substring(0, 4);
-                const response = await downloadWithItemID(track.isrc, settings, itemID, track.name, track.artists, track.album_name, folderName, originalIndex + 1, track.spotify_id, track.duration_ms, isAlbum, releaseYear, track.album_artist || "", track.release_date, track.images, track.track_number, track.disc_number, track.total_tracks, track.total_discs, track.copyright, track.publisher);
+                const response = await downloadWithItemID(settings, itemID, track.name, track.artists, track.album_name, folderName, originalIndex + 1, track.spotify_id, track.duration_ms, isAlbum, releaseYear, track.album_artist || "", track.release_date, track.images, track.track_number, track.disc_number, track.total_tracks, track.total_discs, track.copyright, track.publisher);
                 if (response.success) {
                     if (response.already_exists) {
                         skippedCount++;
-                        logger.info(`skipped: ${track.name} - ${track.artists} (already exists)`);
-                        setSkippedTracks((prev) => new Set(prev).add(track.isrc));
+                        logger.info(`skipped: ${track.name} - ${displayArtist} (already exists)`);
+                        setSkippedTracks((prev) => new Set(prev).add(trackId));
                     }
                     else {
                         successCount++;
-                        logger.success(`downloaded: ${track.name} - ${track.artists}`);
+                        logger.success(`downloaded: ${track.name} - ${displayArtist}`);
                     }
-                    setDownloadedTracks((prev) => new Set(prev).add(track.isrc));
+                    setDownloadedTracks((prev) => new Set(prev).add(trackId));
                     setFailedTracks((prev) => {
                         const newSet = new Set(prev);
-                        newSet.delete(track.isrc);
+                        newSet.delete(trackId);
                         return newSet;
                     });
+                    if (response.file) {
+                        finalFilePaths[originalIndex] = response.file;
+                    }
                 }
                 else {
                     errorCount++;
-                    logger.error(`failed: ${track.name} - ${track.artists}`);
-                    setFailedTracks((prev) => new Set(prev).add(track.isrc));
+                    logger.error(`failed: ${track.name} - ${displayArtist}`);
+                    setFailedTracks((prev) => new Set(prev).add(trackId));
                 }
             }
             catch (err) {
                 errorCount++;
                 logger.error(`error: ${track.name} - ${err}`);
-                setFailedTracks((prev) => new Set(prev).add(track.isrc));
+                setFailedTracks((prev) => new Set(prev).add(trackId));
                 const { MarkDownloadItemFailed } = await import("../../wailsjs/go/main/App");
                 await MarkDownloadItemFailed(itemID, err instanceof Error ? err.message : String(err));
             }
@@ -885,6 +1082,17 @@ export function useDownload(region: string) {
         shouldStopDownloadRef.current = false;
         const { CancelAllQueuedItems: CancelQueued } = await import("../../wailsjs/go/main/App");
         await CancelQueued();
+        if (settings.createM3u8File && folderName) {
+            try {
+                logger.info(`creating m3u8 playlist: ${folderName}`);
+                await CreateM3U8File(folderName, outputDir, finalFilePaths.filter(p => p !== ""));
+                toast.success("M3U8 playlist created");
+            }
+            catch (err) {
+                logger.error(`failed to create m3u8 playlist: ${err}`);
+                toast.error(`Failed to create M3U8 playlist: ${err}`);
+            }
+        }
         logger.info(`batch complete: ${successCount} downloaded, ${skippedCount} skipped, ${errorCount} failed`);
         if (errorCount === 0 && skippedCount === 0) {
             toast.success(`Downloaded ${successCount} tracks successfully`);

frontend/src/hooks/useLyrics.ts

@@ -2,7 +2,7 @@ import { useState, useRef } from "react";
 import { downloadLyrics } from "@/lib/api";
 import { getSettings, parseTemplate, type TemplateData } from "@/lib/settings";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
-import { joinPath, sanitizePath } from "@/lib/utils";
+import { joinPath, sanitizePath, getFirstArtist } from "@/lib/utils";
 import { logger } from "@/lib/logger";
 import type { TrackMetadata } from "@/types/api";
 export function useLyrics() {
@@ -25,11 +25,17 @@ export function useLyrics() {
             const os = settings.operatingSystem;
             let outputDir = settings.downloadPath;
             const placeholder = "__SLASH_PLACEHOLDER__";
+            const yearValue = releaseDate?.substring(0, 4);
+            const displayArtist = settings.useFirstArtistOnly && artistName ? getFirstArtist(artistName) : artistName;
+            const displayAlbumArtist = settings.useFirstArtistOnly && albumArtist ? getFirstArtist(albumArtist) : albumArtist;
             const templateData: TemplateData = {
-                artist: artistName?.replace(/\//g, placeholder),
+                artist: displayArtist?.replace(/\//g, placeholder),
                 album: albumName?.replace(/\//g, placeholder),
+                album_artist: displayAlbumArtist?.replace(/\//g, placeholder) || displayArtist?.replace(/\//g, placeholder),
                 title: trackName?.replace(/\//g, placeholder),
                 track: position,
+                year: yearValue,
+                date: releaseDate,
                 playlist: playlistName?.replace(/\//g, placeholder),
             };
             const folderTemplate = settings.folderTemplate || "";
@@ -51,9 +57,9 @@ export function useLyrics() {
             const response = await downloadLyrics({
                 spotify_id: spotifyId,
                 track_name: trackName,
-                artist_name: artistName,
+                artist_name: displayArtist,
                 album_name: albumName,
-                album_artist: albumArtist,
+                album_artist: displayAlbumArtist,
                 release_date: releaseDate,
                 output_dir: outputDir,
                 filename_format: settings.filenameTemplate || "{title}",
@@ -120,11 +126,17 @@ export function useLyrics() {
                 const placeholder = "__SLASH_PLACEHOLDER__";
                 const useAlbumTrackNumber = settings.folderTemplate?.includes("{album}") || false;
                 const trackPosition = useAlbumTrackNumber ? (track.track_number || i + 1) : (i + 1);
+                const yearValue = track.release_date?.substring(0, 4);
+                const displayArtist = settings.useFirstArtistOnly && track.artists ? getFirstArtist(track.artists) : track.artists;
+                const displayAlbumArtist = settings.useFirstArtistOnly && track.album_artist ? getFirstArtist(track.album_artist) : track.album_artist;
                 const templateData: TemplateData = {
-                    artist: track.artists?.replace(/\//g, placeholder),
+                    artist: displayArtist?.replace(/\//g, placeholder),
                     album: track.album_name?.replace(/\//g, placeholder),
+                    album_artist: displayAlbumArtist?.replace(/\//g, placeholder) || displayArtist?.replace(/\//g, placeholder),
                     title: track.name?.replace(/\//g, placeholder),
                     track: trackPosition,
+                    year: yearValue,
+                    date: track.release_date,
                     playlist: playlistName?.replace(/\//g, placeholder),
                 };
                 const folderTemplate = settings.folderTemplate || "";
@@ -145,9 +157,9 @@ export function useLyrics() {
                 const response = await downloadLyrics({
                     spotify_id: id,
                     track_name: track.name,
-                    artist_name: track.artists,
+                    artist_name: displayArtist,
                     album_name: track.album_name,
-                    album_artist: track.album_artist,
+                    album_artist: displayAlbumArtist,
                     release_date: track.release_date,
                     output_dir: outputDir,
                     filename_format: settings.filenameTemplate || "{title}",

frontend/src/hooks/useMetadata.ts

@@ -1,4 +1,5 @@
 import { useState } from "react";
+import { getSettings } from "@/lib/settings";
 import { fetchSpotifyMetadata } from "@/lib/api";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
 import { logger } from "@/lib/logger";
@@ -7,6 +8,7 @@ import type { SpotifyMetadataResponse } from "@/types/api";
 export function useMetadata() {
     const [loading, setLoading] = useState(false);
     const [metadata, setMetadata] = useState<SpotifyMetadataResponse | null>(null);
+    const [showApiModal, setShowApiModal] = useState(false);
     const [showAlbumDialog, setShowAlbumDialog] = useState(false);
     const [selectedAlbum, setSelectedAlbum] = useState<{
         id: string;
@@ -109,7 +111,7 @@ export function useMetadata() {
             saveToHistory(url, data);
             if ("track" in data) {
                 logger.success(`fetched track: ${data.track.name} - ${data.track.artists}`);
-                logger.debug(`isrc: ${data.track.isrc}, duration: ${data.track.duration_ms}ms`);
+                logger.debug(`duration: ${data.track.duration_ms}ms`);
             }
             else if ("album_info" in data) {
                 logger.success(`fetched album: ${data.album_info.name}`);
@@ -129,7 +131,13 @@ export function useMetadata() {
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : "Failed to fetch metadata";
             logger.error(`fetch failed: ${errorMsg}`);
-            toast.error(errorMsg);
+            const settings = getSettings();
+            if (!settings.useSpotFetchAPI) {
+                setShowApiModal(true);
+            }
+            else {
+                toast.error(errorMsg);
+            }
         }
         finally {
             setLoading(false);
@@ -224,7 +232,13 @@ export function useMetadata() {
         catch (err) {
             const errorMsg = err instanceof Error ? err.message : "Failed to fetch album metadata";
             logger.error(`fetch failed: ${errorMsg}`);
-            toast.error(errorMsg);
+            const settings = getSettings();
+            if (!settings.useSpotFetchAPI) {
+                setShowApiModal(true);
+            }
+            else {
+                toast.error(errorMsg);
+            }
         }
         finally {
             setLoading(false);
@@ -243,6 +257,8 @@ export function useMetadata() {
         handleConfirmAlbumFetch,
         handleArtistClick,
         loadFromCache,
+        showApiModal,
+        setShowApiModal,
         resetMetadata: () => setMetadata(null),
     };
 }

frontend/src/lib/api.ts

@@ -13,6 +13,9 @@ export async function fetchSpotifyMetadata(url: string, batch: boolean = true, d
 }
 export async function downloadTrack(request: DownloadRequest): Promise<DownloadResponse> {
     const req = new main.DownloadRequest(request);
+    if (request.use_single_genre !== undefined) {
+        (req as any).use_single_genre = request.use_single_genre;
+    }
     return await DownloadTrack(req);
 }
 export async function checkHealth(): Promise<HealthResponse> {

frontend/src/lib/settings.ts

@@ -4,7 +4,7 @@ export type FolderPreset = "none" | "artist" | "album" | "year-album" | "year-ar
 export type FilenamePreset = "title" | "title-artist" | "artist-title" | "track-title" | "track-title-artist" | "track-artist-title" | "title-album-artist" | "track-title-album-artist" | "artist-album-title" | "track-dash-title" | "disc-track-title" | "disc-track-title-artist" | "custom";
 export interface Settings {
     downloadPath: string;
-    downloader: "auto" | "tidal" | "qobuz" | "amazon";
+    downloader: "auto" | "tidal" | "qobuz" | "amazon" | "deezer";
     theme: string;
     themeMode: "auto" | "light" | "dark";
     fontFamily: FontFamily;
@@ -21,11 +21,18 @@ export interface Settings {
     embedMaxQualityCover: boolean;
     operatingSystem: "Windows" | "linux/MacOS";
     tidalQuality: "LOSSLESS" | "HI_RES_LOSSLESS";
-    qobuzQuality: "6" | "7";
+    qobuzQuality: "6" | "7" | "27";
     amazonQuality: "original";
-    autoOrder: "tidal-qobuz-amazon" | "tidal-amazon-qobuz" | "qobuz-tidal-amazon" | "qobuz-amazon-tidal" | "amazon-tidal-qobuz" | "amazon-qobuz-tidal" | "tidal-qobuz" | "tidal-amazon" | "qobuz-tidal" | "qobuz-amazon" | "amazon-tidal" | "amazon-qobuz";
+    autoOrder: "tidal-qobuz-amazon-deezer" | "tidal-qobuz-deezer-amazon" | "tidal-amazon-qobuz-deezer" | "tidal-amazon-deezer-qobuz" | "tidal-deezer-qobuz-amazon" | "tidal-deezer-amazon-qobuz" | "qobuz-tidal-amazon-deezer" | "qobuz-tidal-deezer-amazon" | "qobuz-amazon-tidal-deezer" | "qobuz-amazon-deezer-tidal" | "qobuz-deezer-tidal-amazon" | "qobuz-deezer-amazon-tidal" | "amazon-tidal-qobuz-deezer" | "amazon-tidal-deezer-qobuz" | "amazon-qobuz-tidal-deezer" | "amazon-qobuz-deezer-tidal" | "amazon-deezer-tidal-qobuz" | "amazon-deezer-qobuz-tidal" | "deezer-tidal-qobuz-amazon" | "deezer-tidal-amazon-qobuz" | "deezer-qobuz-tidal-amazon" | "deezer-qobuz-amazon-tidal" | "deezer-amazon-tidal-qobuz" | "deezer-amazon-qobuz-tidal" | string;
     autoQuality: "16" | "24";
     allowFallback: boolean;
+    useSpotFetchAPI: boolean;
+    spotFetchAPIUrl: string;
+    createPlaylistFolder: boolean;
+    createM3u8File: boolean;
+    useFirstArtistOnly: boolean;
+    useSingleGenre: boolean;
+    embedGenre: boolean;
 }
 export const FOLDER_PRESETS: Record<FolderPreset, {
     label: string;
@@ -73,6 +80,7 @@ export const TEMPLATE_VARIABLES = [
     { key: "{track}", description: "Track number", example: "01" },
     { key: "{disc}", description: "Disc number", example: "1" },
     { key: "{year}", description: "Release year", example: "2014" },
+    { key: "{date}", description: "Release date (YYYY-MM-DD)", example: "2014-10-27" },
 ];
 function detectOS(): "Windows" | "linux/MacOS" {
     const platform = window.navigator.platform.toLowerCase();
@@ -99,9 +107,16 @@ export const DEFAULT_SETTINGS: Settings = {
     tidalQuality: "LOSSLESS",
     qobuzQuality: "6",
     amazonQuality: "original",
-    autoOrder: "tidal-qobuz-amazon",
+    autoOrder: "tidal-qobuz-amazon-deezer",
     autoQuality: "16",
-    allowFallback: true
+    allowFallback: true,
+    useSpotFetchAPI: false,
+    spotFetchAPIUrl: "https://spotify.afkarxyz.fun/api",
+    createPlaylistFolder: true,
+    createM3u8File: false,
+    useFirstArtistOnly: false,
+    useSingleGenre: false,
+    embedGenre: true
 };
 export const FONT_OPTIONS: {
     value: FontFamily;
@@ -196,9 +211,6 @@ function getSettingsFromLocalStorage(): Settings {
             if (!('qobuzQuality' in parsed)) {
                 parsed.qobuzQuality = "6";
             }
-            if (parsed.qobuzQuality === "27") {
-                parsed.qobuzQuality = "6";
-            }
             if (!('amazonQuality' in parsed)) {
                 parsed.amazonQuality = "original";
             }
@@ -275,9 +287,6 @@ export async function loadSettings(): Promise<Settings> {
             if (!('qobuzQuality' in parsed)) {
                 parsed.qobuzQuality = "6";
             }
-            if (parsed.qobuzQuality === "27") {
-                parsed.qobuzQuality = "6";
-            }
             if (!('amazonQuality' in parsed)) {
                 parsed.amazonQuality = "original";
             }
@@ -290,6 +299,21 @@ export async function loadSettings(): Promise<Settings> {
             if (!('allowFallback' in parsed)) {
                 parsed.allowFallback = true;
             }
+            if (!('createPlaylistFolder' in parsed)) {
+                parsed.createPlaylistFolder = true;
+            }
+            if (!('createM3u8File' in parsed)) {
+                parsed.createM3u8File = false;
+            }
+            if (!('useFirstArtistOnly' in parsed)) {
+                parsed.useFirstArtistOnly = false;
+            }
+            if (!('useSingleGenre' in parsed)) {
+                parsed.useSingleGenre = false;
+            }
+            if (!('embedGenre' in parsed)) {
+                parsed.embedGenre = true;
+            }
             cachedSettings = { ...DEFAULT_SETTINGS, ...parsed };
             return cachedSettings!;
         }
@@ -315,6 +339,7 @@ export interface TemplateData {
     track?: number;
     disc?: number;
     year?: string;
+    date?: string;
     playlist?: string;
 }
 export function parseTemplate(template: string, data: TemplateData): string {
@@ -328,6 +353,7 @@ export function parseTemplate(template: string, data: TemplateData): string {
     result = result.replace(/\{track\}/g, data.track ? String(data.track).padStart(2, "0") : "00");
     result = result.replace(/\{disc\}/g, data.disc ? String(data.disc) : "1");
     result = result.replace(/\{year\}/g, data.year || "0000");
+    result = result.replace(/\{date\}/g, data.date || "0000-00-00");
     result = result.replace(/\{playlist\}/g, data.playlist || "");
     return result;
 }
@@ -344,6 +370,7 @@ export async function saveSettings(settings: Settings): Promise<void> {
         cachedSettings = settings;
         localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings));
         await SaveToBackend(settings as any);
+        window.dispatchEvent(new CustomEvent('settingsUpdated', { detail: settings }));
     }
     catch (error) {
         console.error("Failed to save settings:", error);

frontend/src/lib/utils.ts

@@ -6,7 +6,7 @@ export function cn(...inputs: ClassValue[]) {
     return twMerge(clsx(inputs));
 }
 export function sanitizePath(input: string, os: string): string {
-    let sanitized = input.trim();
+    const sanitized = input.trim();
     if (os === "Windows") {
         return sanitized.replace(/[<>:"/\\|?*]/g, "_");
     }
@@ -46,3 +46,10 @@ export function openExternal(url: string) {
         }
     }
 }
+export function getFirstArtist(artistString: string): string {
+    if (!artistString)
+        return artistString;
+    const delimiters = /[,&]|(?:\s+(?:feat\.?|ft\.?|featuring)\s+)/i;
+    const parts = artistString.split(delimiters);
+    return parts[0].trim();
+}

frontend/src/types/api.ts

@@ -16,7 +16,6 @@ export interface TrackMetadata {
     total_discs?: number;
     disc_number?: number;
     external_urls: string;
-    isrc: string;
     album_type?: string;
     spotify_id?: string;
     album_id?: string;
@@ -109,8 +108,7 @@ export interface ArtistResponse {
 }
 export type SpotifyMetadataResponse = TrackResponse | AlbumResponse | PlaylistResponse | ArtistDiscographyResponse | ArtistResponse;
 export interface DownloadRequest {
-    isrc: string;
-    service: "tidal" | "qobuz" | "amazon";
+    service: "tidal" | "qobuz" | "amazon" | "deezer";
     query?: string;
     track_name?: string;
     artist_name?: string;
@@ -139,6 +137,9 @@ export interface DownloadRequest {
     copyright?: string;
     publisher?: string;
     spotify_url?: string;
+    use_first_artist_only?: boolean;
+    use_single_genre?: boolean;
+    embed_genre?: boolean;
 }
 export interface DownloadResponse {
     success: boolean;
@@ -203,9 +204,11 @@ export interface TrackAvailability {
     tidal: boolean;
     amazon: boolean;
     qobuz: boolean;
+    deezer: boolean;
     tidal_url?: string;
     amazon_url?: string;
     qobuz_url?: string;
+    deezer_url?: string;
 }
 export interface CoverDownloadRequest {
     cover_url: string;

go.mod

@@ -1,6 +1,6 @@
-module spotiflac
+module github.com/afkarxyz/SpotiFLAC
 
-go 1.25.5
+go 1.26
 
 require (
 	github.com/bogem/id3v2/v2 v2.1.4
@@ -12,6 +12,7 @@ require (
 	github.com/ulikunitz/xz v0.5.15
 	github.com/wailsapp/wails/v2 v2.11.0
 	go.etcd.io/bbolt v1.4.3
+	golang.org/x/text v0.31.0
 )
 
 require (
@@ -45,5 +46,4 @@ require (
 	golang.org/x/crypto v0.45.0 // indirect
 	golang.org/x/net v0.47.0 // indirect
 	golang.org/x/sys v0.38.0 // indirect
-	golang.org/x/text v0.31.0 // indirect
 )

main.go

@@ -2,8 +2,11 @@ package main
 
 import (
 	"embed"
+	"encoding/json"
 	"log"
 
+	"github.com/afkarxyz/SpotiFLAC/backend"
+
 	"github.com/wailsapp/wails/v2"
 	"github.com/wailsapp/wails/v2/pkg/options"
 	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
@@ -13,8 +16,21 @@ import (
 //go:embed all:frontend/dist
 var assets embed.FS
 
+//go:embed wails.json
+var wailsJSON []byte
+
 func main() {
 
+	type wailsInfo struct {
+		Info struct {
+			ProductVersion string `json:"productVersion"`
+		} `json:"info"`
+	}
+	var config wailsInfo
+	if err := json.Unmarshal(wailsJSON, &config); err == nil && config.Info.ProductVersion != "" {
+		backend.AppVersion = config.Info.ProductVersion
+	}
+
 	app := NewApp()
 
 	err := wails.Run(&options.App{

wails.json

@@ -12,7 +12,7 @@
   },
   "info": {
     "productName": "SpotiFLAC",
-    "productVersion": "7.0.7",
+    "productVersion": "7.1.0",
     "copyright": "© 2026 afkarxyz"
   },
   "wailsjsdir": "./frontend",