mirror of
https://github.com/AmanTahiliani/box-box.git
synced 2026-08-07 19:56:18 -04:00
924 lines
24 KiB
Go
924 lines
24 KiB
Go
package ui
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/AmanTahiliani/box-box/internal/api"
|
|
"github.com/AmanTahiliani/box-box/internal/models"
|
|
"github.com/charmbracelet/bubbles/spinner"
|
|
"github.com/charmbracelet/bubbles/viewport"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
)
|
|
|
|
type RaceDetailModel struct {
|
|
client *api.OpenF1Client
|
|
meeting *models.Meeting
|
|
|
|
sessions []models.Session
|
|
results []models.SessionResult
|
|
drivers map[int]models.Driver
|
|
rcMsgs []models.RaceControl
|
|
weather []models.Weather
|
|
overtakes []models.Overtake
|
|
|
|
selectedSession *models.Session
|
|
sessionCursor int
|
|
resultsCursor int
|
|
resultsScroll int
|
|
|
|
loadingSessions bool
|
|
loadingResults bool
|
|
driversLoaded bool
|
|
secondaryLoading bool
|
|
errSessions error
|
|
errResults error
|
|
|
|
spinner spinner.Model
|
|
rcView viewport.Model
|
|
rcReady bool
|
|
|
|
width int
|
|
height int
|
|
}
|
|
|
|
func NewRaceDetailModel(client *api.OpenF1Client) RaceDetailModel {
|
|
s := spinner.New()
|
|
s.Spinner = spinner.MiniDot
|
|
s.Style = lipgloss.NewStyle().Foreground(lipgloss.Color(colorF1Red))
|
|
|
|
return RaceDetailModel{
|
|
client: client,
|
|
spinner: s,
|
|
drivers: make(map[int]models.Driver),
|
|
}
|
|
}
|
|
|
|
func (m RaceDetailModel) Init() tea.Cmd {
|
|
return m.spinner.Tick
|
|
}
|
|
|
|
func fetchSessions(client *api.OpenF1Client, meetingKey int) tea.Cmd {
|
|
return func() tea.Msg {
|
|
sessions, err := client.GetSessionsForMeeting(meetingKey)
|
|
return sessionsLoadedMsg{sessions: sessions, err: err}
|
|
}
|
|
}
|
|
|
|
// fetchSessionData fetches primary data (results + drivers) for a session.
|
|
// Secondary data (race control, weather, overtakes) is loaded after primary data arrives.
|
|
func fetchSessionData(client *api.OpenF1Client, sessionKey int) tea.Cmd {
|
|
return tea.Batch(
|
|
func() tea.Msg {
|
|
results, err := client.GetSessionResult(sessionKey)
|
|
return sessionResultsLoadedMsg{results: results, err: err}
|
|
},
|
|
func() tea.Msg {
|
|
drivers, err := client.GetDriversForSession(sessionKey)
|
|
return sessionDriversLoadedMsg{drivers: drivers, err: err}
|
|
},
|
|
)
|
|
}
|
|
|
|
// fetchSecondaryData fetches lower-priority data (race control, weather, overtakes).
|
|
func fetchSecondaryData(client *api.OpenF1Client, sessionKey int) tea.Cmd {
|
|
return tea.Batch(
|
|
func() tea.Msg {
|
|
msgs, err := client.GetRaceControl(sessionKey)
|
|
return raceControlLoadedMsg{messages: msgs, err: err}
|
|
},
|
|
func() tea.Msg {
|
|
weather, err := client.GetWeather(sessionKey)
|
|
return weatherLoadedMsg{weather: weather, err: err}
|
|
},
|
|
func() tea.Msg {
|
|
overtakes, err := client.GetOvertakesForSession(sessionKey)
|
|
return overtakesLoadedMsg{overtakes: overtakes, err: err}
|
|
},
|
|
)
|
|
}
|
|
|
|
func (m RaceDetailModel) Update(msg tea.Msg) (RaceDetailModel, tea.Cmd) {
|
|
var cmds []tea.Cmd
|
|
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
// handled by SetSize from app.go
|
|
|
|
case spinner.TickMsg:
|
|
if m.loadingSessions || m.loadingResults {
|
|
var cmd tea.Cmd
|
|
m.spinner, cmd = m.spinner.Update(msg)
|
|
cmds = append(cmds, cmd)
|
|
}
|
|
|
|
case meetingSelectedMsg:
|
|
m.meeting = &msg.meeting
|
|
m.sessions = nil
|
|
m.results = nil
|
|
m.rcMsgs = nil
|
|
m.weather = nil
|
|
m.overtakes = nil
|
|
m.selectedSession = nil
|
|
m.sessionCursor = 0
|
|
m.resultsCursor = 0
|
|
m.resultsScroll = 0
|
|
m.loadingSessions = true
|
|
m.loadingResults = false
|
|
m.driversLoaded = false
|
|
m.secondaryLoading = false
|
|
m.errSessions = nil
|
|
m.errResults = nil
|
|
m.rcReady = false
|
|
cmds = append(cmds, fetchSessions(m.client, int(msg.meeting.MeetingKey)), m.spinner.Tick)
|
|
|
|
case sessionsLoadedMsg:
|
|
m.loadingSessions = false
|
|
if msg.err != nil {
|
|
m.errSessions = msg.err
|
|
return m, nil
|
|
}
|
|
m.sessions = msg.sessions
|
|
// Auto-select the Race session and load its data
|
|
raceIdx := -1
|
|
for i, s := range m.sessions {
|
|
if s.SessionName == "Race" {
|
|
raceIdx = i
|
|
break
|
|
}
|
|
}
|
|
if raceIdx >= 0 {
|
|
m.sessionCursor = raceIdx
|
|
sess := m.sessions[raceIdx]
|
|
m.selectedSession = &sess
|
|
m.loadingResults = true
|
|
m.driversLoaded = false
|
|
m.secondaryLoading = false
|
|
m.results = nil
|
|
m.rcMsgs = nil
|
|
m.weather = nil
|
|
m.drivers = make(map[int]models.Driver)
|
|
cmds = append(cmds, m.spinner.Tick, fetchSessionData(m.client, sess.SessionKey))
|
|
} else if len(m.sessions) > 0 {
|
|
// Fallback: select last session
|
|
lastIdx := len(m.sessions) - 1
|
|
m.sessionCursor = lastIdx
|
|
sess := m.sessions[lastIdx]
|
|
m.selectedSession = &sess
|
|
m.loadingResults = true
|
|
m.driversLoaded = false
|
|
m.secondaryLoading = false
|
|
m.drivers = make(map[int]models.Driver)
|
|
cmds = append(cmds, m.spinner.Tick, fetchSessionData(m.client, sess.SessionKey))
|
|
}
|
|
|
|
case sessionResultsLoadedMsg:
|
|
if msg.err != nil {
|
|
m.errResults = msg.err
|
|
m.loadingResults = false
|
|
return m, nil
|
|
}
|
|
m.results = msg.results
|
|
m.resultsCursor = 0
|
|
m.resultsScroll = 0
|
|
if cmd := m.checkPrimaryLoaded(); cmd != nil {
|
|
cmds = append(cmds, cmd)
|
|
}
|
|
|
|
case sessionDriversLoadedMsg:
|
|
if msg.err == nil {
|
|
for _, d := range msg.drivers {
|
|
m.drivers[d.DriverNumber] = d
|
|
}
|
|
}
|
|
m.driversLoaded = true
|
|
if cmd := m.checkPrimaryLoaded(); cmd != nil {
|
|
cmds = append(cmds, cmd)
|
|
}
|
|
|
|
case loadSecondaryDataMsg:
|
|
// Only load secondary data if it's still for the currently selected session
|
|
if m.selectedSession != nil && m.selectedSession.SessionKey == msg.sessionKey {
|
|
cmds = append(cmds, fetchSecondaryData(m.client, msg.sessionKey))
|
|
}
|
|
|
|
case raceControlLoadedMsg:
|
|
if msg.err == nil {
|
|
m.rcMsgs = msg.messages
|
|
m.updateRCViewport()
|
|
}
|
|
|
|
case weatherLoadedMsg:
|
|
if msg.err == nil {
|
|
m.weather = msg.weather
|
|
}
|
|
|
|
case overtakesLoadedMsg:
|
|
if msg.err == nil {
|
|
m.overtakes = msg.overtakes
|
|
}
|
|
|
|
case tea.KeyMsg:
|
|
switch {
|
|
case matchKey(msg, GlobalKeys.Retry):
|
|
if m.errSessions != nil && m.meeting != nil {
|
|
m.errSessions = nil
|
|
m.loadingSessions = true
|
|
cmds = append(cmds, m.spinner.Tick, fetchSessions(m.client, int(m.meeting.MeetingKey)))
|
|
} else if m.errResults != nil && m.selectedSession != nil {
|
|
m.errResults = nil
|
|
m.loadingResults = true
|
|
m.driversLoaded = false
|
|
m.secondaryLoading = false
|
|
cmds = append(cmds, m.spinner.Tick, fetchSessionData(m.client, m.selectedSession.SessionKey))
|
|
}
|
|
case matchKey(msg, GlobalKeys.Up):
|
|
if m.results != nil && m.resultsCursor > 0 {
|
|
m.resultsCursor--
|
|
m.ensureResultsVisible()
|
|
}
|
|
case matchKey(msg, GlobalKeys.Down):
|
|
if m.results != nil && m.resultsCursor < len(m.results)-1 {
|
|
m.resultsCursor++
|
|
m.ensureResultsVisible()
|
|
}
|
|
case matchKey(msg, GlobalKeys.GoTop):
|
|
if m.results != nil {
|
|
m.resultsCursor = 0
|
|
m.resultsScroll = 0
|
|
}
|
|
case matchKey(msg, GlobalKeys.GoBottom):
|
|
if m.results != nil && len(m.results) > 0 {
|
|
m.resultsCursor = len(m.results) - 1
|
|
m.ensureResultsVisible()
|
|
}
|
|
case matchKey(msg, GlobalKeys.HalfUp):
|
|
if m.results != nil {
|
|
half := m.resultsVisibleRows() / 2
|
|
m.resultsCursor -= half
|
|
if m.resultsCursor < 0 {
|
|
m.resultsCursor = 0
|
|
}
|
|
m.ensureResultsVisible()
|
|
}
|
|
case matchKey(msg, GlobalKeys.HalfDown):
|
|
if m.results != nil {
|
|
half := m.resultsVisibleRows() / 2
|
|
m.resultsCursor += half
|
|
if m.resultsCursor >= len(m.results) {
|
|
m.resultsCursor = len(m.results) - 1
|
|
}
|
|
m.ensureResultsVisible()
|
|
}
|
|
case matchKey(msg, GlobalKeys.Enter):
|
|
if len(m.sessions) > 0 && m.sessionCursor < len(m.sessions) {
|
|
sess := m.sessions[m.sessionCursor]
|
|
m.selectedSession = &sess
|
|
m.loadingResults = true
|
|
m.driversLoaded = false
|
|
m.secondaryLoading = false
|
|
m.errResults = nil
|
|
m.results = nil
|
|
m.rcMsgs = nil
|
|
m.weather = nil
|
|
m.overtakes = nil
|
|
m.resultsCursor = 0
|
|
m.resultsScroll = 0
|
|
m.drivers = make(map[int]models.Driver)
|
|
cmds = append(cmds, m.spinner.Tick, fetchSessionData(m.client, sess.SessionKey))
|
|
}
|
|
case matchKey(msg, RaceDetailKeys.ScrollUp):
|
|
m.rcView.LineUp(3)
|
|
case matchKey(msg, RaceDetailKeys.ScrollDown):
|
|
m.rcView.LineDown(3)
|
|
case matchKey(msg, RaceDetailKeys.PrevSession):
|
|
if m.sessionCursor > 0 {
|
|
m.sessionCursor--
|
|
sess := m.sessions[m.sessionCursor]
|
|
if m.selectedSession == nil || m.selectedSession.SessionKey != sess.SessionKey {
|
|
m.selectedSession = &sess
|
|
m.loadingResults = true
|
|
m.driversLoaded = false
|
|
m.secondaryLoading = false
|
|
m.errResults = nil
|
|
m.results = nil
|
|
m.rcMsgs = nil
|
|
m.weather = nil
|
|
m.overtakes = nil
|
|
m.resultsCursor = 0
|
|
m.resultsScroll = 0
|
|
m.drivers = make(map[int]models.Driver)
|
|
cmds = append(cmds, m.spinner.Tick, fetchSessionData(m.client, sess.SessionKey))
|
|
}
|
|
}
|
|
case matchKey(msg, RaceDetailKeys.NextSession):
|
|
if m.sessionCursor < len(m.sessions)-1 {
|
|
m.sessionCursor++
|
|
sess := m.sessions[m.sessionCursor]
|
|
if m.selectedSession == nil || m.selectedSession.SessionKey != sess.SessionKey {
|
|
m.selectedSession = &sess
|
|
m.loadingResults = true
|
|
m.driversLoaded = false
|
|
m.secondaryLoading = false
|
|
m.errResults = nil
|
|
m.results = nil
|
|
m.rcMsgs = nil
|
|
m.weather = nil
|
|
m.overtakes = nil
|
|
m.resultsCursor = 0
|
|
m.resultsScroll = 0
|
|
m.drivers = make(map[int]models.Driver)
|
|
cmds = append(cmds, m.spinner.Tick, fetchSessionData(m.client, sess.SessionKey))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if m.rcReady {
|
|
var cmd tea.Cmd
|
|
m.rcView, cmd = m.rcView.Update(msg)
|
|
cmds = append(cmds, cmd)
|
|
}
|
|
|
|
return m, tea.Batch(cmds...)
|
|
}
|
|
|
|
// checkPrimaryLoaded checks if both results and drivers have arrived.
|
|
// If so, marks loading complete and returns a command to trigger secondary data loading.
|
|
func (m *RaceDetailModel) checkPrimaryLoaded() tea.Cmd {
|
|
if m.results != nil && m.driversLoaded {
|
|
m.loadingResults = false
|
|
if m.selectedSession != nil && !m.secondaryLoading {
|
|
m.secondaryLoading = true
|
|
return func() tea.Msg {
|
|
return loadSecondaryDataMsg{sessionKey: m.selectedSession.SessionKey}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m RaceDetailModel) resultsVisibleRows() int {
|
|
rows := m.height - 18
|
|
if rows < 5 {
|
|
rows = 5
|
|
}
|
|
return rows
|
|
}
|
|
|
|
func (m *RaceDetailModel) ensureResultsVisible() {
|
|
visible := m.resultsVisibleRows()
|
|
if m.resultsCursor < m.resultsScroll {
|
|
m.resultsScroll = m.resultsCursor
|
|
}
|
|
if m.resultsCursor >= m.resultsScroll+visible {
|
|
m.resultsScroll = m.resultsCursor - visible + 1
|
|
}
|
|
}
|
|
|
|
func (m *RaceDetailModel) updateRCViewport() {
|
|
content := m.renderRaceControlContent()
|
|
if m.rcReady {
|
|
m.rcView.SetContent(content)
|
|
m.rcView.GotoBottom()
|
|
}
|
|
}
|
|
|
|
func (m *RaceDetailModel) initViewport(w, h int) {
|
|
m.rcView = viewport.New(w, h)
|
|
m.rcReady = true
|
|
m.updateRCViewport()
|
|
}
|
|
|
|
func (m RaceDetailModel) View() string {
|
|
if m.meeting == nil {
|
|
return styleMuted.Render("\n Select a race from the Calendar tab (press 2).\n\n") +
|
|
helpBar("2 calendar", "q quit")
|
|
}
|
|
|
|
w := m.width
|
|
if w < 40 {
|
|
w = 40
|
|
}
|
|
compact := w < 100
|
|
|
|
var sb strings.Builder
|
|
|
|
// Race title header
|
|
flag := countryFlag(m.meeting.CountryCode)
|
|
titleStyle := lipgloss.NewStyle().
|
|
Bold(true).
|
|
Foreground(lipgloss.Color(colorF1Red))
|
|
|
|
if compact {
|
|
sb.WriteString(titleStyle.Render(fmt.Sprintf(" %s %s", flag, m.meeting.MeetingName)) + "\n")
|
|
} else {
|
|
sb.WriteString(titleStyle.Render(fmt.Sprintf(" %s %s", flag, m.meeting.MeetingOfficialName)) + "\n")
|
|
}
|
|
|
|
dates := formatMeetingDates(*m.meeting)
|
|
subtitle := fmt.Sprintf(" %s %s %s",
|
|
styleMuted.Render(m.meeting.Location),
|
|
styleMuted.Render("·"),
|
|
styleMuted.Render(dates))
|
|
sb.WriteString(subtitle + "\n\n")
|
|
|
|
// Session selector pills
|
|
sb.WriteString(m.renderSessionPills())
|
|
sb.WriteString("\n\n")
|
|
|
|
if compact {
|
|
// Single column layout for narrow terminals
|
|
sb.WriteString(m.renderResults(w - 4))
|
|
sb.WriteString("\n")
|
|
sb.WriteString(m.renderWeatherCard(w - 4))
|
|
sb.WriteString("\n")
|
|
sb.WriteString(m.renderOvertakes(w - 4))
|
|
sb.WriteString("\n")
|
|
sb.WriteString(styleSectionTitle.Render("RACE CONTROL") + "\n")
|
|
if !m.rcReady || m.selectedSession == nil {
|
|
sb.WriteString(styleMuted.Render(" No session selected.\n"))
|
|
} else {
|
|
// Show limited RC messages inline
|
|
lines := strings.Split(m.renderRaceControlContent(), "\n")
|
|
maxRC := 8
|
|
if len(lines) > maxRC {
|
|
lines = lines[len(lines)-maxRC:]
|
|
}
|
|
sb.WriteString(strings.Join(lines, "\n") + "\n")
|
|
if len(m.rcMsgs) > maxRC {
|
|
sb.WriteString(styleMuted.Render(fmt.Sprintf(" ... %d more messages (K/J scroll)", len(m.rcMsgs)-maxRC)) + "\n")
|
|
}
|
|
}
|
|
} else {
|
|
// Two-panel layout
|
|
leftWidth := int(float64(w) * 0.55)
|
|
rightWidth := w - leftWidth - 6
|
|
|
|
left := m.renderResults(leftWidth)
|
|
right := m.renderRightPanel(rightWidth)
|
|
|
|
panels := lipgloss.JoinHorizontal(lipgloss.Top,
|
|
stylePanelBorder.Width(leftWidth).Render(left),
|
|
stylePanelBorder.Width(rightWidth).Render(right),
|
|
)
|
|
|
|
sb.WriteString(panels + "\n")
|
|
}
|
|
|
|
sb.WriteString(helpBar("[/] sessions", "j/k results", "g/G top/bottom", "K/J scroll RC", "b back", "q quit"))
|
|
return sb.String()
|
|
}
|
|
|
|
func (m RaceDetailModel) renderSessionPills() string {
|
|
if m.loadingSessions {
|
|
return fmt.Sprintf(" %s Loading sessions...", m.spinner.View())
|
|
}
|
|
if m.errSessions != nil {
|
|
return renderErrorView(m.errSessions)
|
|
}
|
|
|
|
var pills []string
|
|
for i, sess := range m.sessions {
|
|
// Format date
|
|
var dateStr string
|
|
if len(sess.DateStart) >= 10 {
|
|
t, err := time.Parse(time.RFC3339, sess.DateStart)
|
|
if err == nil {
|
|
dateStr = t.Local().Format("Mon 2")
|
|
} else {
|
|
dateStr = sess.DateStart[:10]
|
|
}
|
|
}
|
|
|
|
label := fmt.Sprintf("%s %s", sess.SessionName, dateStr)
|
|
|
|
if m.selectedSession != nil && m.selectedSession.SessionKey == sess.SessionKey {
|
|
pills = append(pills, styleSessionActive.Render(label))
|
|
} else if i == m.sessionCursor {
|
|
pills = append(pills, styleSessionCursor.Render(label))
|
|
} else {
|
|
pills = append(pills, styleSessionInactive.Render(label))
|
|
}
|
|
}
|
|
|
|
return " " + strings.Join(pills, " ")
|
|
}
|
|
|
|
func (m RaceDetailModel) renderResults(width int) string {
|
|
var sb strings.Builder
|
|
|
|
sb.WriteString(styleSectionTitle.Render("RESULTS") + "\n")
|
|
|
|
if m.loadingResults {
|
|
sb.WriteString(fmt.Sprintf(" %s Loading results...\n", m.spinner.View()))
|
|
return sb.String()
|
|
}
|
|
if m.errResults != nil {
|
|
sb.WriteString(renderErrorView(m.errResults))
|
|
return sb.String()
|
|
}
|
|
if m.selectedSession == nil {
|
|
sb.WriteString(styleMuted.Render(" Use [ ] to select a session.\n"))
|
|
return sb.String()
|
|
}
|
|
if len(m.results) == 0 {
|
|
sb.WriteString(styleMuted.Render(" No results available.\n"))
|
|
return sb.String()
|
|
}
|
|
|
|
isRace := m.selectedSession.SessionType == "Race"
|
|
compact := width < 55
|
|
|
|
// Responsive team name width
|
|
teamWidth := 16
|
|
if width >= 70 {
|
|
teamWidth = 20
|
|
} else if compact {
|
|
teamWidth = 10
|
|
}
|
|
|
|
// Column header
|
|
var header string
|
|
if isRace {
|
|
if compact {
|
|
header = fmt.Sprintf(" %s %s %s %s %s",
|
|
padRight("P", 3),
|
|
padRight("", 1),
|
|
padRight("DRV", 4),
|
|
padLeft("GAP", 10),
|
|
padLeft("PTS", 4),
|
|
)
|
|
} else {
|
|
header = fmt.Sprintf(" %s %s %s %s %s %s %s",
|
|
padRight("P", 3),
|
|
padRight("", 1),
|
|
padRight("DRV", 4),
|
|
padRight("TEAM", teamWidth),
|
|
padLeft("LAPS", 4),
|
|
padLeft("GAP", 12),
|
|
padLeft("PTS", 4),
|
|
)
|
|
}
|
|
} else {
|
|
if compact {
|
|
header = fmt.Sprintf(" %s %s %s %s",
|
|
padRight("P", 3),
|
|
padRight("", 1),
|
|
padRight("DRV", 4),
|
|
padLeft("TIME", 12),
|
|
)
|
|
} else {
|
|
header = fmt.Sprintf(" %s %s %s %s %s",
|
|
padRight("P", 3),
|
|
padRight("", 1),
|
|
padRight("DRV", 4),
|
|
padRight("TEAM", teamWidth),
|
|
padLeft("TIME", 12),
|
|
)
|
|
}
|
|
}
|
|
sb.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color(colorMuted)).Bold(true).Render(header) + "\n")
|
|
sb.WriteString(" " + divider(min(width-4, lipgloss.Width(header))) + "\n")
|
|
|
|
visible := m.resultsVisibleRows()
|
|
endIdx := m.resultsScroll + visible
|
|
if endIdx > len(m.results) {
|
|
endIdx = len(m.results)
|
|
}
|
|
|
|
for i := m.resultsScroll; i < endIdx; i++ {
|
|
r := m.results[i]
|
|
d := m.drivers[r.DriverNumber]
|
|
acronym := d.NameAcronym
|
|
if acronym == "" {
|
|
acronym = fmt.Sprintf("#%d", r.DriverNumber)
|
|
}
|
|
|
|
teamColor := colorMuted
|
|
if d.TeamColour != "" {
|
|
teamColor = "#" + d.TeamColour
|
|
} else if d.TeamName != "" {
|
|
teamColor = teamColorFromName(d.TeamName)
|
|
}
|
|
|
|
colorBar := lipgloss.NewStyle().Foreground(lipgloss.Color(teamColor)).Render("┃")
|
|
|
|
// Position with status
|
|
var pos string
|
|
if r.DNF {
|
|
pos = styleDNF.Render("DNF")
|
|
} else if r.DNS {
|
|
pos = styleDNF.Render("DNS")
|
|
} else if r.DSQ {
|
|
pos = styleDNF.Render("DSQ")
|
|
} else {
|
|
pos = renderPosition(r.Position)
|
|
}
|
|
|
|
var row string
|
|
if isRace {
|
|
gap := formatGap(r.GapToLeader)
|
|
var gapStyled string
|
|
if gap == "LEADER" {
|
|
gapStyled = styleLeader.Render("LEADER")
|
|
} else {
|
|
gapStyled = styleGap.Render(gap)
|
|
}
|
|
|
|
if compact {
|
|
row = fmt.Sprintf(" %s %s %s %s %s",
|
|
padRightVisible(pos, 3),
|
|
colorBar,
|
|
padRight(acronym, 4),
|
|
padLeftVisible(gapStyled, 10),
|
|
padLeft(fmt.Sprintf("%.0f", r.Points), 4),
|
|
)
|
|
} else {
|
|
row = fmt.Sprintf(" %s %s %s %s %s %s %s",
|
|
padRightVisible(pos, 3),
|
|
colorBar,
|
|
padRight(acronym, 4),
|
|
padRight(truncate(d.TeamName, teamWidth), teamWidth),
|
|
padLeft(fmt.Sprintf("%d", r.NumberOfLaps), 4),
|
|
padLeftVisible(gapStyled, 12),
|
|
padLeft(fmt.Sprintf("%.0f", r.Points), 4),
|
|
)
|
|
}
|
|
} else {
|
|
dur := formatDuration(r.Duration)
|
|
if compact {
|
|
row = fmt.Sprintf(" %s %s %s %s",
|
|
padRightVisible(pos, 3),
|
|
colorBar,
|
|
padRight(acronym, 4),
|
|
padLeft(dur, 12),
|
|
)
|
|
} else {
|
|
row = fmt.Sprintf(" %s %s %s %s %s",
|
|
padRightVisible(pos, 3),
|
|
colorBar,
|
|
padRight(acronym, 4),
|
|
padRight(truncate(d.TeamName, teamWidth), teamWidth),
|
|
padLeft(dur, 12),
|
|
)
|
|
}
|
|
}
|
|
|
|
if i == m.resultsCursor {
|
|
row = styleSelected.Render(row)
|
|
}
|
|
sb.WriteString(row + "\n")
|
|
}
|
|
|
|
return sb.String()
|
|
}
|
|
|
|
func (m RaceDetailModel) renderRightPanel(width int) string {
|
|
var sb strings.Builder
|
|
|
|
// Weather card at the top
|
|
sb.WriteString(m.renderWeatherCard(width))
|
|
sb.WriteString("\n")
|
|
|
|
// Overtakes summary
|
|
sb.WriteString(m.renderOvertakes(width))
|
|
sb.WriteString("\n")
|
|
|
|
// Race control
|
|
sb.WriteString(styleSectionTitle.Render("RACE CONTROL") + "\n")
|
|
if !m.rcReady || m.selectedSession == nil {
|
|
sb.WriteString(styleMuted.Render(" No session selected.\n"))
|
|
} else {
|
|
sb.WriteString(m.rcView.View() + "\n")
|
|
}
|
|
|
|
return sb.String()
|
|
}
|
|
|
|
func (m RaceDetailModel) renderRaceControlContent() string {
|
|
if len(m.rcMsgs) == 0 {
|
|
return styleMuted.Render(" No race control messages.")
|
|
}
|
|
|
|
var lines []string
|
|
for _, rc := range m.rcMsgs {
|
|
t := "--:--"
|
|
if len(rc.Date) >= 16 {
|
|
pt, err := time.Parse(time.RFC3339, rc.Date)
|
|
if err == nil {
|
|
t = pt.Format("15:04")
|
|
} else {
|
|
t = rc.Date[11:16]
|
|
}
|
|
}
|
|
|
|
// Category-specific icon and styling
|
|
var prefix string
|
|
switch rc.Category {
|
|
case models.CategorySafetyCar:
|
|
prefix = styleSafetyCar.Render(fmt.Sprintf(" ⚠ [%s]", t))
|
|
case models.CategoryDRS:
|
|
prefix = styleDRS.Render(fmt.Sprintf(" ▸ [%s]", t))
|
|
default:
|
|
// Flag-based coloring
|
|
var flagStyle lipgloss.Style
|
|
switch rc.Flag {
|
|
case models.FlagGreen:
|
|
flagStyle = styleFlagGreen
|
|
case models.FlagYellow, models.FlagDoubleYellow:
|
|
flagStyle = styleFlagYellow
|
|
case models.FlagRed:
|
|
flagStyle = styleFlagRed
|
|
case models.FlagBlue:
|
|
flagStyle = styleFlagBlue
|
|
case models.FlagChequered:
|
|
flagStyle = lipgloss.NewStyle().Foreground(lipgloss.Color(colorWhite)).Bold(true)
|
|
default:
|
|
flagStyle = styleMuted
|
|
}
|
|
|
|
icon := " "
|
|
switch rc.Flag {
|
|
case models.FlagGreen:
|
|
icon = "🟢"
|
|
case models.FlagYellow:
|
|
icon = "🟡"
|
|
case models.FlagDoubleYellow:
|
|
icon = "🟡"
|
|
case models.FlagRed:
|
|
icon = "🔴"
|
|
case models.FlagBlue:
|
|
icon = "🔵"
|
|
case models.FlagChequered:
|
|
icon = "🏁"
|
|
default:
|
|
icon = " "
|
|
}
|
|
prefix = flagStyle.Render(fmt.Sprintf(" %s [%s]", icon, t))
|
|
}
|
|
|
|
lines = append(lines, fmt.Sprintf("%s %s", prefix, rc.Message))
|
|
}
|
|
|
|
return strings.Join(lines, "\n")
|
|
}
|
|
|
|
func (m RaceDetailModel) renderWeatherCard(width int) string {
|
|
var sb strings.Builder
|
|
sb.WriteString(styleSectionTitle.Render("WEATHER") + "\n")
|
|
|
|
if len(m.weather) == 0 {
|
|
sb.WriteString(styleMuted.Render(" No weather data.\n"))
|
|
return sb.String()
|
|
}
|
|
|
|
w := m.weather[len(m.weather)-1]
|
|
|
|
// Weather conditions
|
|
var condStr string
|
|
if w.Rainfall > 0 {
|
|
condStr = styleRain.Render("🌧 Rain")
|
|
} else {
|
|
condStr = styleDry.Render("☀ Dry")
|
|
}
|
|
|
|
sb.WriteString(fmt.Sprintf(" %s %s %s %s %s %s %s %s %s%.1fm/s\n",
|
|
condStr,
|
|
styleWeatherLabel.Render("Air:"),
|
|
styleWeatherValue.Render(fmt.Sprintf("%.1f°C", w.AirTemperature)),
|
|
styleWeatherLabel.Render("Track:"),
|
|
styleWeatherValue.Render(fmt.Sprintf("%.1f°C", w.TrackTemperature)),
|
|
styleWeatherLabel.Render("Humidity:"),
|
|
styleWeatherValue.Render(fmt.Sprintf("%.0f%%", w.Humidity)),
|
|
styleWeatherLabel.Render("Wind:"),
|
|
styleWeatherValue.Render(windArrow(w.WindDirection)+" "),
|
|
w.WindSpeed,
|
|
))
|
|
|
|
return sb.String()
|
|
}
|
|
|
|
func (m *RaceDetailModel) SetSize(w, h int) {
|
|
m.width = w
|
|
m.height = h
|
|
if w < 40 {
|
|
w = 40
|
|
}
|
|
compact := w < 100
|
|
var rightWidth, rcHeight int
|
|
if compact {
|
|
rightWidth = w - 6
|
|
rcHeight = 8
|
|
} else {
|
|
rightWidth = int(float64(w)*0.45) - 8
|
|
rcHeight = h - 14
|
|
}
|
|
if rcHeight < 3 {
|
|
rcHeight = 3
|
|
}
|
|
if !m.rcReady {
|
|
m.initViewport(rightWidth, rcHeight)
|
|
} else {
|
|
m.rcView.Width = rightWidth
|
|
m.rcView.Height = rcHeight
|
|
}
|
|
}
|
|
|
|
// renderOvertakes renders the overtakes summary section.
|
|
func (m RaceDetailModel) renderOvertakes(width int) string {
|
|
var sb strings.Builder
|
|
sb.WriteString(styleSectionTitle.Render("OVERTAKES") + "\n")
|
|
|
|
if len(m.overtakes) == 0 {
|
|
sb.WriteString(styleMuted.Render(" No overtake data.\n"))
|
|
return sb.String()
|
|
}
|
|
|
|
// Total count
|
|
sb.WriteString(fmt.Sprintf(" %s %s\n",
|
|
styleWeatherLabel.Render("Total:"),
|
|
lipgloss.NewStyle().Foreground(lipgloss.Color(colorYellow)).Bold(true).Render(fmt.Sprintf("%d", len(m.overtakes))),
|
|
))
|
|
|
|
// Tally: which drivers overtook the most?
|
|
type driverOvertakes struct {
|
|
driverNum int
|
|
overtaking int // times this driver overtook someone
|
|
overtaken int // times this driver was overtaken
|
|
}
|
|
stats := make(map[int]*driverOvertakes)
|
|
for _, o := range m.overtakes {
|
|
if _, ok := stats[o.OvertakingDriverNumber]; !ok {
|
|
stats[o.OvertakingDriverNumber] = &driverOvertakes{driverNum: o.OvertakingDriverNumber}
|
|
}
|
|
stats[o.OvertakingDriverNumber].overtaking++
|
|
|
|
if _, ok := stats[o.OvertakenDriverNumber]; !ok {
|
|
stats[o.OvertakenDriverNumber] = &driverOvertakes{driverNum: o.OvertakenDriverNumber}
|
|
}
|
|
stats[o.OvertakenDriverNumber].overtaken++
|
|
}
|
|
|
|
// Find top overtakers (sorted by most overtakes made)
|
|
type rankedDriver struct {
|
|
driverNum int
|
|
overtaking int
|
|
overtaken int
|
|
}
|
|
var ranked []rankedDriver
|
|
for _, s := range stats {
|
|
ranked = append(ranked, rankedDriver{driverNum: s.driverNum, overtaking: s.overtaking, overtaken: s.overtaken})
|
|
}
|
|
|
|
// Sort by overtaking count descending
|
|
for i := 0; i < len(ranked); i++ {
|
|
for j := i + 1; j < len(ranked); j++ {
|
|
if ranked[j].overtaking > ranked[i].overtaking {
|
|
ranked[i], ranked[j] = ranked[j], ranked[i]
|
|
}
|
|
}
|
|
}
|
|
|
|
// Show top 5 overtakers
|
|
maxShow := 5
|
|
if len(ranked) < maxShow {
|
|
maxShow = len(ranked)
|
|
}
|
|
for i := 0; i < maxShow; i++ {
|
|
r := ranked[i]
|
|
d := m.drivers[r.driverNum]
|
|
acronym := d.NameAcronym
|
|
if acronym == "" {
|
|
acronym = fmt.Sprintf("#%d", r.driverNum)
|
|
}
|
|
|
|
teamColor := colorMuted
|
|
if d.TeamColour != "" {
|
|
teamColor = "#" + d.TeamColour
|
|
} else if d.TeamName != "" {
|
|
teamColor = teamColorFromName(d.TeamName)
|
|
}
|
|
|
|
colorBar := lipgloss.NewStyle().Foreground(lipgloss.Color(teamColor)).Render("┃")
|
|
|
|
overtakingStr := lipgloss.NewStyle().
|
|
Foreground(lipgloss.Color(colorGreen)).Bold(true).
|
|
Render(fmt.Sprintf("+%d", r.overtaking))
|
|
overtakenStr := lipgloss.NewStyle().
|
|
Foreground(lipgloss.Color(colorF1Red)).
|
|
Render(fmt.Sprintf("-%d", r.overtaken))
|
|
|
|
sb.WriteString(fmt.Sprintf(" %s %s %s %s\n",
|
|
colorBar,
|
|
padRight(acronym, 4),
|
|
overtakingStr,
|
|
overtakenStr,
|
|
))
|
|
}
|
|
|
|
return sb.String()
|
|
}
|