arr-tui/internal/ui/calendar.go

package ui

import (
	"cmp"
	"context"
	"fmt"
	"slices"
	"strings"
	"sync"
	"time"

	"github.com/gdamore/tcell/v2"
	"github.com/rivo/tview"

	"git.stinnesbeck.com/nils/arr-tui/internal/arr"
	"git.stinnesbeck.com/nils/arr-tui/internal/radarr"
	"git.stinnesbeck.com/nils/arr-tui/internal/sonarr"
	"git.stinnesbeck.com/nils/arr-tui/internal/trakt"
)

const (
	calendarDays = 14 // length of the window
	calendarStep = 7  // `[` and `]` move by this many days
)

// calEntry is one line of the calendar: a movie release or an episode airing.
type calEntry struct {
	day       time.Time // local midnight of the day
	at        time.Time // time of day, zero for date-only entries (movie releases)
	movie     bool
	title     string // plain title, for sorting
	label     string // escaped title for display
	sub       string // "S02E05 Welcome" or "Digital release"
	have      bool
	monitored bool
	missing   bool // aired already and not downloaded
	details   detailText
	cover     coverRef

	movieID, episodeID int
}

func (e calEntry) key() string {
	if e.movie {
		return fmt.Sprintf("m%d/%s/%s", e.movieID, e.sub, e.day.Format("2006-01-02"))
	}
	return fmt.Sprintf("e%d", e.episodeID)
}

// localDay returns midnight of the date of t in the local zone.
func localDay(t time.Time) time.Time {
	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local)
}

// releaseDay reads a movie release date. Radarr sends these as midnight UTC
// timestamps meaning "this date", so the date is taken as written and not
// shifted into the local zone.
func releaseDay(s string) (time.Time, bool) {
	if s == "" {
		return time.Time{}, false
	}
	t, err := time.Parse(time.RFC3339, s)
	if err != nil {
		return time.Time{}, false
	}
	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local), true
}

// movieEntries returns an entry for every release date of the movie that falls
// into [from, to] (local days).
func movieEntries(m radarr.Movie, from, to time.Time, cover coverRef, now time.Time) []calEntry {
	var out []calEntry
	for _, rel := range []struct{ name, date string }{
		{"In cinemas", m.InCinemas}, {"Digital release", m.DigitalRelease}, {"Physical release", m.PhysicalRelease},
	} {
		day, ok := releaseDay(rel.date)
		if !ok || day.Before(from) || day.After(to) {
			continue
		}
		label := tview.Escape(m.Title)
		if m.Year > 0 {
			label += fmt.Sprintf(" (%d)", m.Year)
		}
		d := movieDetails(m)
		d.head += "Release: " + rel.name + ", " + day.Format("Mon 2 Jan 2006") + "\n"
		out = append(out, calEntry{
			day: day, movie: true, title: m.Title, label: label, sub: rel.name,
			have: m.HasFile, monitored: m.Monitored, missing: m.Monitored && !m.HasFile && !day.After(now),
			details: d, cover: cover, movieID: m.ID,
		})
	}
	return out
}

// episodeEntry converts an airing episode, or reports false if it has no usable date.
func episodeEntry(e sonarr.Episode, from, to time.Time, cover coverRef, now time.Time) (calEntry, bool) {
	var day, at time.Time
	if t, err := time.Parse(time.RFC3339, e.AirDateUTC); err == nil {
		at = t.Local()
		day = localDay(at)
	} else if t, err := time.Parse("2006-01-02", e.AirDate); err == nil {
		day = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local)
	} else {
		return calEntry{}, false
	}
	if day.Before(from) || day.After(to) {
		return calEntry{}, false
	}
	series := "Unknown series"
	var overview string
	if e.Series != nil {
		series = e.Series.Title
		overview = e.Series.Overview
	}
	if e.Overview != "" {
		overview = e.Overview
	}
	sub := fmt.Sprintf("S%02dE%02d %s", e.SeasonNumber, e.EpisodeNumber, e.Title)

	head := "[::b]" + tview.Escape(series) + "[::-]\n" + tview.Escape(sub) + "\n"
	if !at.IsZero() {
		head += "Airs " + at.Format("Mon 2 Jan 15:04") + "\n"
	} else {
		head += "Airs " + day.Format("Mon 2 Jan") + "\n"
	}
	switch {
	case e.HasFile:
		head += "[green]Downloaded[-]\n"
	case !e.Monitored:
		head += "[gray]Not monitored[-]\n"
	default:
		head += "[yellow]Not downloaded[-]\n"
	}
	aired := !at.IsZero() && at.Before(now) || at.IsZero() && day.Before(localDay(now))
	return calEntry{
		day: day, at: at, title: series, label: tview.Escape(series), sub: sub,
		have: e.HasFile, monitored: e.Monitored, missing: e.Monitored && !e.HasFile && aired,
		details: detailText{head: head, plot: tview.Escape(overview), people: episodeSeriesRef(e)}, cover: cover,
		episodeID: e.ID,
	}, true
}

// sortEntries orders by day, then time of day (date-only first), then title.
func sortEntries(es []calEntry) {
	slices.SortStableFunc(es, func(a, b calEntry) int {
		return cmp.Or(
			a.day.Compare(b.day),
			a.at.Compare(b.at),
			strings.Compare(strings.ToLower(a.title), strings.ToLower(b.title)),
			strings.Compare(a.sub, b.sub),
		)
	})
}

// dayLabel returns the date of a day and, for days near today, its relative
// name: ("Wed 21 Oct", "Tomorrow").
func dayLabel(day, today time.Time) (date, relative string) {
	date = day.Format("Mon 2 Jan")
	switch int(day.Sub(today).Round(24*time.Hour).Hours() / 24) { // Round: days are 23 or 25 hours long when the clocks change
	case 0:
		return date, "Today"
	case 1:
		return date, "Tomorrow"
	case -1:
		return date, "Yesterday"
	}
	return date, ""
}

// calendarView lists the movies and episodes coming up in a two-week window.
type calendarView struct {
	app    *App
	radarr *radarr.Client
	sonarr *sonarr.Client

	root    *tview.Flex
	header  *tview.TextView
	table   *tview.Table
	details *detailPane

	// UI-goroutine state.
	offset      int // days from today to the first day shown; moved with [ and ]
	unmonitored bool
	entries     []calEntry
	rows        []calRow
	loaded      bool
	gen         int
}

// calRow is a table row: a day header (entry == nil) or an entry.
type calRow struct {
	day   time.Time
	entry *calEntry
}

func newCalendarView(app *App, r *radarr.Client, s *sonarr.Client) *calendarView {
	v := &calendarView{
		app: app, radarr: r, sonarr: s,
		header:  tview.NewTextView().SetDynamicColors(true),
		table:   tview.NewTable().SetSelectable(true, false).SetFixed(0, 0),
		details: newDetailPane(app),
	}
	v.table.SetBorder(true).SetTitle(" Upcoming ")
	v.root = tview.NewFlex().SetDirection(tview.FlexRow).
		AddItem(v.header, 1, 0, false).
		AddItem(tview.NewFlex().
			AddItem(v.table, 0, 3, true).
			AddItem(v.details, 0, 2, false), 0, 1, true)

	v.table.SetSelectionChangedFunc(func(int, int) { v.renderDetails() })
	v.table.SetSelectedFunc(func(int, int) { v.open() })
	v.table.SetInputCapture(v.handleKey)
	app.reconnect = append(app.reconnect, func() { v.entries, v.loaded = nil, false })
	v.render()
	return v
}

func (v *calendarView) handleKey(ev *tcell.EventKey) *tcell.EventKey {
	if ev.Key() != tcell.KeyRune {
		return ev
	}
	switch ev.Rune() {
	case '[':
		v.offset -= calendarStep
		v.reload()
	case ']':
		v.offset += calendarStep
		v.reload()
	case 't':
		v.offset = 0
		v.reload()
	case 'u':
		v.unmonitored = !v.unmonitored
		v.reload()
	case 'r':
		v.reload()
	case 'i':
		v.open()
	case 's':
		v.search()
	default:
		return ev
	}
	return nil
}

// window returns the first and last day shown.
func (v *calendarView) window(now time.Time) (from, to time.Time) {
	from = localDay(now).AddDate(0, 0, v.offset)
	return from, from.AddDate(0, 0, calendarDays-1)
}

func (v *calendarView) activate() { v.reload() }

// reload fetches both calendars in parallel.
func (v *calendarView) reload() {
	v.gen++
	gen, unmonitored := v.gen, v.unmonitored
	now := time.Now()
	from, to := v.window(now)
	v.render()

	go func() {
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cancel()
		var (
			wg              sync.WaitGroup
			movies          []radarr.Movie
			episodes        []sonarr.Episode
			movieErr, tvErr error
		)
		wg.Add(2)
		go func() { defer wg.Done(); movies, movieErr = v.radarr.Calendar(ctx, from, to, unmonitored) }()
		go func() { defer wg.Done(); episodes, tvErr = v.sonarr.Calendar(ctx, from, to, unmonitored) }()
		wg.Wait()

		var entries []calEntry
		for _, m := range movies {
			entries = append(entries, movieEntries(m, from, to, coverFor(v.radarr.Client, m.Images, true), now)...)
		}
		for _, e := range episodes {
			var cover coverRef
			if e.Series != nil {
				cover = coverFor(v.sonarr.Client, e.Series.Images, true)
			}
			if entry, ok := episodeEntry(e, from, to, cover, now); ok {
				entries = append(entries, entry)
			}
		}
		sortEntries(entries)

		v.app.post(func() {
			v.app.SetService("Radarr", "", movieErr)
			v.app.SetService("Sonarr", "", tvErr)
			if gen != v.gen {
				return
			}
			// A service that is not set up just contributes nothing.
			usable := func(err error) bool { return err == nil || notConfigured(err) }
			for _, err := range []error{movieErr, tvErr} {
				if !usable(err) {
					v.app.SetMessage("[red]Calendar: " + tview.Escape(err.Error()))
				}
			}
			if usable(movieErr) || usable(tvErr) { // show what we got
				v.entries, v.loaded = entries, true
			}
			v.render()
		})
	}()
}

func (v *calendarView) selected() (*calEntry, bool) {
	r, _ := v.table.GetSelection()
	if r < 0 || r >= len(v.rows) || v.rows[r].entry == nil {
		return nil, false
	}
	return v.rows[r].entry, true
}

func (v *calendarView) render() {
	selKey := ""
	if e, ok := v.selected(); ok {
		selKey = e.key()
	}
	now := time.Now()
	today := localDay(now)
	from, to := v.window(now)

	v.rows = v.rows[:0]
	var lastDay time.Time
	for i := range v.entries {
		e := &v.entries[i]
		if !e.day.Equal(lastDay) {
			v.rows = append(v.rows, calRow{day: e.day})
			lastDay = e.day
		}
		v.rows = append(v.rows, calRow{day: e.day, entry: e})
	}

	v.table.Clear()
	selRow, firstEntry := 0, -1
	for i, r := range v.rows {
		if r.entry == nil {
			date, relative := dayLabel(r.day, today)
			v.table.SetCell(i, 0, tview.NewTableCell("[::b][yellow]"+date).SetSelectable(false))
			v.table.SetCell(i, 1, tview.NewTableCell("").SetSelectable(false))
			v.table.SetCell(i, 2, tview.NewTableCell("[yellow]"+relative).SetSelectable(false))
			v.table.SetCell(i, 3, tview.NewTableCell("").SetSelectable(false))
			continue
		}
		e := r.entry
		if firstEntry < 0 {
			firstEntry = i
		}
		when := "      "
		if !e.at.IsZero() {
			when = e.at.Format("15:04") + " "
		}
		kind := "[blue]TV   "
		if e.movie {
			kind = "[purple]Movie"
		}
		v.table.SetCell(i, 0, tview.NewTableCell("  "+when).SetSelectable(true))
		v.table.SetCell(i, 1, tview.NewTableCell(kind+"[-]"))
		v.table.SetCell(i, 2, tview.NewTableCell(e.label+" [gray]"+tview.Escape(e.sub)).SetExpansion(1))
		v.table.SetCell(i, 3, tview.NewTableCell(calStatus(*e)))
		if selKey != "" && e.key() == selKey {
			selRow = i
		}
	}

	title := " Upcoming · " + from.Format("2 Jan") + " – " + to.Format("2 Jan") + " "
	if v.unmonitored {
		title += "· incl. unmonitored "
	}
	v.table.SetTitle(title)
	switch {
	case len(v.entries) == 0:
		msg := "Loading…"
		if v.loaded {
			msg = "Nothing in this period"
		}
		v.table.SetCell(0, 0, tview.NewTableCell("[gray]"+msg).SetSelectable(false))
		v.table.SetSelectable(false, false)
		v.table.Select(0, 0)
	default:
		v.table.SetSelectable(true, false)
		if selRow == 0 {
			selRow = firstEntry
		}
		v.table.Select(selRow, 0)
		if selRow == firstEntry {
			v.table.ScrollToBeginning()
		}
	}
	v.header.SetText("[::b]Calendar[::-] · [ ] move by a week · t today · u unmonitored · Enter releases · s search")
	v.renderDetails()
}

// calStatus is the coloured status text of an entry.
func calStatus(e calEntry) string {
	switch {
	case e.have:
		return "[green]✓ downloaded"
	case !e.monitored:
		return "[gray]unmonitored"
	case e.missing:
		return "[yellow]missing"
	}
	return "[gray]upcoming"
}

func (v *calendarView) renderDetails() {
	if e, ok := v.selected(); ok {
		v.details.Show(e.details, e.cover)
		return
	}
	v.details.Clear()
}

// open starts the interactive release search for the selected entry.
func (v *calendarView) open() {
	e, ok := v.selected()
	if !ok {
		return
	}
	if e.movie {
		id, title := e.movieID, tview.Escape(e.title)
		v.app.openReleases("Releases for "+title,
			func(ctx context.Context) ([]arr.Release, error) { return v.radarr.Releases(ctx, id) },
			v.radarr.Grab)
		return
	}
	id := e.episodeID
	v.app.openReleases("Releases for "+e.label+" "+tview.Escape(e.sub),
		func(ctx context.Context) ([]arr.Release, error) { return v.sonarr.EpisodeReleases(ctx, id) },
		v.sonarr.Grab)
}

// search starts an automatic search for the selected entry.
func (v *calendarView) search() {
	e, ok := v.selected()
	if !ok {
		return
	}
	what := e.label
	if !e.movie {
		what += " " + tview.Escape(e.sub)
	}
	v.app.SetMessage("Searching for " + what + "…")
	movie, movieID, episodeID := e.movie, e.movieID, e.episodeID
	go func() {
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cancel()
		var err error
		if movie {
			err = v.radarr.SearchMovie(ctx, movieID)
		} else {
			err = v.sonarr.SearchEpisode(ctx, episodeID)
		}
		v.app.post(func() {
			if err != nil {
				v.app.SetMessage("[red]" + tview.Escape(err.Error()))
				return
			}
			v.app.SetMessage("[green]Search started for " + what)
		})
	}()
}

// episodeSeriesRef names the series of a calendar episode for its cast.
func episodeSeriesRef(e sonarr.Episode) trakt.Ref {
	if e.Series == nil {
		return trakt.Ref{}
	}
	return seriesRef(*e.Series)
}