package queue import ( "bytes" "context" "log/slog" "slices" "sync" "time" "gobuz/internal/downloader" "gobuz/internal/log" "gobuz/internal/models" "gobuz/internal/web/pages" ) type userQueue struct { userID int64 mu sync.RWMutex items map[string]*models.QueueItem order []string broker *SSEBroker dl ReleaseDownloader lockRegistry *releaseLockRegistry pages *pages.Pages currentReleaseID string trackToReleaseMap map[string]string isProcessing bool logger *slog.Logger onComplete func() ctx context.Context cancel context.CancelFunc } func newUserQueue(userID int64, broker *SSEBroker, dl ReleaseDownloader, lockRegistry *releaseLockRegistry, pgs *pages.Pages, logger *slog.Logger, onComplete func()) *userQueue { ctx, cancel := context.WithCancel(context.Background()) return &userQueue{ userID: userID, items: make(map[string]*models.QueueItem), order: make([]string, 0), broker: broker, dl: dl, lockRegistry: lockRegistry, pages: pgs, trackToReleaseMap: make(map[string]string), logger: logger, onComplete: onComplete, ctx: ctx, cancel: cancel, } } func (u *userQueue) setOnComplete(fn func()) { u.mu.Lock() defer u.mu.Unlock() u.onComplete = fn } func (u *userQueue) stop() { u.cancel() } func (u *userQueue) processing() bool { u.mu.RLock() defer u.mu.RUnlock() return u.isProcessing } func (u *userQueue) OnRelease(msg downloader.MsgRelease) { u.mu.Lock() defer u.mu.Unlock() if !u.isProcessing || msg.ReleaseID == "" { return } if item, exists := u.items[msg.ReleaseID]; exists { u.currentReleaseID = msg.ReleaseID item.Status = models.StatusDownloading u.broadcastProgressLocked() } } func (u *userQueue) OnRegisterTrack(msg downloader.MsgRegisterTrack) { u.mu.Lock() defer u.mu.Unlock() if !u.isProcessing { return } releaseID := msg.ReleaseID if releaseID == "" { releaseID = u.currentReleaseID } if releaseID == "" { return } release, exists := u.items[releaseID] if !exists { release = &models.QueueItem{ Release: models.Release{ ID: releaseID, Title: msg.Name, }, Status: models.StatusDownloading, } u.items[releaseID] = release u.order = append(u.order, releaseID) } release.Status = models.StatusDownloading u.trackToReleaseMap[msg.ID] = releaseID if track := findTrack(release.Tracks, msg.ID); track != nil { track.Title = msg.Name track.Status = models.StatusDownloading track.Counter = msg.Counter } else { release.Tracks = append(release.Tracks, &models.TrackProgress{ ID: msg.ID, TrackNumber: len(release.Tracks) + 1, Title: msg.Name, Status: models.StatusDownloading, Counter: msg.Counter, }) } u.broadcastProgressLocked() } func (u *userQueue) OnSetTotal(msg downloader.MsgSetTotal) { u.mu.Lock() defer u.mu.Unlock() if _, track := u.releaseForTrackLocked(msg.ID); track != nil { track.TotalBytes = msg.Total u.broadcastProgressLocked() } } func (u *userQueue) OnDone(msg downloader.MsgDone) { u.mu.Lock() defer u.mu.Unlock() release, track := u.releaseForTrackLocked(msg.ID) if release == nil { return } if track != nil { track.Status = models.StatusDone if track.TotalBytes > 0 { track.DownloadedBytes = track.TotalBytes track.Percent = 100 } } if len(release.Tracks) > 0 && hasAllTracksSucceeded(release) { release.Status = models.StatusDone release.Percent = 100 } u.broadcastProgressLocked() } func (u *userQueue) OnFailed(msg downloader.MsgFailed) { u.mu.Lock() defer u.mu.Unlock() release, track := u.releaseForTrackLocked(msg.ID) if release == nil { return } if track != nil { track.Status = models.StatusFailed } release.Status = models.StatusFailed u.broadcastProgressLocked() } func findTrack(tracks []*models.TrackProgress, trackID string) *models.TrackProgress { for _, t := range tracks { if t.ID == trackID { return t } } return nil } func (u *userQueue) releaseForTrackLocked(trackID string) (*models.QueueItem, *models.TrackProgress) { releaseID, ok := u.trackToReleaseMap[trackID] if !ok { return nil, nil } release, exists := u.items[releaseID] if !exists { return nil, nil } return release, findTrack(release.Tracks, trackID) } func (u *userQueue) tick() { u.mu.Lock() defer u.mu.Unlock() changed := false for _, release := range u.items { if release.Status != models.StatusDownloading { continue } var sumDownloaded, sumTotal int64 var sumPercent int trackCount := len(release.Tracks) for _, t := range release.Tracks { if t.Status == models.StatusDownloading && t.Counter != nil { downloaded := t.Counter.Load() if downloaded != t.DownloadedBytes { t.DownloadedBytes = downloaded if t.TotalBytes > 0 { t.Percent = min(int((float64(downloaded)/float64(t.TotalBytes))*100), 100) } changed = true } } sumDownloaded += t.DownloadedBytes sumTotal += t.TotalBytes sumPercent += t.Percent } if trackCount > 0 { release.DownloadedBytes = sumDownloaded release.TotalBytes = sumTotal release.Percent = sumPercent / trackCount } } if changed { u.broadcastProgressLocked() } } func (u *userQueue) isQueued(id string) bool { if id == "" { return false } u.mu.RLock() defer u.mu.RUnlock() _, exists := u.items[id] return exists } func (u *userQueue) stageRelease(item models.QueueItem) { if item.ID == "" { return } u.mu.Lock() defer u.mu.Unlock() if _, exists := u.items[item.ID]; !exists { item.Status = models.StatusStaged u.items[item.ID] = &item u.order = append(u.order, item.ID) } } func (u *userQueue) removeRelease(id string) { if id == "" { return } u.mu.Lock() defer u.mu.Unlock() delete(u.items, id) u.order = slices.DeleteFunc(u.order, func(oid string) bool { return oid == id }) } func (u *userQueue) clear() { u.mu.Lock() defer u.mu.Unlock() if !u.isProcessing { u.items = make(map[string]*models.QueueItem) u.order = nil u.trackToReleaseMap = make(map[string]string) return } newItems := make(map[string]*models.QueueItem) var newOrder []string for _, id := range u.order { if item, ok := u.items[id]; ok && (item.Status == models.StatusDownloading || item.Status == models.StatusPending) { newItems[id] = item newOrder = append(newOrder, id) } } u.items = newItems u.order = newOrder } func (u *userQueue) getItem(id string) *models.QueueItem { if id == "" { return nil } u.mu.RLock() defer u.mu.RUnlock() if item, exists := u.items[id]; exists { cpy := *item return &cpy } return nil } func (u *userQueue) startDownloads() { u.mu.Lock() for _, id := range u.order { if item, ok := u.items[id]; ok && item.Status == models.StatusStaged { item.Status = models.StatusPending } } u.broadcastProgressLocked() if u.isProcessing { u.mu.Unlock() return } u.isProcessing = true u.mu.Unlock() go u.processQueueLoop() } func (u *userQueue) processQueueLoop() { defer func() { u.mu.Lock() if u.isProcessing { u.isProcessing = false u.broadcastProgressLocked() } u.mu.Unlock() }() stopTicker := make(chan struct{}) go func() { ticker := time.NewTicker(500 * time.Millisecond) defer ticker.Stop() for { select { case <-ticker.C: u.tick() case <-stopTicker: return } } }() defer close(stopTicker) for { select { case <-u.ctx.Done(): return default: } nextID, requestedBy := u.nextPendingRelease() if nextID == "" { return } u.logger.Info("starting download", "id", nextID, "requested_by", requestedBy) l := u.lockRegistry.getLock(nextID) l.Lock() downloadCtx := downloader.WithRequestedBy(u.ctx, requestedBy) downloadCtx = downloader.WithProgressListener(downloadCtx, u) downloadCtx = log.IntoContext(downloadCtx, u.logger) downloadErr := u.dl.DownloadRelease(downloadCtx, nextID) if downloadErr != nil { u.logger.Error("release download failed", "id", nextID, "err", downloadErr) } l.Unlock() if onComplete := u.finalizeReleaseDownload(nextID, requestedBy, downloadErr); onComplete != nil { onComplete() } } } func (u *userQueue) nextPendingRelease() (string, string) { u.mu.Lock() defer u.mu.Unlock() for _, id := range u.order { if item, ok := u.items[id]; ok && item.Status == models.StatusPending { item.Status = models.StatusDownloading u.currentReleaseID = id u.broadcastProgressLocked() return id, item.RequestedBy } } u.isProcessing = false u.broadcastProgressLocked() return "", "" } func (u *userQueue) finalizeReleaseDownload(releaseID, requestedBy string, downloadErr error) func() { u.mu.Lock() defer u.mu.Unlock() var onComplete func() if item, ok := u.items[releaseID]; ok { if downloadErr != nil || !hasAllTracksSucceeded(item) { item.Status = models.StatusFailed u.logger.Warn("download failed", "id", releaseID, "requested_by", requestedBy) } else { item.Status = models.StatusDone item.Percent = 100 for _, t := range item.Tracks { t.Status = models.StatusDone t.Percent = 100 } u.logger.Info("download completed", "id", releaseID, "requested_by", requestedBy, "tracks", len(item.Tracks)) onComplete = u.onComplete } } u.broadcastProgressLocked() return onComplete } func hasAllTracksSucceeded(item *models.QueueItem) bool { if item.TracksCount > 0 && len(item.Tracks) < item.TracksCount { return false } for _, t := range item.Tracks { if t.Status != models.StatusDone { return false } } return true } func (u *userQueue) getViewModelLocked() pages.QueueViewModel { items := make([]*models.QueueItem, len(u.order)) stagedCount := 0 isDownloading := false for i, id := range u.order { item := u.items[id] items[i] = item switch item.Status { case models.StatusStaged: stagedCount++ case models.StatusDownloading, models.StatusPending: isDownloading = true } } return pages.QueueViewModel{ Items: items, StagedCount: stagedCount, Downloading: isDownloading, } } func (u *userQueue) getViewModel() pages.QueueViewModel { u.mu.RLock() defer u.mu.RUnlock() return u.getViewModelLocked() } func (u *userQueue) broadcastProgressLocked() { vm := u.getViewModelLocked() var buf bytes.Buffer if err := u.pages.RenderQueue(&buf, vm); err == nil { u.broker.Broadcast(u.userID, "queue-progress", buf.String()) } }