package watchers

import (
	"errors"
	"sync"

	"Moonshark/logger"
)

var (
	ErrDirectoryNotFound = errors.New("directory not found")
	ErrAlreadyWatching   = errors.New("already watching directory")
)

// WatcherManager now just manages watcher lifecycle - no polling logic
type WatcherManager struct {
	watchers map[string]*Watcher
	mu       sync.RWMutex
}

func NewWatcherManager() *WatcherManager {
	return &WatcherManager{
		watchers: make(map[string]*Watcher),
	}
}

func (m *WatcherManager) Close() error {
	m.mu.Lock()
	defer m.mu.Unlock()

	for _, watcher := range m.watchers {
		watcher.Close()
	}

	m.watchers = make(map[string]*Watcher)
	return nil
}

func (m *WatcherManager) WatchDirectory(config WatcherConfig) error {
	m.mu.Lock()
	defer m.mu.Unlock()

	if _, exists := m.watchers[config.Dir]; exists {
		return ErrAlreadyWatching
	}

	watcher, err := NewWatcher(config)
	if err != nil {
		return err
	}

	m.watchers[config.Dir] = watcher
	logger.Debugf("WatcherManager added watcher for %s", config.Dir)

	return nil
}

func (m *WatcherManager) UnwatchDirectory(dir string) error {
	m.mu.Lock()
	defer m.mu.Unlock()

	watcher, exists := m.watchers[dir]
	if !exists {
		return ErrDirectoryNotFound
	}

	watcher.Close()
	delete(m.watchers, dir)
	logger.Debugf("WatcherManager removed watcher for %s", dir)

	return nil
}

func (m *WatcherManager) GetWatcher(dir string) (*Watcher, bool) {
	m.mu.RLock()
	defer m.mu.RUnlock()

	watcher, exists := m.watchers[dir]
	return watcher, exists
}

func (m *WatcherManager) ListWatching() []string {
	m.mu.RLock()
	defer m.mu.RUnlock()

	dirs := make([]string, 0, len(m.watchers))
	for dir := range m.watchers {
		dirs = append(dirs, dir)
	}

	return dirs
}