patchwork

package folder

import (
	"context"
	"io/fs"
	"os"
	"path/filepath"
	"time"

	"github.com/fsnotify/fsnotify"
)

// Watch scans once, then again after file events settle (debounce), on
// every poll tick, and shortly after any scan that left files pending.
// fsnotify is a hint, not a source of truth: it misses events on network
// mounts and some Docker bind mounts, which is why polling always runs.
// onReport is called after every scan.
func (r *Runner) Watch(ctx context.Context, debounce, poll time.Duration, onReport func(Report, error)) error {
	events := make(chan struct{}, 1)
	if r.PollOnly {
		r.Log.Info("file events disabled; polling only")
	} else if w, err := fsnotify.NewWatcher(); err != nil {
		r.Log.Warn("file events unavailable; polling only", "err", err)
	} else {
		defer w.Close()
		r.addDirs(w)
		go r.forward(ctx, w, events)
	}

	var tick <-chan time.Time
	if poll > 0 {
		t := time.NewTicker(poll)
		defer t.Stop()
		tick = t.C
	}
	var timer *time.Timer
	var fire <-chan time.Time
	schedule := func(d time.Duration) {
		if timer != nil {
			timer.Stop()
		}
		timer = time.NewTimer(d)
		fire = timer.C
	}

	scan := func() {
		rep, err := r.Scan(ctx, false)
		onReport(rep, err)
		if len(rep.Pending) > 0 {
			schedule(r.Settle + 100*time.Millisecond)
		}
	}
	scan()
	for {
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-events:
			schedule(debounce)
		case <-fire:
			fire = nil
			scan()
		case <-tick:
			scan()
		}
	}
}

func (r *Runner) forward(ctx context.Context, w *fsnotify.Watcher, events chan<- struct{}) {
	for {
		select {
		case <-ctx.Done():
			return
		case ev, ok := <-w.Events:
			if !ok {
				return
			}
			// New directories need their own watch.
			if ev.Has(fsnotify.Create) {
				r.addDir(w, ev.Name)
			}
			select {
			case events <- struct{}{}:
			default:
			}
		case err, ok := <-w.Errors:
			if !ok {
				return
			}
			r.Log.Warn("file watcher error", "err", err)
		}
	}
}

func (r *Runner) addDirs(w *fsnotify.Watcher) {
	_ = filepath.WalkDir(r.Root, func(p string, d fs.DirEntry, err error) error {
		if err != nil || !d.IsDir() {
			return nil
		}
		if p != r.Root && r.Matcher.excluded(d.Name()) {
			return filepath.SkipDir
		}
		if err := w.Add(p); err != nil {
			r.Log.Warn("cannot watch directory", "dir", p, "err", err)
		}
		return nil
	})
}

func (r *Runner) addDir(w *fsnotify.Watcher, p string) {
	if fi, err := os.Stat(p); err == nil && fi.IsDir() && !r.Matcher.excluded(fi.Name()) {
		_ = w.Add(p)
	}
}