cricinfo-cli-go 0.1.2 → 0.1.4

package/internal/cricinfo/renderer.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 )
 
@@ -201,6 +202,15 @@ func renderText(w io.Writer, result NormalizedResult, opts RenderOptions) error
 			lines = append(lines, formatInningsTimelines(itemMap)...)
 			return writeTextLines(w, lines)
 		}
+		if result.Kind == EntityMatchSituation {
+			itemMap, err := toMap(result.Data, opts.AllFields)
+			if err != nil {
+				return err
+			}
+			lines = append(lines, "Match Situation")
+			lines = append(lines, formatMatchSituation(itemMap)...)
+			return writeTextLines(w, lines)
+		}
 		if result.Kind == EntityPlayerStats {
 			itemMap, err := toMap(result.Data, opts.AllFields)
 			if err != nil {
@@ -264,6 +274,15 @@ func renderText(w io.Writer, result NormalizedResult, opts RenderOptions) error
 			lines = append(lines, formatMatchPhases(itemMap)...)
 			return writeTextLines(w, lines)
 		}
+		if result.Kind == EntityMatchDuel {
+			itemMap, err := toMap(result.Data, opts.AllFields)
+			if err != nil {
+				return err
+			}
+			lines = append(lines, "Match Duel")
+			lines = append(lines, formatMatchDuel(itemMap)...)
+			return writeTextLines(w, lines)
+		}
 
 		itemMap, err := toMap(result.Data, opts.AllFields)
 		if err != nil {
@@ -283,8 +302,35 @@ func renderText(w io.Writer, result NormalizedResult, opts RenderOptions) error
 		return writeTextLines(w, lines)
 	}
 
+	if result.Kind == EntityTeamStatistics || result.Kind == EntityTeamRecords {
+		title := "Team Statistics"
+		if result.Kind == EntityTeamRecords {
+			title = "Team Records"
+		}
+		lines = append(lines, fmt.Sprintf("%s Categories (%d)", title, len(result.Items)))
+		lines = append(lines, formatStatCategoryList(result.Items)...)
+		return writeTextLines(w, lines)
+	}
+
+	if result.Kind == EntityStandingsGroup {
+		lines = append(lines, formatStandingsGroupList(result.Items)...)
+		return writeTextLines(w, lines)
+	}
+
 	if result.Kind == EntityDeliveryEvent || result.Kind == EntityPlayerDelivery {
 		lines = append(lines, fmt.Sprintf("%s (%d)", titleize(kindPlural(result.Kind)), len(result.Items)))
+		if result.Kind == EntityDeliveryEvent {
+			source := ""
+			switch {
+			case strings.Contains(result.RequestedRef, "/details"):
+				source = "details"
+			case strings.Contains(result.RequestedRef, "/plays"):
+				source = "plays"
+			}
+			if source != "" {
+				lines = append(lines, "Source: "+source)
+			}
+		}
 		for i, item := range result.Items {
 			summary := summarizeDeliveryListItem(item, result.Kind)
 			if strings.TrimSpace(summary) == "" {
@@ -339,19 +385,26 @@ func summarizeDeliveryListItem(item any, kind EntityKind) string {
 		if short == "" {
 			short = joinParts("over "+intString(typed.OverNumber), "ball "+intString(typed.BallNumber))
 		}
+		lead := firstNonEmpty(overBallString(typed.OverNumber, typed.BallNumber), "")
+		score := firstNonEmpty(scoreLabel(typed.HomeScore), scoreLabel(typed.AwayScore))
 		if kind == EntityPlayerDelivery {
-			return joinParts(short, strings.Join(typed.Involvement, ","), overBallString(typed.OverNumber, typed.BallNumber))
+			return joinParts(lead, short, score, strings.Join(typed.Involvement, ","))
 		}
-		return short
+		return joinParts(lead, short, score)
 	case map[string]any:
 		short := firstNonEmpty(valueString(typed, "shortText"), valueString(typed, "text"))
 		if short == "" {
 			short = joinParts("over "+valueString(typed, "overNumber"), "ball "+valueString(typed, "ballNumber"))
 		}
+		if strings.TrimSpace(short) == "/" || strings.TrimSpace(short) == "-" {
+			return ""
+		}
+		lead := overBallLabel(typed)
+		score := firstNonEmpty(scoreLabel(valueString(typed, "homeScore")), scoreLabel(valueString(typed, "awayScore")))
 		if kind == EntityPlayerDelivery {
-			return joinParts(short, involvementLabel(typed), overBallLabel(typed))
+			return joinParts(lead, short, score, involvementLabel(typed))
 		}
-		return short
+		return joinParts(lead, short, score)
 	default:
 		return ""
 	}
@@ -361,7 +414,7 @@ func overBallString(over, ball int) string {
 	if over <= 0 || ball <= 0 {
 		return ""
 	}
-	return fmt.Sprintf("over %d.%d", over, ball)
+	return fmt.Sprintf("%d.%d", over, ball)
 }
 
 func intString(value int) string {
@@ -379,6 +432,17 @@ func defaultNumeric(raw string) string {
 	return raw
 }
 
+func scoreLabel(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+	if strings.Contains(raw, "/") {
+		return raw
+	}
+	return ""
+}
+
 func sanitizeValue(value any, allFields bool) (any, error) {
 	blob, err := json.Marshal(value)
 	if err != nil {
@@ -423,6 +487,25 @@ func toMap(value any, allFields bool) (map[string]any, error) {
 	return mapped, nil
 }
 
+func mapFromAny(value any) map[string]any {
+	if value == nil {
+		return nil
+	}
+	if mapped, ok := value.(map[string]any); ok {
+		return mapped
+	}
+
+	blob, err := json.Marshal(value)
+	if err != nil {
+		return nil
+	}
+	var mapped map[string]any
+	if err := json.Unmarshal(blob, &mapped); err != nil {
+		return nil
+	}
+	return mapped
+}
+
 func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) string {
 	switch kind {
 	case EntityMatch:
@@ -464,6 +547,15 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 			return joinParts("situation", data)
 		}
 		return joinParts("situation", valueString(entity, "competitionId"))
+	case EntityMatchDuel:
+		duelLabel := strings.TrimSpace(fmt.Sprintf("%s vs %s",
+			firstNonEmpty(valueString(entity, "batterName"), valueString(entity, "batterId")),
+			firstNonEmpty(valueString(entity, "bowlerName"), valueString(entity, "bowlerId")),
+		))
+		return joinParts(
+			duelLabel,
+			fmt.Sprintf("%s off %s", valueString(entity, "runs"), valueString(entity, "balls")),
+		)
 	case EntityMatchPhases:
 		return joinParts(
 			"match "+firstNonEmpty(valueString(entity, "matchId"), valueString(entity, "competitionId")),
@@ -520,7 +612,15 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 		name := firstNonEmpty(valueString(entity, "name"), valueString(entity, "shortName"), valueString(entity, "id"))
 		return joinParts(name, bracket(valueString(entity, "homeAway")))
 	case EntityTeamRoster:
-		name := firstNonEmpty(valueString(entity, "displayName"), valueString(entity, "playerId"), valueString(entity, "athleteId"))
+		name := strings.TrimSpace(valueString(entity, "displayName"))
+		if name == "" {
+			playerID := firstNonEmpty(valueString(entity, "playerId"), valueString(entity, "athleteId"))
+			if playerID != "" {
+				name = "Unknown player (" + playerID + ")"
+			} else {
+				name = "Unknown player"
+			}
+		}
 		badges := []string{}
 		if valueString(entity, "captain") == "true" {
 			badges = append(badges, "captain")
@@ -528,7 +628,7 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 		if valueString(entity, "active") == "true" {
 			badges = append(badges, "active")
 		}
-		return joinParts(name, strings.Join(badges, ", "))
+		return joinParts(name, firstNonEmpty(valueString(entity, "teamName"), valueString(entity, "teamId")), strings.Join(badges, ", "))
 	case EntityTeamScore:
 		return joinParts(valueString(entity, "displayValue"), valueString(entity, "value"), bracket(valueString(entity, "source")))
 	case EntityTeamLeaders:
@@ -915,7 +1015,7 @@ func formatPlayerProfile(entity map[string]any) []string {
 }
 
 func formatPlayerMatchView(entity map[string]any) []string {
-	lines := make([]string, 0, 16)
+	lines := make([]string, 0, 48)
 	if player := valueString(entity, "playerName"); player != "" {
 		lines = append(lines, "Player: "+player)
 	}
@@ -931,13 +1031,21 @@ func formatPlayerMatchView(entity map[string]any) []string {
 		}
 	}
 	if batting := sliceValue(entity, "batting"); len(batting) > 0 {
-		lines = append(lines, fmt.Sprintf("Batting Categories: %d", len(batting)))
+		lines = append(lines, "Batting")
+		lines = append(lines, formatStatCategoryList(batting)...)
 	}
 	if bowling := sliceValue(entity, "bowling"); len(bowling) > 0 {
-		lines = append(lines, fmt.Sprintf("Bowling Categories: %d", len(bowling)))
+		lines = append(lines, "Bowling")
+		lines = append(lines, formatStatCategoryList(bowling)...)
 	}
 	if fielding := sliceValue(entity, "fielding"); len(fielding) > 0 {
-		lines = append(lines, fmt.Sprintf("Fielding Categories: %d", len(fielding)))
+		lines = append(lines, "Fielding")
+		lines = append(lines, formatStatCategoryList(fielding)...)
+	}
+	if len(sliceValue(entity, "batting")) == 0 &&
+		len(sliceValue(entity, "bowling")) == 0 &&
+		len(sliceValue(entity, "fielding")) == 0 {
+		lines = append(lines, "No match statistics categories available.")
 	}
 	return lines
 }
@@ -992,6 +1100,164 @@ func formatMatchView(entity map[string]any) []string {
 	return lines
 }
 
+func formatMatchSituation(entity map[string]any) []string {
+	lines := make([]string, 0, 64)
+	if matchID := firstNonEmpty(valueString(entity, "matchId"), valueString(entity, "competitionId")); matchID != "" {
+		lines = append(lines, "Match: "+matchID)
+	}
+
+	live, _ := entity["live"].(map[string]any)
+	if live == nil {
+		if oddsRef := valueString(entity, "oddsRef"); oddsRef != "" {
+			lines = append(lines, "Odds Ref: "+oddsRef)
+		}
+		if data, ok := entity["data"].(map[string]any); ok && len(data) > 0 {
+			lines = append(lines, "Data: "+printableValue(data))
+		}
+		if len(lines) <= 1 {
+			lines = append(lines, "No situation data available for this match.")
+		}
+		return lines
+	}
+
+	if fixture := valueString(live, "fixture"); fixture != "" {
+		lines = append(lines, "Fixture: "+fixture)
+	}
+	if status := valueString(live, "status"); status != "" {
+		lines = append(lines, "Status: "+status)
+	}
+	scoreLine := joinParts(valueString(live, "score"), valueString(live, "overs"))
+	if scoreLine != "" {
+		lines = append(lines, "Score: "+scoreLine)
+	}
+	teamsLine := joinParts(
+		"Batting "+valueString(live, "battingTeam"),
+		"Bowling "+valueString(live, "bowlingTeam"),
+	)
+	if teamsLine != "" {
+		lines = append(lines, teamsLine)
+	}
+	if snapshotAt := valueString(live, "snapshotAt"); snapshotAt != "" {
+		lines = append(lines, "Snapshot: "+snapshotAt)
+	}
+	if stale := valueString(live, "stale"); stale == "true" {
+		lines = append(lines, "Stale: true")
+		if reason := valueString(live, "staleReason"); reason != "" {
+			lines = append(lines, "Stale Reason: "+reason)
+		}
+	}
+
+	batters := sliceValue(live, "batters")
+	if len(batters) > 0 {
+		lines = append(lines, "Batters")
+		for i, raw := range batters {
+			batter, ok := raw.(map[string]any)
+			if !ok {
+				continue
+			}
+			score := fmt.Sprintf("%s(%s)", defaultNumeric(valueString(batter, "runs")), defaultNumeric(valueString(batter, "balls")))
+			boundaries := joinParts("4s "+defaultNumeric(valueString(batter, "fours")), "6s "+defaultNumeric(valueString(batter, "sixes")))
+			row := joinParts(
+				firstNonEmpty(valueString(batter, "playerName"), valueString(batter, "playerId")),
+				score,
+				"SR "+defaultNumeric(valueString(batter, "strikeRate")),
+				boundaries,
+			)
+			if strings.EqualFold(valueString(batter, "onStrike"), "true") {
+				row = joinParts(row, "*")
+			}
+			lines = append(lines, fmt.Sprintf("  %d. %s", i+1, row))
+		}
+	}
+
+	bowlers := sliceValue(live, "bowlers")
+	if len(bowlers) > 0 {
+		lines = append(lines, "Bowlers")
+		for i, raw := range bowlers {
+			bowler, ok := raw.(map[string]any)
+			if !ok {
+				continue
+			}
+			figures := fmt.Sprintf("%s-%s-%s-%s",
+				oversLabelFromFields(valueString(bowler, "overs"), valueString(bowler, "balls")),
+				defaultNumeric(valueString(bowler, "maidens")),
+				defaultNumeric(valueString(bowler, "conceded")),
+				defaultNumeric(valueString(bowler, "wickets")),
+			)
+			row := joinParts(
+				firstNonEmpty(valueString(bowler, "playerName"), valueString(bowler, "playerId")),
+				figures,
+				"Econ "+defaultNumeric(valueString(bowler, "economy")),
+			)
+			lines = append(lines, fmt.Sprintf("  %d. %s", i+1, row))
+		}
+	}
+
+	balls := sliceValue(live, "recentBalls")
+	if len(balls) == 0 {
+		balls = sliceValue(live, "currentOverBalls")
+	}
+	if len(balls) > 0 {
+		lines = append(lines, "Recent Balls")
+		for i, raw := range balls {
+			lines = append(lines, fmt.Sprintf("  %d. %s", i+1, summarizeDeliveryListItem(raw, EntityDeliveryEvent)))
+		}
+	}
+	return lines
+}
+
+func formatMatchDuel(entity map[string]any) []string {
+	lines := make([]string, 0, 48)
+	if matchID := valueString(entity, "matchId"); matchID != "" {
+		lines = append(lines, "Match: "+matchID)
+	}
+	if fixture := valueString(entity, "fixture"); fixture != "" {
+		lines = append(lines, "Fixture: "+fixture)
+	}
+	if score := valueString(entity, "score"); score != "" {
+		lines = append(lines, "Score: "+score)
+	}
+	lines = append(lines, "Duel: "+firstNonEmpty(valueString(entity, "batterName"), valueString(entity, "batterId"))+" vs "+firstNonEmpty(valueString(entity, "bowlerName"), valueString(entity, "bowlerId")))
+	summary := joinParts(
+		fmt.Sprintf("%s off %s", defaultNumeric(valueString(entity, "runs")), defaultNumeric(valueString(entity, "balls"))),
+		"SR "+defaultNumeric(valueString(entity, "strikeRate")),
+		"dots "+defaultNumeric(valueString(entity, "dots")),
+		"4s "+defaultNumeric(valueString(entity, "fours")),
+		"6s "+defaultNumeric(valueString(entity, "sixes")),
+		"wkts "+defaultNumeric(valueString(entity, "wickets")),
+	)
+	if strings.TrimSpace(summary) != "" {
+		lines = append(lines, "Summary: "+summary)
+	}
+	if snapshot := valueString(entity, "snapshotAt"); snapshot != "" {
+		lines = append(lines, "Snapshot: "+snapshot)
+	}
+	balls := sliceValue(entity, "recentBalls")
+	if len(balls) > 0 {
+		lines = append(lines, "Recent Duel Balls")
+		for i, raw := range balls {
+			lines = append(lines, fmt.Sprintf("  %d. %s", i+1, summarizeDeliveryListItem(raw, EntityDeliveryEvent)))
+		}
+	}
+	return lines
+}
+
+func oversLabelFromFields(overs string, balls string) string {
+	overs = strings.TrimSpace(overs)
+	if overs != "" && overs != "0" {
+		return overs
+	}
+	balls = strings.TrimSpace(balls)
+	if balls == "" || balls == "0" {
+		return "0.0"
+	}
+	b, err := strconv.Atoi(balls)
+	if err != nil || b < 0 {
+		return "0.0"
+	}
+	return fmt.Sprintf("%d.%d", b/6, b%6)
+}
+
 func formatMatchPhases(entity map[string]any) []string {
 	lines := make([]string, 0, 64)
 	if matchID := firstNonEmpty(valueString(entity, "matchId"), valueString(entity, "competitionId")); matchID != "" {
@@ -1266,6 +1532,149 @@ func formatTeamLeaders(entity map[string]any) []string {
 	return lines
 }
 
+func formatStatCategoryList(items []any) []string {
+	lines := make([]string, 0, len(items)*4)
+	for i, rawCategory := range items {
+		category := mapFromAny(rawCategory)
+		if category == nil {
+			continue
+		}
+
+		categoryName := firstNonEmpty(valueString(category, "displayName"), valueString(category, "name"), "Category")
+		lines = append(lines, fmt.Sprintf("  %d. %s", i+1, categoryName))
+
+		stats := sliceValue(category, "stats")
+		if len(stats) == 0 {
+			continue
+		}
+
+		limit := len(stats)
+		if limit > 16 {
+			limit = 16
+		}
+		for j := 0; j < limit; j++ {
+			statMap, ok := stats[j].(map[string]any)
+			if !ok {
+				continue
+			}
+			label := firstNonEmpty(valueString(statMap, "displayName"), valueString(statMap, "name"), valueString(statMap, "abbreviation"))
+			value := firstNonEmpty(valueString(statMap, "displayValue"), valueString(statMap, "value"))
+			row := joinParts(label, value, bracket(valueString(statMap, "abbreviation")))
+			if row == "" {
+				continue
+			}
+			lines = append(lines, fmt.Sprintf("     - %s", row))
+		}
+		if len(stats) > limit {
+			lines = append(lines, fmt.Sprintf("     - ... %d more", len(stats)-limit))
+		}
+	}
+	return lines
+}
+
+func formatStandingsGroupList(items []any) []string {
+	lines := make([]string, 0, len(items)*8+1)
+	lines = append(lines, fmt.Sprintf("Standings Groups (%d)", len(items)))
+
+	for i, rawGroup := range items {
+		group := mapFromAny(rawGroup)
+		if group == nil {
+			continue
+		}
+
+		groupID := firstNonEmpty(valueString(group, "groupId"), valueString(group, "id"), fmt.Sprintf("%d", i+1))
+		seasonID := valueString(group, "seasonId")
+		header := "Group " + groupID
+		if seasonID != "" {
+			header = joinParts(header, "Season "+seasonID)
+		}
+		lines = append(lines, header)
+
+		entries := sliceValue(group, "entries")
+		if len(entries) == 0 {
+			lines = append(lines, "  No standings entries available.")
+			continue
+		}
+
+		for entryIndex, rawEntry := range entries {
+			team := mapFromAny(rawEntry)
+			if team == nil {
+				continue
+			}
+
+			rank := standingsStatValueFromTeam(team, "rank", "position")
+			if rank == "" {
+				rank = fmt.Sprintf("%d", entryIndex+1)
+			}
+			teamName := firstNonEmpty(valueString(team, "shortName"), valueString(team, "name"), valueString(team, "id"))
+			played := standingsStatValueFromTeam(team, "matchesplayed", "played", "matches")
+			won := standingsStatValueFromTeam(team, "wins", "won")
+			lost := standingsStatValueFromTeam(team, "losses", "lost")
+			points := standingsStatValueFromTeam(team, "matchpoints", "points", "pts")
+			nrr := standingsStatValueFromTeam(team, "netrunrate", "nrr", "runrate")
+
+			row := joinParts(
+				fmt.Sprintf("#%s %s", rank, teamName),
+				nonEmptyLabel("P", played),
+				nonEmptyLabel("W", won),
+				nonEmptyLabel("L", lost),
+				nonEmptyLabel("Pts", points),
+				nonEmptyLabel("NRR", nrr),
+			)
+			if strings.TrimSpace(row) == "" {
+				row = joinParts(fmt.Sprintf("#%s %s", rank, teamName), valueString(team, "scoreSummary"))
+			}
+			lines = append(lines, "  "+row)
+		}
+	}
+	return lines
+}
+
+func standingsStatValueFromTeam(team map[string]any, names ...string) string {
+	if len(names) == 0 || team == nil {
+		return ""
+	}
+
+	targets := map[string]struct{}{}
+	for _, name := range names {
+		key := normalizeStatName(name)
+		if key != "" {
+			targets[key] = struct{}{}
+		}
+	}
+
+	extensions, ok := team["extensions"].(map[string]any)
+	if !ok || extensions == nil {
+		return ""
+	}
+	records, ok := extensions["records"].([]any)
+	if !ok || len(records) == 0 {
+		return ""
+	}
+
+	for _, rawRecord := range records {
+		record := mapFromAny(rawRecord)
+		if record == nil {
+			continue
+		}
+		for _, rawStat := range sliceValue(record, "stats") {
+			stat := mapFromAny(rawStat)
+			if stat == nil {
+				continue
+			}
+			nameKey := normalizeStatName(firstNonEmpty(valueString(stat, "name"), valueString(stat, "type")))
+			if _, ok := targets[nameKey]; !ok {
+				continue
+			}
+			value := firstNonEmpty(valueString(stat, "displayValue"), valueString(stat, "value"))
+			if value != "" {
+				return value
+			}
+		}
+	}
+	return ""
+}
+
 func formatAnalysisView(entity map[string]any) []string {
 	lines := make([]string, 0, 64)
 	if command := valueString(entity, "command"); command != "" {
@@ -1535,9 +1944,9 @@ func overBallLabel(entity map[string]any) string {
 		return ""
 	}
 	if ball == "" {
-		return "over " + over
+		return over
 	}
-	return "over " + over + "." + ball
+	return over + "." + ball
 }
 
 func involvementLabel(entity map[string]any) string {