132 lines
3.3 KiB
Go
132 lines
3.3 KiB
Go
package service
|
|
|
|
import (
|
|
"database/sql"
|
|
"strings"
|
|
"time"
|
|
|
|
"mal/internal/domain"
|
|
"mal/internal/observability"
|
|
)
|
|
|
|
const (
|
|
retryInterval = 15 * time.Minute
|
|
retryWindow = 3 * time.Hour
|
|
airingFallbackRefreshInterval = 6 * time.Hour
|
|
)
|
|
|
|
func nextRefreshAt(anime domain.Anime, now time.Time) sql.NullTime {
|
|
if !anime.Airing {
|
|
return sql.NullTime{}
|
|
}
|
|
|
|
// During the hours immediately following a broadcast time, providers can lag.
|
|
// Keep retrying for a short window, even if the provider request succeeded.
|
|
lastBroadcast := nextBroadcastBeforeOrAt(anime, now)
|
|
if !lastBroadcast.IsZero() && now.Before(lastBroadcast.Add(retryWindow)) {
|
|
return sql.NullTime{Time: now.Add(retryInterval).UTC(), Valid: true}
|
|
}
|
|
|
|
next := nextBroadcastAfter(anime, now)
|
|
if !next.IsZero() {
|
|
return sql.NullTime{Time: next, Valid: true}
|
|
}
|
|
|
|
// Broadcast metadata is often missing or wrong for currently airing shows.
|
|
// Avoid "never refresh again" caches by falling back to a fixed interval.
|
|
return sql.NullTime{Time: now.Add(airingFallbackRefreshInterval).UTC(), Valid: true}
|
|
}
|
|
|
|
func nextRetryTime(anime domain.Anime, now time.Time) time.Time {
|
|
broadcast := nextBroadcastBeforeOrAt(anime, now)
|
|
if broadcast.IsZero() || now.After(broadcast.Add(retryWindow)) {
|
|
return nextBroadcastAfter(anime, now)
|
|
}
|
|
return now.Add(retryInterval)
|
|
}
|
|
|
|
func nextBroadcastBeforeOrAt(anime domain.Anime, now time.Time) time.Time {
|
|
next := nextBroadcastAfter(anime, now.AddDate(0, 0, -7))
|
|
if next.IsZero() || next.After(now) {
|
|
return time.Time{}
|
|
}
|
|
return next
|
|
}
|
|
|
|
func nextBroadcastAfter(anime domain.Anime, after time.Time) time.Time {
|
|
day := weekdayFromJikan(anime.Broadcast.Day)
|
|
if day < 0 || strings.TrimSpace(anime.Broadcast.Time) == "" {
|
|
return time.Time{}
|
|
}
|
|
|
|
loc := time.UTC
|
|
if tz := strings.TrimSpace(anime.Broadcast.Timezone); tz != "" {
|
|
if loaded, err := time.LoadLocation(tz); err == nil {
|
|
loc = loaded
|
|
} else {
|
|
observability.Warn(
|
|
"episodes_broadcast_timezone_parse_failed",
|
|
"episodes",
|
|
"",
|
|
map[string]any{
|
|
"anime_id": anime.MalID,
|
|
"timezone": tz,
|
|
},
|
|
err,
|
|
)
|
|
}
|
|
}
|
|
|
|
hour, minute, ok := parseBroadcastTime(anime.Broadcast.Time)
|
|
if !ok {
|
|
observability.Warn(
|
|
"episodes_broadcast_time_parse_failed",
|
|
"episodes",
|
|
"",
|
|
map[string]any{
|
|
"anime_id": anime.MalID,
|
|
"time": anime.Broadcast.Time,
|
|
},
|
|
nil,
|
|
)
|
|
return time.Time{}
|
|
}
|
|
|
|
localAfter := after.In(loc)
|
|
daysAhead := (int(day) - int(localAfter.Weekday()) + 7) % 7
|
|
candidate := time.Date(localAfter.Year(), localAfter.Month(), localAfter.Day()+daysAhead, hour, minute, 0, 0, loc)
|
|
if !candidate.After(localAfter) {
|
|
candidate = candidate.AddDate(0, 0, 7)
|
|
}
|
|
return candidate.UTC()
|
|
}
|
|
|
|
func weekdayFromJikan(day string) time.Weekday {
|
|
switch strings.ToLower(strings.TrimSpace(day)) {
|
|
case "sundays":
|
|
return time.Sunday
|
|
case "mondays":
|
|
return time.Monday
|
|
case "tuesdays":
|
|
return time.Tuesday
|
|
case "wednesdays":
|
|
return time.Wednesday
|
|
case "thursdays":
|
|
return time.Thursday
|
|
case "fridays":
|
|
return time.Friday
|
|
case "saturdays":
|
|
return time.Saturday
|
|
default:
|
|
return -1
|
|
}
|
|
}
|
|
|
|
func parseBroadcastTime(value string) (int, int, bool) {
|
|
t, err := time.Parse("15:04", strings.TrimSpace(value))
|
|
if err != nil {
|
|
return 0, 0, false
|
|
}
|
|
return t.Hour(), t.Minute(), true
|
|
}
|