Merge pull request #172 from 0xjuanma/feat/improvedgoallinks

feat[reddit]: paced goal-link queue with reddit block recovery

Author: 0xjuanma

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 - **Caching** — FotMob league page bodies are now cached for 60s and shared across the live, stats, World Cup, and standings views, reducing redundant network calls during quick navigation.
+- **Reddit goal-link retrieval** — goal replay links now load one-by-one in the match panel and recover gracefully when Reddit rate-limits the app, instead of all attempts failing in a burst.
 
 ### Fixed
 - **Live matches view** — matches that kicked off before the user's UTC midnight (e.g. evening kickoffs for users in the Americas) are no longer dropped from the Live view.

internal/app/commands.go

@@ -362,31 +362,52 @@ func fetchStatsMatchDetailsFotmob(client *fotmob.Client, matchID int, useMockDat
 	}
 }
 
-// fetchGoalLinks fetches goal replay links from Reddit for all goals in a match.
-// This is called on-demand when match details are loaded/displayed.
-// Links are cached persistently to avoid redundant API calls.
+// fetchGoalLinks opens a streaming subscription to the reddit queue for all
+// goals in `details`. Returns a tea.Cmd that emits a goalLinkStreamMsg
+// carrying the result channel; the Update loop stashes the channel and arms
+// successive waitForGoalLink reader Cmds at the queue's cadence.
+//
+// Goals already in the persistent cache surface immediately (they're written
+// into the channel by GoalLinksAsync before queueing begins); uncached goals
+// arrive at QueueInterval cadence. Each emitted goalLinkMsg carries a single
+// result so the UI updates progressively instead of waiting for the entire
+// match's goals to resolve.
 func fetchGoalLinks(redditClient *reddit.Client, details *api.MatchDetails) tea.Cmd {
-	return func() tea.Msg {
-		if redditClient == nil || details == nil {
-			return goalLinksMsg{matchID: 0, links: nil}
-		}
+	if redditClient == nil || details == nil {
+		return nil
+	}
 
-		goals := buildGoalInfos(details)
-		if len(goals) == 0 {
-			return goalLinksMsg{matchID: details.ID, links: nil}
-		}
+	goals := buildGoalInfos(details)
+	if len(goals) == 0 {
+		return nil
+	}
 
-		// Log the per-goal running scores so the corrected matcher inputs are
-		// observable in golazo_debug.log without trawling individual search
-		// queries. Useful for verifying World Cup / national-team retrievals.
-		redditClient.DebugLog(fmt.Sprintf("fetchGoalLinks: match=%d %s vs %s — %d goals: %s",
-			details.ID, details.HomeTeam.Name, details.AwayTeam.Name, len(goals),
-			formatGoalSummary(goals)))
+	// Log the per-goal running scores so the corrected matcher inputs are
+	// observable in golazo_debug.log without trawling individual search
+	// queries. Useful for verifying World Cup / national-team retrievals.
+	redditClient.DebugLog(fmt.Sprintf("fetchGoalLinks: match=%d %s vs %s — %d goals: %s",
+		details.ID, details.HomeTeam.Name, details.AwayTeam.Name, len(goals),
+		formatGoalSummary(goals)))
 
-		// Fetch links for all goals (uses cache internally)
-		links := redditClient.GoalLinks(goals)
+	matchID := details.ID
+	results := redditClient.GoalLinksAsync(goals)
 
-		return goalLinksMsg{matchID: details.ID, links: links}
+	return func() tea.Msg {
+		return goalLinkStreamMsg{matchID: matchID, ch: results}
+	}
+}
+
+// waitForGoalLink returns a tea.Cmd that blocks until the next GoalResult
+// arrives on results (or the channel closes), then emits a goalLinkMsg or a
+// terminal goalLinksDoneMsg. The Update handler re-arms this Cmd after each
+// goalLinkMsg, forming the subscription loop.
+func waitForGoalLink(matchID int, results <-chan reddit.GoalResult) tea.Cmd {
+	return func() tea.Msg {
+		r, ok := <-results
+		if !ok {
+			return goalLinksDoneMsg{matchID: matchID}
+		}
+		return goalLinkMsg{matchID: matchID, key: r.Key, link: r.Link}
 	}
 }
 

internal/app/commands_test.go

@@ -1,12 +1,22 @@
 package app
 
 import (
+	"io"
+	"log/slog"
 	"testing"
 	"time"
 
 	"github.com/0xjuanma/golazo/internal/api"
+	"github.com/0xjuanma/golazo/internal/reddit"
 )
 
+// testLogger returns a slog.Logger that discards output, matching the
+// debugLog-disabled path of initLogger. Required because handleGoalLink
+// calls m.debugLog which panics with nil m.logger.
+func testLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(io.Discard, nil))
+}
+
 func TestBuildGoalInfosRunningScore(t *testing.T) {
 	home := api.Team{ID: 1, Name: "Australia", ShortName: "AUS"}
 	away := api.Team{ID: 2, Name: "Türkiye", ShortName: "TUR"}
@@ -145,3 +155,61 @@ func TestBuildGoalInfosNilDetails(t *testing.T) {
 		t.Errorf("expected nil for nil details, got %d goals", len(got))
 	}
 }
+
+// TestHandleGoalLinkMergesSingle exercises the per-goal merge that the
+// subscription path relies on: a single goalLinkMsg must be applied to
+// m.goalLinks[key] and the reader Cmd must be re-armed against the same
+// channel. The behavior under test is the merge inside handleGoalLink — not
+// any wrapping fetch logic — so the test wires a channel directly without
+// invoking GoalLinksAsync.
+func TestHandleGoalLinkMergesSingle(t *testing.T) {
+	ch := make(chan reddit.GoalResult, 1)
+	defer close(ch)
+
+	m := model{
+		goalLinks:     make(map[reddit.GoalLinkKey]*reddit.GoalLink),
+		goalLinkChans: map[int]<-chan reddit.GoalResult{42: ch},
+		logger:        testLogger(),
+	}
+
+	link := &reddit.GoalLink{
+		MatchID: 42,
+		Minute:  17,
+		URL:     "https://example.com/replay",
+		Title:   "Iran 0 - [1] New Zealand - E. Just 7'",
+	}
+	key := reddit.GoalLinkKey{MatchID: 42, Minute: 17}
+
+	newModel, cmd := m.handleGoalLink(goalLinkMsg{matchID: 42, key: key, link: link})
+	mm, ok := newModel.(model)
+	if !ok {
+		t.Fatalf("handleGoalLink returned wrong model type: %T", newModel)
+	}
+	if got := mm.goalLinks[key]; got != link {
+		t.Errorf("goalLinks[%+v] = %+v, want %+v", key, got, link)
+	}
+	if cmd == nil {
+		t.Fatal("handleGoalLink returned nil Cmd; expected re-armed waitForGoalLink")
+	}
+}
+
+// TestHandleGoalLinkNotFoundIsRecorded verifies that nil/not-found results
+// are still stored in goalLinks so the UI can distinguish "search resolved
+// to no match" from "search still pending".
+func TestHandleGoalLinkNotFoundIsRecorded(t *testing.T) {
+	ch := make(chan reddit.GoalResult, 1)
+	defer close(ch)
+
+	m := model{
+		goalLinks:     make(map[reddit.GoalLinkKey]*reddit.GoalLink),
+		goalLinkChans: map[int]<-chan reddit.GoalResult{99: ch},
+		logger:        testLogger(),
+	}
+	key := reddit.GoalLinkKey{MatchID: 99, Minute: 45}
+
+	newModel, _ := m.handleGoalLink(goalLinkMsg{matchID: 99, key: key, link: nil})
+	mm := newModel.(model)
+	if _, ok := mm.goalLinks[key]; !ok {
+		t.Errorf("expected nil-link sentinel entry in goalLinks for %+v", key)
+	}
+}

internal/app/messages.go

@@ -66,11 +66,34 @@ type pollTickMsg struct {
 // This allows the "Updating..." spinner to be visible for at least 1 second.
 type pollDisplayCompleteMsg struct{}
 
-// goalLinksMsg contains goal replay links fetched from Reddit.
-// Sent after searching r/soccer for Media posts matching goal events.
-type goalLinksMsg struct {
+// goalLinkStreamMsg hands a freshly-opened goal-link subscription channel to
+// the Update loop. The handler stashes the channel on the model (keyed by
+// matchID) and arms the first reader Cmd. Emitted once per match-details
+// load, before any goalLinkMsg for that match.
+type goalLinkStreamMsg struct {
+	matchID int
+	ch      <-chan reddit.GoalResult
+}
+
+// goalLinkMsg streams a single goal-link outcome from the reddit queue's
+// subscription channel. The match-level goalLinksMsg above remains for
+// initial cache-hit batches; goalLinkMsg carries per-goal results that
+// arrive at the queue's 30s cadence so the UI can render replay links
+// progressively instead of waiting for the entire match's goals to resolve.
+// Link is nil when the goal was searched but not found, was dropped because
+// Reddit returned ErrBlocked, or hit a transient fetch error.
+type goalLinkMsg struct {
+	matchID int
+	key     reddit.GoalLinkKey
+	link    *reddit.GoalLink
+}
+
+// goalLinksDoneMsg signals that the reddit queue's subscription channel for
+// a given match has closed — every queued goal has produced exactly one
+// goalLinkMsg. Used to stop the subscription tea.Cmd loop without leaking
+// goroutines.
+type goalLinksDoneMsg struct {
 	matchID int
-	links   map[reddit.GoalLinkKey]*reddit.GoalLink
 }
 
 // standingsMsg contains league standings from API response.

internal/app/model.go

@@ -159,6 +159,13 @@ type model struct {
 	// Goal replay links from Reddit (keyed by matchID:minute)
 	goalLinks map[reddit.GoalLinkKey]*reddit.GoalLink
 
+	// Active goal-link subscriptions keyed by matchID. The reddit client's
+	// GoalLinksAsync streams one GoalResult per goal at the queue's cadence;
+	// the Update loop drives a reader Cmd that re-arms from the same
+	// channel until it closes. Stored on the model so handleGoalLink can
+	// re-issue a wait Cmd without losing the channel reference.
+	goalLinkChans map[int]<-chan reddit.GoalResult
+
 	// Logging
 	logger  *slog.Logger
 	logFile *os.File // kept open for logger lifetime
@@ -280,6 +287,7 @@ func New(useMockData bool, debugMode bool, isDevBuild bool, newVersionAvailable
 		parser:                 fotmob.NewLiveUpdateParser(),
 		redditClient:           redditClient,
 		goalLinks:              make(map[reddit.GoalLinkKey]*reddit.GoalLink),
+		goalLinkChans:          make(map[int]<-chan reddit.GoalResult),
 		logger:                 logger,
 		logFile:                logFile,
 		notifier:               notify.NewDesktopNotifier(),

internal/app/update.go

@@ -66,8 +66,14 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		// Route filter matches message to the appropriate list based on current view
 		return m.handleFilterMatches(msg)
 
-	case goalLinksMsg:
-		return m.handleGoalLinks(msg)
+	case goalLinkStreamMsg:
+		return m.handleGoalLinkStream(msg)
+
+	case goalLinkMsg:
+		return m.handleGoalLink(msg)
+
+	case goalLinksDoneMsg:
+		return m.handleGoalLinksDone(msg)
 
 	case standingsMsg:
 		return m.handleStandings(msg)
@@ -1289,37 +1295,55 @@ func max(a, b int) int {
 	return b
 }
 
-// handleGoalLinks processes goal replay links fetched from Reddit.
-func (m model) handleGoalLinks(msg goalLinksMsg) (tea.Model, tea.Cmd) {
-	m.debugLog(fmt.Sprintf("handleGoalLinks called for match %d with %d links", msg.matchID, len(msg.links)))
-	if len(msg.links) == 0 {
-		m.debugLog(fmt.Sprintf("GoalLinks completed for match %d: no links found", msg.matchID))
-		return m, nil
-	}
-
-	m.debugLog(fmt.Sprintf("GoalLinks completed for match %d: processing %d links", msg.matchID, len(msg.links)))
+// handleGoalLinkStream stashes a freshly-opened goal-link subscription
+// channel on the model and arms the first reader Cmd. One stream is tracked
+// per matchID; re-opening for the same match replaces the previous channel
+// (the old reader Cmd will receive a closed-channel signal next read and
+// exit cleanly via goalLinksDoneMsg).
+func (m model) handleGoalLinkStream(msg goalLinkStreamMsg) (tea.Model, tea.Cmd) {
+	if m.goalLinkChans == nil {
+		m.goalLinkChans = make(map[int]<-chan reddit.GoalResult)
+	}
+	m.goalLinkChans[msg.matchID] = msg.ch
+	m.debugLog(fmt.Sprintf("goalLinkStream: opened subscription for match %d", msg.matchID))
+	return m, waitForGoalLink(msg.matchID, msg.ch)
+}
 
-	// Merge new links into the goal links map
+// handleGoalLink merges a single goal-link result into the model's
+// goalLinks map and re-arms the reader Cmd against the same stream. This is
+// where the per-goal behavior change lives: each link is applied
+// individually so the UI re-renders progressively at the queue's cadence.
+func (m model) handleGoalLink(msg goalLinkMsg) (tea.Model, tea.Cmd) {
 	if m.goalLinks == nil {
 		m.goalLinks = make(map[reddit.GoalLinkKey]*reddit.GoalLink)
 	}
 
-	validLinks := 0
-	failedLinks := 0
-
-	for key, link := range msg.links {
-		m.goalLinks[key] = link
-		if link != nil && link.URL != "" && link.URL != "__NOT_FOUND__" {
-			validLinks++
-			m.debugLog(fmt.Sprintf("Cached goal link: %d:%d → %s (post: %s)", key.MatchID, key.Minute, link.URL, link.PostURL))
-		} else if link != nil && link.URL == "__NOT_FOUND__" {
-			failedLinks++
-			m.debugLog(fmt.Sprintf("No link found: %d:%d", key.MatchID, key.Minute))
-		}
+	if msg.link != nil && msg.link.URL != "" && msg.link.URL != reddit.NotFoundMarker {
+		m.goalLinks[msg.key] = msg.link
+		m.debugLog(fmt.Sprintf("goalLink: match=%d %d:%d → %s",
+			msg.matchID, msg.key.MatchID, msg.key.Minute, msg.link.URL))
+	} else {
+		// Record nil/not-found so the UI knows the search resolved (vs.
+		// pending) without rendering a broken link.
+		m.goalLinks[msg.key] = msg.link
+		m.debugLog(fmt.Sprintf("goalLink: match=%d %d:%d → no link",
+			msg.matchID, msg.key.MatchID, msg.key.Minute))
 	}
 
-	m.debugLog(fmt.Sprintf("Goal link batch complete: %d valid, %d failed", validLinks, failedLinks))
+	ch, ok := m.goalLinkChans[msg.matchID]
+	if !ok {
+		// Stream was torn down (e.g., user navigated away) — don't re-arm.
+		return m, nil
+	}
+	return m, waitForGoalLink(msg.matchID, ch)
+}
 
+// handleGoalLinksDone removes the closed subscription channel from the
+// model. Emitted by waitForGoalLink when the reddit queue's result channel
+// for this match has been fully drained.
+func (m model) handleGoalLinksDone(msg goalLinksDoneMsg) (tea.Model, tea.Cmd) {
+	delete(m.goalLinkChans, msg.matchID)
+	m.debugLog(fmt.Sprintf("goalLinkStream: closed subscription for match %d", msg.matchID))
 	return m, nil
 }
 

internal/reddit/cache.go

@@ -17,8 +17,11 @@ const (
 	// 7 days keeps the cache file small while covering recent matches.
 	CacheTTL = 7 * 24 * time.Hour // 7 days
 	// NotFoundTTL defines how long to cache "not found" results.
-	// Shorter than CacheTTL since links might appear later.
-	NotFoundTTL = 5 * time.Minute // 5 minutes
+	// Shorter than CacheTTL since links might appear later. 1h is a balance:
+	// long enough to avoid re-hitting Reddit for the same missing goal within
+	// a single viewing session (queue is paced at 30s/request), short enough
+	// that late-uploaded videos surface on the next app run.
+	NotFoundTTL = 1 * time.Hour
 	// NotFoundMarker is a special URL indicating "searched but not found"
 	NotFoundMarker = "__NOT_FOUND__"
 )