package queue

import (
	"log/slog"
	"sync"

	"gobuz/internal/downloader"
	"gobuz/internal/models"
	"gobuz/internal/web/pages"
)

type Manager struct {
	mu           sync.RWMutex
	queues       map[int64]*UserQueue
	broker       *SSEBroker
	dl           *downloader.Downloader
	lockRegistry *AlbumLockRegistry
	pages        *pages.Pages
	logger       *slog.Logger
	onComplete   func()
}

func NewManager(broker *SSEBroker, dl *downloader.Downloader, pgs *pages.Pages, logger *slog.Logger) *Manager {
	m := &Manager{
		queues:       make(map[int64]*UserQueue),
		broker:       broker,
		dl:           dl,
		lockRegistry: NewAlbumLockRegistry(),
		pages:        pgs,
		logger:       logger,
	}
	return m
}

func (m *Manager) SetOnComplete(fn func()) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.onComplete = fn
	for _, uq := range m.queues {
		uq.setOnComplete(fn)
	}
}

func (m *Manager) Stop() {
	m.mu.Lock()
	defer m.mu.Unlock()
	for _, uq := range m.queues {
		uq.Stop()
	}
}

func (m *Manager) GetUserQueue(userID int64) *UserQueue {
	m.mu.Lock()
	defer m.mu.Unlock()

	uq, exists := m.queues[userID]
	if !exists {
		uq = newUserQueue(userID, m.broker, m.dl, m.lockRegistry, m.pages, m.logger, m.onComplete)
		m.queues[userID] = uq
	}
	return uq
}

func (m *Manager) GetViewModel(userID int64) pages.QueueViewModel {
	return m.GetUserQueue(userID).GetViewModel()
}

func (m *Manager) IsQueued(userID int64, id string) bool {
	return m.GetUserQueue(userID).IsQueued(id)
}

func (m *Manager) StageRelease(userID int64, item models.QueueItem) {
	m.GetUserQueue(userID).StageRelease(item)
}

func (m *Manager) RemoveRelease(userID int64, id string) {
	m.GetUserQueue(userID).RemoveRelease(id)
}

func (m *Manager) GetItem(userID int64, id string) *models.QueueItem {
	return m.GetUserQueue(userID).GetItem(id)
}

func (m *Manager) Clear(userID int64) {
	m.GetUserQueue(userID).Clear()
}

func (m *Manager) StartDownloads(userID int64) {
	m.GetUserQueue(userID).StartDownloads()
}

func (m *Manager) IsAnyProcessing() bool {
	m.mu.RLock()
	defer m.mu.RUnlock()
	for _, uq := range m.queues {
		if uq.IsProcessing() {
			return true
		}
	}
	return false
}

func (m *Manager) IsProcessing(userID int64) bool {
	return m.GetUserQueue(userID).IsProcessing()
}