app.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	goruntime "runtime"
	"strconv"
	"strings"
	"sync"
	"time"

	core "github.com/kushiemoon-dev/flacidal-core"

	"github.com/wailsapp/wails/v2/pkg/runtime"
)

// App struct - main Wails application
type App struct {
	ctx             context.Context
	config          *core.Config
	db              *core.Database
	tidalClient     *core.TidalClient
	spotifySearch   *core.SpotifyClient    // For search/matching (Client Credentials, no login)
	matcher         *core.Matcher
	downloader      *core.TidalHifiService // FLAC downloader
	downloadManager *core.DownloadManager  // Concurrent download manager
	logBuffer       *core.LogBuffer        // Log buffer for Terminal page
	sourceManager   *core.SourceManager    // Multi-source manager
	tidalSource     *core.TidalSource      // Tidal source
	qobuzSource     *core.QobuzSource      // Qobuz source
	trackContentMap sync.Map                  // maps trackID (int) → contentID (string) for history tracking
}

// NewApp creates a new App application struct
func NewApp() *App {
	return &App{}
}

// startup is called when the app starts
func (a *App) startup(ctx context.Context) {
	a.ctx = ctx

	// Initialize log buffer
	a.logBuffer = core.NewLogBuffer(500)
	a.logBuffer.Info("FLACidal starting...")

	// Load config
	config, err := core.LoadConfig()
	if err != nil {
		a.logBuffer.Warn("Could not load config: " + err.Error())
		config = &core.Config{}
	}
	a.config = config
	a.logBuffer.Success("Configuration loaded")

	// Initialize database
	db, err := core.NewDatabase()
	if err != nil {
		a.logBuffer.Error("Database initialization failed: " + err.Error())
	} else {
		a.logBuffer.Success("Database initialized")
	}
	a.db = db

	// Initialize Tidal client (uses internal credentials, no user config needed)
	a.tidalClient = core.NewTidalClientDefault()
	a.tidalClient.SetCountryCode(config.CountryCode)
	if config.ProxyURL != "" {
		if err := a.tidalClient.SetProxy(config.ProxyURL); err != nil {
			a.logBuffer.Warn("Proxy config error (Tidal API): " + err.Error())
		} else {
			a.logBuffer.Info("Tidal API proxy: " + config.ProxyURL)
		}
	}
	a.logBuffer.Info("Tidal client ready")

	// Initialize Spotify search client (Client Credentials, no login needed)
	a.spotifySearch = core.NewSpotifyClientForSearch()

	// Initialize matcher
	a.matcher = core.NewMatcher(a.spotifySearch, a.db)

	// Initialize FLAC downloader
	a.downloader = core.NewTidalHifiService()
	// Attach logger so endpoint rotation events appear in Terminal page
	a.downloader.SetLogger(a.logBuffer)
	if config.ProxyURL != "" {
		if err := a.downloader.SetProxy(config.ProxyURL); err != nil {
			a.logBuffer.Warn("Proxy config error (downloader): " + err.Error())
		}
	}
	// Apply custom endpoints if configured
	if len(config.TidalHifiEndpoints) > 0 {
		a.downloader.SetEndpoints(config.TidalHifiEndpoints)
		a.logBuffer.Info(fmt.Sprintf("Tidal HiFi endpoint pool: %d endpoints configured", len(config.TidalHifiEndpoints)))
	}
	// Set download options from config
	quality := config.DownloadQuality
	if quality == "" {
		quality = "LOSSLESS"
	}
	fileNameFormat := config.FileNameFormat
	if fileNameFormat == "" {
		fileNameFormat = "{artist} - {title}"
	}
	a.downloader.SetOptions(core.DownloadOptions{
		Quality:              quality,
		FileNameFormat:       fileNameFormat,
		OrganizeFolders:      config.OrganizeFolders,
		FolderTemplate:       config.FolderTemplate,
		EmbedCover:           config.EmbedCover,
		SaveCoverFile:        config.SaveCoverFile,
		AutoAnalyze:          config.AutoAnalyze,
		AutoQualityFallback:  config.AutoQualityFallback,
		QualityFallbackOrder: config.QualityOrder,
		FirstArtistOnly:      config.FirstArtistOnly,
		SkipExisting:         config.SkipExisting,
		ArtistSeparator:      config.ArtistSeparator,
		PlaylistSubfolder:    config.PlaylistSubfolder,
		SaveLyricsFile:       config.SaveLyricsFile,
		SaveFolderCover:      config.SaveFolderCover,
	})
	a.logBuffer.Info("FLAC downloader service ready")

	// Initialize download manager with 4 concurrent workers
	a.downloadManager = core.NewDownloadManager(a.downloader, 4)

	// Serialized event channel to avoid concurrent ExecuteJS calls that crash WebKit on Linux.
	// Events are queued and emitted one at a time from a dedicated goroutine.
	type progressEvent struct {
		trackID int
		status  string
		result  *core.DownloadResult
	}
	eventCh := make(chan progressEvent, 64)
	go func() {
		for ev := range eventCh {
			runtime.EventsEmit(ctx, "download-progress", map[string]interface{}{
				"trackId": ev.trackID,
				"status":  ev.status,
				"result":  ev.result,
			})
			// Small delay between events to let WebKit/GTK process JS
			time.Sleep(50 * time.Millisecond)
		}
	}()

	a.downloadManager.SetProgressCallback(func(trackID int, status string, result *core.DownloadResult) {
		// Log download events
		if a.logBuffer != nil {
			switch status {
			case "queued":
				a.logBuffer.Info(fmt.Sprintf("Track %d added to queue", trackID))
			case "downloading":
				a.logBuffer.Info(fmt.Sprintf("Downloading track %d...", trackID))
			case "completed":
				if result != nil {
					a.logBuffer.Success(fmt.Sprintf("Downloaded: %s (quality: %s)", result.FilePath, result.Quality))
					if result.QualityMismatch {
						a.logBuffer.Warn(fmt.Sprintf("Quality mismatch: requested %s but got %s",
							result.RequestedQuality, result.Quality))
					}
					if result.Analysis != nil {
						if result.Analysis.IsTrueLossless {
							a.logBuffer.Info(fmt.Sprintf("Analysis: %s - True lossless", result.Analysis.VerdictLabel))
						} else {
							a.logBuffer.Warn(fmt.Sprintf("Analysis: %s - May be upscaled from lossy source", result.Analysis.VerdictLabel))
						}
					}
				}
			case "error":
				if result != nil && result.Error != "" {
					a.logBuffer.Error(fmt.Sprintf("Download failed: %s", result.Error))
				}
			case "cancelled":
				a.logBuffer.Warn(fmt.Sprintf("Track %d cancelled", trackID))
			}
		}

		// Update download history counts
		if a.db != nil {
			switch status {
			case "completed":
				if cid, ok := a.trackContentMap.Load(trackID); ok {
					_ = a.db.IncrementDownloadCounts(cid.(string), true)
					a.trackContentMap.Delete(trackID)
				}
			case "error":
				if cid, ok := a.trackContentMap.Load(trackID); ok {
					_ = a.db.IncrementDownloadCounts(cid.(string), false)
					a.trackContentMap.Delete(trackID)
				}
			}
		}

		// Queue event for serialized emission (blocking — workers wait
		// briefly if buffer is full, which is negligible vs download time)
		eventCh <- progressEvent{trackID, status, result}
	})
	a.downloadManager.Start()
	a.logBuffer.Success("Download manager started (4 workers)")

	// Initialize source manager
	a.sourceManager = core.NewSourceManager()

	// Initialize Tidal source
	a.tidalSource = core.NewTidalSource()
	a.tidalSource.SetAvailable(config.TidalEnabled)
	a.sourceManager.RegisterSource(a.tidalSource)
	a.logBuffer.Info("Tidal source registered")

	// Initialize Qobuz source
	a.qobuzSource = core.NewQobuzSource(config.QobuzAppID, config.QobuzAppSecret)
	a.qobuzSource.SetLogger(a.logBuffer)
	if config.ProxyURL != "" {
		if err := a.qobuzSource.SetProxy(config.ProxyURL); err != nil {
			a.logBuffer.Warn("Proxy config error (Qobuz): " + err.Error())
		}
	}
	if len(config.QobuzEndpoints) > 0 {
		a.qobuzSource.SetEndpoints(config.QobuzEndpoints)
		a.logBuffer.Info(fmt.Sprintf("Qobuz endpoint pool: %d endpoints configured", len(config.QobuzEndpoints)))
	}
	if config.QobuzAuthToken != "" {
		a.qobuzSource.SetCredentials(config.QobuzAppID, config.QobuzAppSecret, config.QobuzAuthToken)
	}
	a.sourceManager.RegisterSource(a.qobuzSource)
	if config.QobuzEnabled && config.QobuzAppID != "" {
		a.logBuffer.Info("Qobuz source registered")
	}

	// Set preferred source
	if config.PreferredSource != "" {
		a.sourceManager.SetPreferredSource(config.PreferredSource)
	}

	// Configure inter-source fallback for download manager
	if config.QobuzEnabled && a.qobuzSource.IsAvailable() {
		a.downloadManager.SetFallbackQobuzSource(a.qobuzSource)
	}
	sourceOrder := config.SourceOrder
	if len(sourceOrder) == 0 {
		// Default: prefer Tidal, fall back to Qobuz if enabled
		if config.QobuzEnabled {
			sourceOrder = []string{"tidal", "qobuz"}
		} else {
			sourceOrder = []string{"tidal"}
		}
	}
	a.downloadManager.SetSourceOrder(sourceOrder)
	a.downloadManager.SetGenerateM3U8(config.GenerateM3U8)
	a.downloadManager.SetSkipUnavailable(config.SkipUnavailableTracks)

	a.logBuffer.Success("FLACidal ready!")
}

// shutdown is called when the app is closing
func (a *App) shutdown(ctx context.Context) {
	// Stop download manager
	if a.downloadManager != nil {
		a.downloadManager.Stop()
	}

	// Save config
	if a.config != nil {
		core.SaveConfig(a.config)
	}

	// Close database
	if a.db != nil {
		a.db.Close()
	}
}

// =============================================================================
// Config Methods (exposed to frontend)
// =============================================================================

// GetConfig returns current configuration
func (a *App) GetConfig() *core.Config {
	return a.config
}

// SaveConfig saves configuration
func (a *App) SaveConfig(config core.Config) error {
	a.config = &config
	if a.downloadManager != nil {
		a.downloadManager.SetGenerateM3U8(config.GenerateM3U8)
		a.downloadManager.SetSkipUnavailable(config.SkipUnavailableTracks)
	}
	if a.downloader != nil {
		opts := a.downloader.GetOptions()
		opts.AutoQualityFallback = config.AutoQualityFallback
		opts.QualityFallbackOrder = config.QualityOrder
		opts.FirstArtistOnly = config.FirstArtistOnly
		opts.SkipExisting = config.SkipExisting
		opts.ArtistSeparator = config.ArtistSeparator
		opts.PlaylistSubfolder = config.PlaylistSubfolder
		if config.DownloadQuality != "" {
			opts.Quality = config.DownloadQuality
		}
		if config.FileNameFormat != "" {
			opts.FileNameFormat = config.FileNameFormat
		}
		opts.OrganizeFolders = config.OrganizeFolders
		opts.FolderTemplate = config.FolderTemplate
		opts.EmbedCover = config.EmbedCover
		opts.SaveCoverFile = config.SaveCoverFile
		opts.AutoAnalyze = config.AutoAnalyze
		opts.SaveLyricsFile = config.SaveLyricsFile
		opts.SaveFolderCover = config.SaveFolderCover
		a.downloader.SetOptions(opts)
	}
	if a.downloadManager != nil {
		a.downloadManager.SetSourceOrder(config.SourceOrder)
	}
	// Apply proxy changes immediately (no restart needed)
	if a.tidalClient != nil {
		if err := a.tidalClient.SetProxy(config.ProxyURL); err != nil {
			a.logBuffer.Warn("Proxy config error (Tidal API): " + err.Error())
		}
	}
	if a.downloader != nil {
		if err := a.downloader.SetProxy(config.ProxyURL); err != nil {
			a.logBuffer.Warn("Proxy config error (downloader): " + err.Error())
		}
	}
	if a.qobuzSource != nil {
		if err := a.qobuzSource.SetProxy(config.ProxyURL); err != nil {
			a.logBuffer.Warn("Proxy config error (Qobuz): " + err.Error())
		}
	}
	return core.SaveConfig(&config)
}

// ResetToDefaults resets configuration to default values
func (a *App) ResetToDefaults() (*core.Config, error) {
	defaultCfg := core.GetDefaultConfig()

	// Preserve download folder if set
	if a.config != nil && a.config.DownloadFolder != "" {
		defaultCfg.DownloadFolder = a.config.DownloadFolder
	}

	a.config = defaultCfg
	if err := core.SaveConfig(defaultCfg); err != nil {
		return nil, err
	}

	if a.logBuffer != nil {
		a.logBuffer.Info("Configuration reset to defaults")
		runtime.EventsEmit(a.ctx, "log", a.logBuffer.Info("Settings restored to defaults"))
	}

	return defaultCfg, nil
}

// GetConnectionStatus returns service status
func (a *App) GetConnectionStatus() map[string]interface{} {
	return map[string]interface{}{
		"tidalReady":    true, // Always ready (uses internal credentials)
		"spotifySearch": a.spotifySearch != nil,
	}
}

// EndpointStatus represents the status of an API endpoint
type EndpointStatus struct {
	Name      string `json:"name"`
	URL       string `json:"url"`
	Status    string `json:"status"`    // "online", "offline", "slow"
	LatencyMs int64  `json:"latencyMs"` // Response time in milliseconds
}

// CheckAPIStatus checks the status of all configured API endpoints
func (a *App) CheckAPIStatus() []EndpointStatus {
	endpoints := []struct {
		name string
		url  string
	}{
		{"Tidal HiFi Proxy", "https://vogel.qqdl.site"},
		{"Metadata (hifi-one)", "https://hifi-one.spotisaver.net"},
		{"Metadata (hifi-two)", "https://hifi-two.spotisaver.net"},
		{"Metadata (triton)", "https://triton.squid.wtf"},
		{"Tidal API", "https://api.tidalhifi.com"},
	}

	// Add Qobuz if enabled
	if a.config != nil && a.config.QobuzEnabled {
		endpoints = append(endpoints, struct {
			name string
			url  string
		}{"Qobuz API", "https://www.qobuz.com/api.json/0.2"})
	}

	results := make([]EndpointStatus, len(endpoints))
	var wg sync.WaitGroup
	client := &http.Client{Timeout: 10 * time.Second}

	for i, ep := range endpoints {
		wg.Add(1)
		go func(idx int, name, url string) {
			defer wg.Done()
			status := EndpointStatus{Name: name, URL: url}

			start := time.Now()
			resp, err := client.Head(url)
			latency := time.Since(start)
			status.LatencyMs = latency.Milliseconds()

			if err != nil {
				status.Status = "offline"
			} else {
				resp.Body.Close()
				if resp.StatusCode >= 500 {
					status.Status = "offline"
				} else if latency > 3*time.Second {
					status.Status = "slow"
				} else {
					status.Status = "online"
				}
			}
			results[idx] = status
		}(i, ep.name, ep.url)
	}

	wg.Wait()
	return results
}

// OpenConfigFolder opens the app config directory in the system file manager
func (a *App) OpenConfigFolder() error {
	configDir := core.GetDataDir()
	return openFolder(configDir)
}

// openFolder opens a folder in the system file manager
func openFolder(path string) error {
	switch goruntime.GOOS {
	case "darwin":
		return exec.Command("open", path).Start()
	case "windows":
		return exec.Command("explorer", path).Start()
	default:
		return exec.Command("xdg-open", path).Start()
	}
}

// =============================================================================
// Tidal Methods (exposed to frontend)
// =============================================================================

// SetTidalCredentials saves Tidal client credentials
func (a *App) SetTidalCredentials(clientID, clientSecret string) error {
	a.config.TidalClientID = clientID
	a.config.TidalClientSecret = clientSecret

	// Initialize client with new credentials
	a.tidalClient = core.NewTidalClient(clientID, clientSecret)

	return core.SaveConfig(a.config)
}

// FetchTidalPlaylist fetches a public playlist from Tidal URL
func (a *App) FetchTidalPlaylist(url string) (*core.TidalPlaylist, error) {
	// Parse URL to get playlist UUID
	id, contentType, err := core.ParseTidalURL(url)
	if err != nil {
		return nil, err
	}

	if contentType != "playlist" {
		return nil, fmt.Errorf("URL is not a playlist (got %s)", contentType)
	}

	return a.downloader.GetPlaylistFromProxy(id)
}

// FetchTidalContent fetches playlist, album, or single track from any Tidal URL
func (a *App) FetchTidalContent(url string) (map[string]interface{}, error) {
	id, contentType, err := core.ParseTidalURL(url)
	if err != nil {
		return nil, err
	}

	result := map[string]interface{}{
		"type": contentType,
		"id":   id,
	}

	switch contentType {
	case "playlist":
		playlist, err := a.downloader.GetPlaylistFromProxy(id)
		if err != nil {
			return nil, err
		}
		result["title"] = playlist.Title
		result["creator"] = playlist.Creator
		result["coverUrl"] = playlist.CoverURL
		result["tracks"] = playlist.Tracks
		result["trackCount"] = len(playlist.Tracks)

	case "album":
		album, err := a.downloader.GetAlbumFromProxy(id)
		if err != nil {
			return nil, err
		}
		result["title"] = album.Title
		result["creator"] = album.Artist
		result["coverUrl"] = album.CoverURL
		result["tracks"] = album.Tracks
		result["trackCount"] = len(album.Tracks)
		result["albumType"] = album.AlbumType

	case "track":
		trackIDInt, convErr := strconv.Atoi(id)
		if convErr != nil {
			return nil, fmt.Errorf("invalid track ID: %s", id)
		}
		track, err := a.downloader.GetTrackAsTidalTrack(trackIDInt)
		if err != nil {
			return nil, err
		}
		result["title"] = track.Title
		result["creator"] = track.Artist
		result["coverUrl"] = track.CoverURL
		result["tracks"] = []core.TidalTrack{*track}
		result["trackCount"] = 1

	case "mix":
		mix, err := a.downloader.GetMixFromProxy(id)
		if err != nil {
			return nil, err
		}
		result["title"] = mix.Title
		result["creator"] = mix.Creator
		result["coverUrl"] = mix.CoverURL
		result["tracks"] = mix.Tracks
		result["trackCount"] = len(mix.Tracks)

	case "artist":
		artist, err := a.tidalClient.GetArtistDiscography(id)
		if err != nil {
			return nil, err
		}
		result["title"] = artist.Name
		result["creator"] = artist.Name
		result["coverUrl"] = artist.PictureURL
		result["albums"] = artist.Albums
		result["albumCount"] = len(artist.Albums)
		result["artistId"] = artist.ID
		result["tracks"] = []core.TidalTrack{} // empty — tracks loaded per album

	default:
		return nil, fmt.Errorf("unsupported content type: %s", contentType)
	}

	return result, nil
}

// ValidateTidalURL checks if a URL is a valid Tidal URL
func (a *App) ValidateTidalURL(url string) map[string]interface{} {
	id, contentType, err := core.ParseTidalURL(url)
	if err != nil {
		return map[string]interface{}{
			"valid": false,
			"error": err.Error(),
		}
	}
	return map[string]interface{}{
		"valid": true,
		"id":    id,
		"type":  contentType,
	}
}

// =============================================================================
// Database Methods (exposed to frontend)
// =============================================================================

// GetCacheStats returns track cache statistics
func (a *App) GetCacheStats() map[string]interface{} {
	if a.db == nil {
		return map[string]interface{}{"error": "database not initialized"}
	}

	total, byMethod, err := a.db.GetCacheStats()
	if err != nil {
		return map[string]interface{}{"error": err.Error()}
	}

	return map[string]interface{}{
		"total":    total,
		"byMethod": byMethod,
	}
}

// GetDownloadHistory returns all download history
func (a *App) GetDownloadHistory() ([]core.DownloadRecord, error) {
	if a.db == nil {
		return nil, nil
	}
	return a.db.GetAllDownloadRecords()
}

// GetDownloadHistoryFiltered returns filtered download history with pagination
func (a *App) GetDownloadHistoryFiltered(filter map[string]interface{}) (map[string]interface{}, error) {
	if a.db == nil {
		return nil, fmt.Errorf("database not initialized")
	}

	// Parse filter options
	dbFilter := core.HistoryFilter{}

	if ct, ok := filter["contentType"].(string); ok {
		dbFilter.ContentType = ct
	}
	if search, ok := filter["search"].(string); ok {
		dbFilter.Search = search
	}
	if limit, ok := filter["limit"].(float64); ok {
		dbFilter.Limit = int(limit)
	}
	if offset, ok := filter["offset"].(float64); ok {
		dbFilter.Offset = int(offset)
	}

	records, total, err := a.db.GetDownloadRecordsFiltered(dbFilter)
	if err != nil {
		return nil, err
	}

	return map[string]interface{}{
		"records": records,
		"total":   total,
	}, nil
}

// DeleteHistoryRecord deletes a single download history record
func (a *App) DeleteHistoryRecord(id int64) error {
	if a.db == nil {
		return fmt.Errorf("database not initialized")
	}
	return a.db.DeleteDownloadRecord(id)
}

// ClearDownloadHistory removes all download history
func (a *App) ClearDownloadHistory() error {
	if a.db == nil {
		return fmt.Errorf("database not initialized")
	}
	err := a.db.ClearAllHistory()
	if err == nil && a.logBuffer != nil {
		a.logBuffer.Info("Download history cleared")
	}
	return err
}

// RefetchFromHistory re-downloads content from history
func (a *App) RefetchFromHistory(tidalContentID string) (map[string]interface{}, error) {
	if a.db == nil {
		return nil, fmt.Errorf("database not initialized")
	}

	// Get the record to find the content type
	record, err := a.db.GetDownloadRecord(tidalContentID)
	if err != nil {
		return nil, err
	}
	if record == nil {
		return nil, fmt.Errorf("history record not found")
	}

	// Reconstruct the Tidal URL
	var url string
	switch record.ContentType {
	case "playlist":
		url = fmt.Sprintf("https://tidal.com/browse/playlist/%s", tidalContentID)
	case "album":
		url = fmt.Sprintf("https://tidal.com/browse/album/%s", tidalContentID)
	case "track":
		url = fmt.Sprintf("https://tidal.com/browse/track/%s", tidalContentID)
	default:
		return nil, fmt.Errorf("unknown content type: %s", record.ContentType)
	}

	// Fetch the content
	return a.FetchTidalContent(url)
}

// GetMatchFailures returns all match failures
func (a *App) GetMatchFailures() ([]core.MatchFailure, error) {
	if a.db == nil {
		return nil, nil
	}
	return a.db.GetMatchFailures()
}

// =============================================================================
// App Info
// =============================================================================

// GetAppVersion returns application version
func (a *App) GetAppVersion() string {
	return "4.0.5"
}

// UpdateInfo represents available update information
type UpdateInfo struct {
	HasUpdate  bool   `json:"hasUpdate"`
	Version    string `json:"version"`
	URL        string `json:"url"`
	ReleaseURL string `json:"releaseUrl"`
}

// CheckForUpdate checks GitHub for a newer release
func (a *App) CheckForUpdate() (*UpdateInfo, error) {
	client := &http.Client{Timeout: 10 * time.Second}
	req, err := http.NewRequest("GET", "https://api.github.com/repos/kushiemoon-dev/flacidal/releases/latest", nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Accept", "application/vnd.github.v3+json")
	req.Header.Set("User-Agent", "FLACidal/"+a.GetAppVersion())

	resp, err := client.Do(req)
	if err != nil {
		return &UpdateInfo{HasUpdate: false}, nil
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return &UpdateInfo{HasUpdate: false}, nil
	}

	var release struct {
		TagName string `json:"tag_name"`
		HTMLURL string `json:"html_url"`
		Assets  []struct {
			BrowserDownloadURL string `json:"browser_download_url"`
		} `json:"assets"`
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return &UpdateInfo{HasUpdate: false}, nil
	}

	if err := json.Unmarshal(body, &release); err != nil {
		return &UpdateInfo{HasUpdate: false}, nil
	}

	latestVersion := strings.TrimPrefix(release.TagName, "v")
	currentVersion := a.GetAppVersion()

	hasUpdate := latestVersion != currentVersion && latestVersion > currentVersion

	downloadURL := release.HTMLURL
	if len(release.Assets) > 0 {
		downloadURL = release.Assets[0].BrowserDownloadURL
	}

	return &UpdateInfo{
		HasUpdate:  hasUpdate,
		Version:    latestVersion,
		URL:        downloadURL,
		ReleaseURL: release.HTMLURL,
	}, nil
}

// =============================================================================
// Logging Methods (exposed to frontend)
// =============================================================================

// GetLogs returns all log entries
func (a *App) GetLogs() []core.LogEntry {
	if a.logBuffer == nil {
		return []core.LogEntry{}
	}
	return a.logBuffer.GetAll()
}

// ClearLogs clears all log entries
func (a *App) ClearLogs() {
	if a.logBuffer != nil {
		a.logBuffer.Clear()
	}
}

// AddLog adds a log entry (for testing/debug)
func (a *App) AddLog(level, message string) {
	if a.logBuffer != nil {
		entry := a.logBuffer.Add(level, message)
		// Emit log event to frontend
		runtime.EventsEmit(a.ctx, "log", entry)
	}
}

// =============================================================================
// Matcher Methods (exposed to frontend)
// =============================================================================

// MatchPlaylistTracks matches all tracks from a Tidal playlist to Spotify
func (a *App) MatchPlaylistTracks(tracks []core.TidalTrack) []core.MatchResult {
	if a.matcher == nil {
		return nil
	}
	return a.matcher.MatchPlaylist(tracks)
}

// MatchSingleTrack matches a single track
func (a *App) MatchSingleTrack(track core.TidalTrack) core.MatchResult {
	if a.matcher == nil {
		return core.MatchResult{TidalTrack: track, Matched: false, MatchMethod: "none"}
	}
	return a.matcher.MatchTrack(track)
}

// =============================================================================
// Download Methods (exposed to frontend)
// =============================================================================

// OpenFLACFilesDialog opens a multi-file picker filtered to FLAC files.
func (a *App) OpenFLACFilesDialog() ([]string, error) {
	paths, err := runtime.OpenMultipleFilesDialog(a.ctx, runtime.OpenDialogOptions{
		Title: "Select FLAC Files to Analyze",
		Filters: []runtime.FileFilter{
			{DisplayName: "FLAC Audio (*.flac)", Pattern: "*.flac"},
		},
	})
	if err != nil {
		return nil, err
	}
	return paths, nil
}

// SelectDownloadFolder opens a folder picker dialog
func (a *App) SelectDownloadFolder() (string, error) {
	folder, err := runtime.OpenDirectoryDialog(a.ctx, runtime.OpenDialogOptions{
		Title: "Select Download Folder",
	})
	if err != nil {
		return "", err
	}
	return folder, nil
}

// GetDownloadFolder returns the configured download folder
func (a *App) GetDownloadFolder() string {
	if a.config != nil && a.config.DownloadFolder != "" {
		return a.config.DownloadFolder
	}
	return ""
}

// SetDownloadFolder saves the download folder to config
func (a *App) SetDownloadFolder(folder string) error {
	if a.config == nil {
		a.config = &core.Config{}
	}
	a.config.DownloadFolder = folder
	return core.SaveConfig(a.config)
}

// IsDownloaderAvailable checks if the download service is reachable
func (a *App) IsDownloaderAvailable() bool {
	if a.downloader == nil {
		return false
	}
	return a.downloader.IsAvailable()
}

// DownloadTrack downloads a single track by its Tidal ID
func (a *App) DownloadTrack(trackID int, outputDir string) (*core.DownloadResult, error) {
	if a.downloader == nil {
		return nil, fmt.Errorf("downloader not initialized")
	}
	if outputDir == "" {
		return nil, fmt.Errorf("no output directory specified")
	}
	return a.downloader.DownloadTrack(trackID, outputDir, "", "")
}

// DownloadTrackFromTidal downloads using TidalTrack data (for UI convenience)
func (a *App) DownloadTrackFromTidal(track core.TidalTrack, outputDir string) (*core.DownloadResult, error) {
	if a.downloader == nil {
		return nil, fmt.Errorf("downloader not initialized")
	}
	if outputDir == "" {
		return nil, fmt.Errorf("no output directory specified")
	}
	return a.downloader.DownloadTrack(track.ID, outputDir, track.Copyright, track.Label)
}

// QueueDownloads queues multiple tracks for concurrent download
func (a *App) QueueDownloads(tracks []core.TidalTrack, outputDir string, contentName string, contentID string, contentType string) (int, error) {
	if a.downloadManager == nil {
		return 0, fmt.Errorf("download manager not initialized")
	}
	if outputDir == "" {
		return 0, fmt.Errorf("no output directory specified")
	}

	// Create subfolder with content name (playlist/album/track title)
	if contentName != "" {
		outputDir = filepath.Join(outputDir, core.SanitizeFileName(contentName))
		if err := os.MkdirAll(outputDir, 0755); err != nil {
			return 0, fmt.Errorf("failed to create folder: %w", err)
		}
	}

	queued := a.downloadManager.QueueMultiple(tracks, outputDir)

	// Save initial history record
	if a.db != nil && contentID != "" {
		_ = a.db.SaveDownloadRecord(&core.DownloadRecord{
			TidalContentID:   contentID,
			TidalContentName: contentName,
			ContentType:      contentType,
			TracksTotal:      queued,
		})
	}
	// Map each trackID → contentID for progress callback
	for _, t := range tracks {
		a.trackContentMap.Store(t.ID, contentID)
	}

	return queued, nil
}

// QueueQobuzDownloads queues Qobuz-sourced tracks for concurrent download
func (a *App) QueueQobuzDownloads(tracks []core.SourceTrack, outputDir string, contentName string) (int, error) {
	if a.downloadManager == nil {
		return 0, fmt.Errorf("download manager not initialized")
	}
	if outputDir == "" {
		return 0, fmt.Errorf("no output directory specified")
	}
	if contentName != "" {
		outputDir = filepath.Join(outputDir, core.SanitizeFileName(contentName))
		if err := os.MkdirAll(outputDir, 0755); err != nil {
			return 0, fmt.Errorf("failed to create folder: %w", err)
		}
	}
	return a.downloadManager.QueueQobuzTracks(tracks, outputDir), nil
}

// QueueArtistAlbum fetches a Tidal album's tracks and queues them all for download.
// outputDir should be the artist folder; an album subfolder is created automatically.
func (a *App) QueueArtistAlbum(albumID string, artistName string, outputDir string) (int, error) {
	if a.downloadManager == nil {
		return 0, fmt.Errorf("download manager not initialized")
	}
	if outputDir == "" {
		return 0, fmt.Errorf("no output directory specified")
	}

	album, err := a.downloader.GetAlbumFromProxy(albumID)
	if err != nil {
		return 0, fmt.Errorf("failed to fetch album: %w", err)
	}

	// Create {Artist}/{Album} folder structure
	artistFolder := core.SanitizeFileName(artistName)
	if artistFolder == "" {
		artistFolder = core.SanitizeFileName(album.Artist)
	}
	albumFolder := core.SanitizeFileName(album.Title)
	albumDir := filepath.Join(outputDir, artistFolder, albumFolder)
	if err := os.MkdirAll(albumDir, 0755); err != nil {
		return 0, fmt.Errorf("failed to create album folder: %w", err)
	}

	queued := a.downloadManager.QueueMultiple(album.Tracks, albumDir)
	return queued, nil
}

// DownloadArtistAssets downloads the artist's profile picture and banner image.
// Files are saved to {outputDir}/{artistName}/ as profile.jpg, profile_hires.jpg, banner.jpg.
// Returns the number of files successfully downloaded.
func (a *App) DownloadArtistAssets(artistID string, artistName string, outputDir string) (int, error) {
	if outputDir == "" {
		return 0, fmt.Errorf("no output directory specified")
	}

	name, pictureID, err := a.tidalClient.GetArtistPictureID(artistID)
	if err != nil {
		return 0, fmt.Errorf("failed to fetch artist info: %w", err)
	}
	if pictureID == "" {
		return 0, fmt.Errorf("artist has no picture available")
	}

	// Use fetched name if caller didn't provide one
	if artistName == "" {
		artistName = name
	}

	urls := core.ArtistImageURLs(pictureID)
	if len(urls) == 0 {
		return 0, fmt.Errorf("no image URLs generated")
	}

	// Save to {outputDir}/{artistName}/
	destDir := filepath.Join(outputDir, core.SanitizeFileName(artistName))
	if err := os.MkdirAll(destDir, 0755); err != nil {
		return 0, fmt.Errorf("failed to create artist folder: %w", err)
	}

	// Map of label → filename
	fileNames := map[string]string{
		"profile":       "profile.jpg",
		"profile_hires": "profile_hires.jpg",
		"banner":        "banner.jpg",
	}

	client := &http.Client{}
	downloaded := 0
	for label, imgURL := range urls {
		fname := fileNames[label]
		destPath := filepath.Join(destDir, fname)

		resp, err := client.Get(imgURL)
		if err != nil || resp.StatusCode != 200 {
			if resp != nil {
				resp.Body.Close()
			}
			continue // skip unavailable sizes
		}

		f, err := os.Create(destPath)
		if err != nil {
			resp.Body.Close()
			continue
		}
		_, copyErr := io.Copy(f, resp.Body)
		f.Close()
		resp.Body.Close()
		if copyErr == nil {
			downloaded++
		}
	}

	return downloaded, nil
}

// QueueSingleDownload queues a single track for download
func (a *App) QueueSingleDownload(trackID int, outputDir, title, artist string) error {
	if a.downloadManager == nil {
		return fmt.Errorf("download manager not initialized")
	}
	if outputDir == "" {
		return fmt.Errorf("no output directory specified")
	}

	err := a.downloadManager.QueueDownload(trackID, outputDir, title, artist)
	if err == nil && a.db != nil {
		contentID := strconv.Itoa(trackID)
		_ = a.db.SaveDownloadRecord(&core.DownloadRecord{
			TidalContentID:   contentID,
			TidalContentName: title,
			ContentType:      "track",
			TracksTotal:      1,
		})
		a.trackContentMap.Store(trackID, contentID)
	}
	return err
}

// GetDownloadQueueStatus returns current queue status
func (a *App) GetDownloadQueueStatus() map[string]interface{} {
	if a.downloadManager == nil {
		return map[string]interface{}{"running": false}
	}

	return map[string]interface{}{
		"running":     a.downloadManager.IsRunning(),
		"paused":      a.downloadManager.IsPaused(),
		"activeCount": a.downloadManager.GetActiveCount(),
		"queueLength": a.downloadManager.GetQueueLength(),
	}
}

// GetDownloadOptions returns current download options
func (a *App) GetDownloadOptions() map[string]interface{} {
	if a.config == nil {
		return map[string]interface{}{
			"quality":         "LOSSLESS",
			"fileNameFormat":  "{artist} - {title}",
			"organizeFolders": false,
			"embedCover":      true,
			"saveCoverFile":   true,
			"saveFolderCover": true,
			"autoAnalyze":     false,
		}
	}

	quality := a.config.DownloadQuality
	if quality == "" {
		quality = "LOSSLESS"
	}
	format := a.config.FileNameFormat
	if format == "" {
		format = "{artist} - {title}"
	}

	return map[string]interface{}{
		"quality":         quality,
		"fileNameFormat":  format,
		"organizeFolders": a.config.OrganizeFolders,
		"embedCover":      a.config.EmbedCover,
		"saveCoverFile":   a.config.SaveCoverFile,
		"saveFolderCover": a.config.SaveFolderCover,
		"autoAnalyze":     a.config.AutoAnalyze,
	}
}

// SetDownloadOptions updates download options
func (a *App) SetDownloadOptions(quality, fileNameFormat string, organizeFolders, embedCover, saveCoverFile, autoAnalyze bool) error {
	if a.config == nil {
		a.config = &core.Config{}
	}

	a.config.DownloadQuality = quality
	a.config.FileNameFormat = fileNameFormat
	a.config.OrganizeFolders = organizeFolders
	a.config.EmbedCover = embedCover
	a.config.SaveCoverFile = saveCoverFile
	a.config.AutoAnalyze = autoAnalyze

	// Update downloader options (preserve AutoQualityFallback from config)
	if a.downloader != nil {
		autoQualityFallback := false
		if a.config != nil {
			autoQualityFallback = a.config.AutoQualityFallback
		}
		a.downloader.SetOptions(core.DownloadOptions{
			Quality:             quality,
			FileNameFormat:      fileNameFormat,
			OrganizeFolders:     organizeFolders,
			EmbedCover:          embedCover,
			SaveCoverFile:       saveCoverFile,
			AutoAnalyze:         autoAnalyze,
			AutoQualityFallback: autoQualityFallback,
		})
	}

	return core.SaveConfig(a.config)
}

// OpenDownloadFolder opens the download folder in the system file manager
func (a *App) OpenDownloadFolder(folder string) error {
	if folder == "" {
		return fmt.Errorf("no folder specified")
	}
	runtime.BrowserOpenURL(a.ctx, "file://"+folder)
	return nil
}

// =============================================================================
// Search Methods (exposed to frontend)
// =============================================================================

// SearchTidal searches for tracks on Tidal
func (a *App) SearchTidal(query string) ([]core.TidalTrack, error) {
	if a.downloader == nil {
		return nil, fmt.Errorf("downloader not initialized")
	}

	results, err := a.downloader.SearchTracks(query, 50)
	if err != nil {
		return nil, err
	}

	// Convert to TidalTrack format for frontend
	tracks := make([]core.TidalTrack, len(results))
	for i, r := range results {
		// Build artist string
		var artists []string
		for _, art := range r.Artists {
			artists = append(artists, art.Name)
		}
		artistStr := ""
		if len(artists) > 0 {
			artistStr = artists[0]
		}
		allArtists := artistStr
		if len(artists) > 1 {
			allArtists = fmt.Sprintf("%s, %s", artists[0], artists[1])
			if len(artists) > 2 {
				allArtists += fmt.Sprintf(" +%d", len(artists)-2)
			}
		}

		// Build cover URL
		coverURL := ""
		if r.Album.Cover != "" {
			coverURL = fmt.Sprintf("https://resources.tidal.com/images/%s/320x320.jpg",
				core.FormatCoverUUID(r.Album.Cover))
		}

		tracks[i] = core.TidalTrack{
			ID:       r.ID,
			Title:    r.Title,
			Artist:   artistStr,
			Artists:  allArtists,
			Album:    r.Album.Title,
			Duration: r.Duration,
			ISRC:     r.ISRC,
			CoverURL: coverURL,
			Explicit: r.Explicit,
		}
	}

	return tracks, nil
}

// SearchTidalAlbums searches for albums on Tidal
func (a *App) SearchTidalAlbums(query string) ([]core.TidalAlbum, error) {
	if a.tidalSource == nil {
		return nil, fmt.Errorf("tidal source not initialized")
	}
	return a.tidalSource.SearchAlbums(query, 20)
}

// SearchTidalArtists searches for artists on Tidal
func (a *App) SearchTidalArtists(query string) ([]core.TidalArtist, error) {
	if a.tidalSource == nil {
		return nil, fmt.Errorf("tidal source not initialized")
	}
	return a.tidalSource.SearchArtists(query, 20)
}

// =============================================================================
// File Browser Methods (exposed to frontend)
// =============================================================================

// ListDownloadedFiles lists all downloaded FLAC files
func (a *App) ListDownloadedFiles() ([]core.DownloadedFileInfo, error) {
	folder := a.GetDownloadFolder()
	if folder == "" {
		return []core.DownloadedFileInfo{}, nil
	}

	return core.ListFLACFiles(folder)
}

// DeleteFile deletes a file from the filesystem
func (a *App) DeleteFile(path string) error {
	return core.DeleteFile(path)
}

// GetFileMetadata reads and returns metadata from a FLAC file
func (a *App) GetFileMetadata(filePath string) (*core.FLACMetadata, error) {
	return core.ReadFLACMetadata(filePath)
}

// GetFileCoverArt returns cover art as base64 encoded string
func (a *App) GetFileCoverArt(filePath string) (map[string]string, error) {
	base64Data, mimeType, err := core.GetCoverArtBase64(filePath)
	if err != nil {
		return nil, err
	}
	return map[string]string{
		"data":     base64Data,
		"mimeType": mimeType,
	}, nil
}

// GetRenameTemplates returns available rename templates
func (a *App) GetRenameTemplates() []map[string]string {
	return core.GetRenameTemplates()
}

// PreviewRename generates a preview of rename operations
func (a *App) PreviewRename(files []string, template string) []core.RenamePreview {
	return core.PreviewRename(files, template)
}

// RenameFiles renames files according to the template
func (a *App) RenameFiles(files []string, template string) []core.RenameResult {
	results := core.RenameFiles(files, template)

	// Log results
	if a.logBuffer != nil {
		success := 0
		failed := 0
		for _, r := range results {
			if r.Success {
				success++
			} else {
				failed++
			}
		}
		a.logBuffer.Info(fmt.Sprintf("Renamed %d files (%d failed)", success, failed))
	}

	return results
}

// =============================================================================
// Converter Methods (exposed to frontend)
// =============================================================================

// IsConverterAvailable checks if FFmpeg is available
func (a *App) IsConverterAvailable() bool {
	return core.IsConverterAvailable()
}

// GetFFmpegInfo returns FFmpeg availability and version
func (a *App) GetFFmpegInfo() map[string]interface{} {
	return core.GetFFmpegInfo()
}

// InstallFFmpeg downloads and installs FFmpeg, emitting progress events
func (a *App) InstallFFmpeg() error {
	progressCh := make(chan core.FFmpegInstallProgress, 10)

	go func() {
		for p := range progressCh {
			runtime.EventsEmit(a.ctx, "ffmpeg-install-progress", p)
		}
	}()

	err := core.InstallFFmpeg(progressCh)
	if err != nil {
		return err
	}

	// Reinitialize converter with new path
	core.ResetConverter()
	return nil
}

// GetFFmpegInstallStatus returns whether FFmpeg is available and if local install exists
func (a *App) GetFFmpegInstallStatus() map[string]interface{} {
	return map[string]interface{}{
		"systemAvailable": core.IsConverterAvailable(),
		"localInstalled":  core.IsFFmpegInstalledLocally(),
		"localPath":       core.GetLocalFFmpegPath(),
	}
}

// GetConversionFormats returns available conversion formats
func (a *App) GetConversionFormats() []core.ConversionFormat {
	conv := core.GetConverter()
	if conv == nil {
		return []core.ConversionFormat{}
	}
	return conv.GetFormats()
}

// ConvertFiles converts files to the specified format
func (a *App) ConvertFiles(files []string, format, quality, outputDir string, deleteSource bool) []core.ConversionResult {
	conv := core.GetConverter()
	if conv == nil {
		results := make([]core.ConversionResult, len(files))
		for i, f := range files {
			results[i] = core.ConversionResult{
				SourcePath: f,
				Error:      "FFmpeg not available",
			}
		}
		return results
	}

	opts := core.ConversionOptions{
		Format:       format,
		Quality:      quality,
		OutputDir:    outputDir,
		DeleteSource: deleteSource,
	}

	results := conv.ConvertMultiple(files, opts)

	// Log results
	if a.logBuffer != nil {
		success := 0
		for _, r := range results {
			if r.Success {
				success++
			}
		}
		a.logBuffer.Info(fmt.Sprintf("Converted %d/%d files to %s", success, len(files), format))
	}

	return results
}

// SelectFolderForConversion opens a directory dialog and returns paths of FLAC files within it
func (a *App) SelectFolderForConversion() ([]string, error) {
	dir, err := runtime.OpenDirectoryDialog(a.ctx, runtime.OpenDialogOptions{
		Title: "Select folder to convert",
	})
	if err != nil || dir == "" {
		return nil, err
	}
	files, err := core.ListFLACFiles(dir)
	if err != nil {
		return nil, err
	}
	paths := make([]string, len(files))
	for i, f := range files {
		paths[i] = f.Path
	}
	return paths, nil
}

// ConvertFolder converts all .flac files in a folder recursively
func (a *App) ConvertFolder(folderPath, format, quality, outputDir string, deleteSource bool) []core.ConversionResult {
	var files []string
	filepath.Walk(folderPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return nil
		}
		if !info.IsDir() && strings.EqualFold(filepath.Ext(path), ".flac") {
			files = append(files, path)
		}
		return nil
	})

	if len(files) == 0 {
		return nil
	}

	return a.ConvertFiles(files, format, quality, outputDir, deleteSource)
}

// OpenInFileManager opens the file's directory in the system file manager
func (a *App) OpenInFileManager(path string) error {
	runtime.BrowserOpenURL(a.ctx, "file://"+path)
	return nil
}

// RetryDownload retries a failed download
func (a *App) RetryDownload(trackID int) error {
	if a.downloadManager == nil {
		return fmt.Errorf("download manager not initialized")
	}

	folder := a.GetDownloadFolder()
	if folder == "" {
		return fmt.Errorf("no download folder configured")
	}

	return a.downloadManager.QueueDownload(trackID, folder, "", "")
}

// RetryAllFailed retries all failed downloads
func (a *App) RetryAllFailed() (int, error) {
	if a.downloadManager == nil {
		return 0, fmt.Errorf("download manager not initialized")
	}

	count := a.downloadManager.RetryAllFailed()
	return count, nil
}

// ExportFailedDownloads saves failed download info to a TXT or CSV file chosen by the user.
// format is "txt" or "csv". Returns the path of the saved file, or empty string if cancelled.
func (a *App) ExportFailedDownloads(format string) (string, error) {
	if a.downloadManager == nil {
		return "", fmt.Errorf("download manager not initialized")
	}
	jobs := a.downloadManager.GetFailedJobs()
	if len(jobs) == 0 {
		return "", nil
	}

	// Determine file filter and default name
	var filter []runtime.FileFilter
	var defaultFilename string
	if format == "csv" {
		filter = []runtime.FileFilter{{DisplayName: "CSV Files", Pattern: "*.csv"}}
		defaultFilename = "failed_downloads.csv"
	} else {
		filter = []runtime.FileFilter{{DisplayName: "Text Files", Pattern: "*.txt"}}
		defaultFilename = "failed_downloads.txt"
	}

	savePath, err := runtime.SaveFileDialog(a.ctx, runtime.SaveDialogOptions{
		DefaultFilename: defaultFilename,
		Filters:         filter,
	})
	if err != nil || savePath == "" {
		return "", err
	}

	var sb strings.Builder
	if format == "csv" {
		sb.WriteString("artist,title,url,error\n")
		for _, job := range jobs {
			url := fmt.Sprintf("https://tidal.com/browse/track/%d", job.TrackID)
			sb.WriteString(fmt.Sprintf("%q,%q,%q,%q\n", job.Artist, job.Title, url, job.Error))
		}
	} else {
		for _, job := range jobs {
			url := fmt.Sprintf("https://tidal.com/browse/track/%d", job.TrackID)
			sb.WriteString(fmt.Sprintf("%s - %s | %s | %s\n", job.Artist, job.Title, url, job.Error))
		}
	}

	if err := os.WriteFile(savePath, []byte(sb.String()), 0644); err != nil {
		return "", err
	}
	return savePath, nil
}

// CancelDownload cancels a download in progress
func (a *App) CancelDownload(trackID int) error {
	if a.downloadManager == nil {
		return fmt.Errorf("download manager not initialized")
	}

	return a.downloadManager.CancelDownload(trackID)
}

// PauseDownloads pauses the download queue
func (a *App) PauseDownloads() bool {
	if a.downloadManager == nil {
		return false
	}

	success := a.downloadManager.PauseQueue()
	if success && a.logBuffer != nil {
		a.logBuffer.Info("Download queue paused")
		runtime.EventsEmit(a.ctx, "queue-paused", true)
	}
	return success
}

// ResumeDownloads resumes the download queue
func (a *App) ResumeDownloads() bool {
	if a.downloadManager == nil {
		return false
	}

	success := a.downloadManager.ResumeQueue()
	if success && a.logBuffer != nil {
		a.logBuffer.Info("Download queue resumed")
		runtime.EventsEmit(a.ctx, "queue-paused", false)
	}
	return success
}

// IsQueuePaused returns whether the download queue is paused
func (a *App) IsQueuePaused() bool {
	if a.downloadManager == nil {
		return false
	}
	return a.downloadManager.IsPaused()
}

// =============================================================================
// Analyzer Methods (exposed to frontend)
// =============================================================================

// AnalyzeFile analyzes a single FLAC file for quality/authenticity
func (a *App) AnalyzeFile(filePath string) (*core.AnalysisResult, error) {
	result, err := core.AnalyzeFLAC(filePath)
	if err != nil {
		return nil, err
	}

	if a.logBuffer != nil {
		a.logBuffer.Info(fmt.Sprintf("Analyzed: %s - %s", result.FileName, result.VerdictLabel))
	}

	return result, nil
}

// AnalyzeMultiple analyzes multiple files
func (a *App) AnalyzeMultiple(filePaths []string) []core.AnalysisResult {
	results := core.AnalyzeMultiple(filePaths)

	if a.logBuffer != nil {
		lossless := 0
		upscaled := 0
		for _, r := range results {
			if r.IsTrueLossless {
				lossless++
			} else if r.Verdict != "error" {
				upscaled++
			}
		}
		a.logBuffer.Info(fmt.Sprintf("Analyzed %d files: %d lossless, %d upscaled", len(results), lossless, upscaled))
	}

	return results
}

// QuickAnalyze performs a fast analysis based on file size heuristics
func (a *App) QuickAnalyze(filePath string) (*core.AnalysisResult, error) {
	return core.QuickAnalyze(filePath)
}

// =============================================================================
// Lyrics Methods (exposed to frontend)
// =============================================================================

// FetchLyrics fetches lyrics for a track from LRCLIB
func (a *App) FetchLyrics(title, artist string, durationSec int) (*core.Lyrics, error) {
	client := core.NewLyricsClient()
	lyrics, err := client.SearchLyrics(title, artist, durationSec)
	if err != nil {
		if a.logBuffer != nil {
			a.logBuffer.Warn(fmt.Sprintf("Lyrics not found for %s - %s", artist, title))
		}
		return nil, err
	}

	if a.logBuffer != nil {
		if lyrics.HasSynced {
			a.logBuffer.Success(fmt.Sprintf("Found synced lyrics for %s - %s", artist, title))
		} else {
			a.logBuffer.Success(fmt.Sprintf("Found plain lyrics for %s - %s", artist, title))
		}
	}

	return lyrics, nil
}

// FetchLyricsForFile fetches lyrics based on a FLAC file's metadata
func (a *App) FetchLyricsForFile(filePath string) (*core.Lyrics, error) {
	meta, err := core.ReadFLACMetadata(filePath)
	if err != nil {
		return nil, fmt.Errorf("failed to read metadata: %w", err)
	}

	client := core.NewLyricsClient()
	return client.FetchLyricsForFile(meta)
}

// EmbedLyricsToFile embeds lyrics into a FLAC file
func (a *App) EmbedLyricsToFile(filePath string, plain, synced string) error {
	tagger := core.NewFLACTagger()
	err := tagger.EmbedLyrics(filePath, plain, synced)
	if err != nil {
		if a.logBuffer != nil {
			a.logBuffer.Error(fmt.Sprintf("Failed to embed lyrics: %s", err.Error()))
		}
		return err
	}

	if a.logBuffer != nil {
		a.logBuffer.Success(fmt.Sprintf("Lyrics embedded to %s", filepath.Base(filePath)))
	}
	return nil
}

// FetchAndEmbedLyrics fetches and embeds lyrics for a file in one operation
func (a *App) FetchAndEmbedLyrics(filePath string) (*core.Lyrics, error) {
	// Fetch lyrics based on file metadata
	lyrics, err := a.FetchLyricsForFile(filePath)
	if err != nil {
		return nil, err
	}

	// Embed lyrics
	err = a.EmbedLyricsToFile(filePath, lyrics.Plain, lyrics.Synced)
	if err != nil {
		return lyrics, err // Return lyrics even if embedding failed
	}

	// Save lyrics as separate file if enabled
	if a.config != nil && a.config.SaveLyricsFile {
		if saveErr := core.SaveLyricsFile(filePath, lyrics.Synced, lyrics.Plain); saveErr != nil {
			a.logBuffer.Warn("Failed to save lyrics file: " + saveErr.Error())
		}
	}

	return lyrics, nil
}

// FetchAndEmbedLyricsMultiple fetches and embeds lyrics for multiple files
func (a *App) FetchAndEmbedLyricsMultiple(filePaths []string) []map[string]interface{} {
	results := make([]map[string]interface{}, len(filePaths))

	for i, filePath := range filePaths {
		result := map[string]interface{}{
			"filePath": filePath,
			"success":  false,
		}

		lyrics, err := a.FetchAndEmbedLyrics(filePath)
		if err != nil {
			result["error"] = err.Error()
		} else {
			result["success"] = true
			result["hasPlain"] = lyrics.Plain != ""
			result["hasSynced"] = lyrics.HasSynced
		}

		results[i] = result
	}

	return results
}

// =============================================================================
// Source Manager Methods (exposed to frontend)
// =============================================================================

// GetAvailableSources returns info about all registered music sources
func (a *App) GetAvailableSources() []core.SourceInfo {
	return a.sourceManager.GetSourcesInfo()
}

// GetPreferredSource returns the currently preferred source name
func (a *App) GetPreferredSource() string {
	source, ok := a.sourceManager.GetPreferredSource()
	if ok {
		return source.Name()
	}
	return "tidal"
}

// SetPreferredSource sets the preferred source
func (a *App) SetPreferredSource(sourceName string) {
	a.sourceManager.SetPreferredSource(sourceName)
	if a.logBuffer != nil {
		a.logBuffer.Info(fmt.Sprintf("Preferred source set to: %s", sourceName))
	}
}

// DetectSourceFromURL identifies which source can handle a URL
func (a *App) DetectSourceFromURL(rawURL string) map[string]interface{} {
	result := map[string]interface{}{
		"detected":    false,
		"source":      "",
		"displayName": "",
		"contentType": "",
		"id":          "",
		"available":   false,
	}

	source, err := a.sourceManager.DetectSource(rawURL)
	if err != nil {
		return result
	}

	id, contentType, err := source.ParseURL(rawURL)
	if err != nil {
		return result
	}

	result["detected"] = true
	result["source"] = source.Name()
	result["displayName"] = source.DisplayName()
	result["contentType"] = contentType
	result["id"] = id
	result["available"] = source.IsAvailable()

	return result
}

// FetchContentFromURL fetches content info from any supported source URL
func (a *App) FetchContentFromURL(rawURL string) (map[string]interface{}, error) {
	source, err := a.sourceManager.DetectSource(rawURL)
	if err != nil {
		return nil, err
	}

	id, contentType, err := source.ParseURL(rawURL)
	if err != nil {
		return nil, err
	}

	result := map[string]interface{}{
		"source": source.Name(),
		"type":   contentType,
		"id":     id,
	}

	// Helper to convert SourceTrack to frontend-compatible format
	convertTrack := func(t core.SourceTrack) map[string]interface{} {
		// Convert ID to int if possible, otherwise use string
		trackID, _ := strconv.Atoi(t.ID)
		artists := t.Artist
		if len(t.Artists) > 0 {
			artists = strings.Join(t.Artists, ", ")
		}
		return map[string]interface{}{
			"id":          trackID,
			"title":       t.Title,
			"artist":      t.Artist,
			"artists":     artists,
			"album":       t.Album,
			"duration":    t.Duration,
			"trackNumber": t.TrackNumber,
			"coverUrl":    t.CoverURL,
			"explicit":    t.Explicit,
			"isrc":        t.ISRC,
		}
	}

	convertTracks := func(tracks []core.SourceTrack) []map[string]interface{} {
		result := make([]map[string]interface{}, len(tracks))
		for i, t := range tracks {
			result[i] = convertTrack(t)
		}
		return result
	}

	switch contentType {
	case "track":
		track, err := source.GetTrack(id)
		if err != nil {
			return nil, err
		}
		result["title"] = track.Title
		result["creator"] = track.Artist
		result["coverUrl"] = track.CoverURL
		result["tracks"] = convertTracks([]core.SourceTrack{*track})

	case "album":
		album, err := source.GetAlbum(id)
		if err != nil {
			return nil, err
		}
		result["title"] = album.Title
		result["creator"] = album.Artist
		result["coverUrl"] = album.CoverURL
		result["tracks"] = convertTracks(album.Tracks)

	case "playlist":
		playlist, err := source.GetPlaylist(id)
		if err != nil {
			return nil, err
		}
		result["title"] = playlist.Title
		result["creator"] = playlist.Creator
		result["coverUrl"] = playlist.CoverURL
		result["tracks"] = convertTracks(playlist.Tracks)

	case "mix":
		mix, err := a.downloader.GetMixFromProxy(id)
		if err != nil {
			return nil, err
		}
		result["title"] = mix.Title
		result["creator"] = mix.Creator
		result["coverUrl"] = mix.CoverURL
		tidalTracks := make([]core.SourceTrack, len(mix.Tracks))
		for i, t := range mix.Tracks {
			tidalTracks[i] = core.SourceTrack{
				ID:          strconv.Itoa(t.ID),
				Title:       t.Title,
				Artist:      t.Artist,
				Artists:     []string{t.Artists},
				Album:       t.Album,
				ISRC:        t.ISRC,
				Duration:    t.Duration,
				TrackNumber: t.TrackNum,
				CoverURL:    t.CoverURL,
				Explicit:    t.Explicit,
				SourceURL:   t.TidalURL,
				Source:      "tidal",
			}
		}
		result["tracks"] = convertTracks(tidalTracks)
	}

	if a.logBuffer != nil {
		a.logBuffer.Info(fmt.Sprintf("Fetched %s from %s: %s", contentType, source.DisplayName(), id))
	}

	return result, nil
}

// GetSourceTrack fetches a track from a specific source
func (a *App) GetSourceTrack(sourceName, trackID string) (*core.SourceTrack, error) {
	source, ok := a.sourceManager.GetSource(sourceName)
	if !ok {
		return nil, fmt.Errorf("source not found: %s", sourceName)
	}
	return source.GetTrack(trackID)
}

// GetSourceAlbum fetches an album from a specific source
func (a *App) GetSourceAlbum(sourceName, albumID string) (*core.SourceAlbum, error) {
	source, ok := a.sourceManager.GetSource(sourceName)
	if !ok {
		return nil, fmt.Errorf("source not found: %s", sourceName)
	}
	return source.GetAlbum(albumID)
}

// GetSourcePlaylist fetches a playlist from a specific source
func (a *App) GetSourcePlaylist(sourceName, playlistID string) (*core.SourcePlaylist, error) {
	source, ok := a.sourceManager.GetSource(sourceName)
	if !ok {
		return nil, fmt.Errorf("source not found: %s", sourceName)
	}
	return source.GetPlaylist(playlistID)
}

// UpdateQobuzCredentials updates Qobuz credentials
func (a *App) UpdateQobuzCredentials(appID, appSecret, authToken string) error {
	a.qobuzSource.SetCredentials(appID, appSecret, authToken)

	// Update config
	a.config.QobuzAppID = appID
	a.config.QobuzAppSecret = appSecret
	a.config.QobuzAuthToken = authToken
	a.config.QobuzEnabled = appID != "" && appSecret != ""

	if err := core.SaveConfig(a.config); err != nil {
		return err
	}

	if a.logBuffer != nil {
		if a.config.QobuzEnabled {
			a.logBuffer.Success("Qobuz credentials updated")
		} else {
			a.logBuffer.Info("Qobuz disabled")
		}
	}

	return nil
}

// IsQobuzConfigured checks if Qobuz is properly configured
func (a *App) IsQobuzConfigured() bool {
	return a.qobuzSource.IsAvailable()
}