path: root/internal/casino/table_ux.go

package casino

import (
	"fmt"
	"strings"
)

// RulesText is the shared rules view for table commands and room fixtures.
func (c TableConfig) RulesText() string {
	switch c.Game {
	case GameBlackjack:
		return c.BlackjackRulesText()
	case GameBaccarat:
		return c.BaccaratRulesText()
	case GameCraps:
		return c.CrapsRulesText()
	case GameRoulette:
		rules := c.Label() + "\nStraight numbers pay 35:1; splits 17:1; streets and trios 11:1; corners 8:1; lines 5:1.\n" +
			"1to12/13to24/25to36 and rows 2:1; other outside bets 1:1; the American basket pays 6:1.\n" +
			"Combos: bet 10 on split 1 2 | bet 10 on street 1 2 3 | bet 10 on corner 1 2 4 5 |\n" +
			"bet 10 on line 1 2 3 4 5 6 | bet 10 on trio 0 1 2 | bet 10 on basket.\n"
		if c.Roulette.Racetrack {
			rules += "Racetrack (single zero): bet 10 on voisins | tiers | orphelins | jeu zero | neighbors 17.\n"
		}
		return rules + "Zero pockets lose all outside bets. One wager per spin. Use help roulette."
	default:
		return c.Label()
	}
}

func (c TableConfig) Label() string {
	if c.Game == GameRoulette {
		label := "Roulette / Single zero"
		if c.Roulette.DoubleZero {
			label = "Roulette / Double zero"
		}
		if c.Roulette.Racetrack {
			label += " / Racetrack"
		}
		return label
	}
	if c.Game != GameBaccarat {
		return gameTitle(c.Game)
	}
	switch c.Baccarat.Normalize().Variant {
	case BaccaratSuper6:
		return "Baccarat / Super 6"
	case BaccaratEZ:
		return "Baccarat / EZ"
	default:
		return "Baccarat / Commission"
	}
}

func (c *tableCore[P]) overview() string {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.overviewLocked()
}

func (c *tableCore[P]) overviewLocked() string {
	// Concise enough to sit beside a look minimap without wrapping into it.
	// The betting countdown lives in the menu heading and warning lines.
	return fmt.Sprintf("%s | Limits %s | %d/%d seated", c.Config.Label(), compactBetRange(c.Config.MinBet, c.Config.MaxBet), c.players.count(), c.Config.MaxPlayers)
}

// compactBetRange renders the wager range in the short form used by the
// one-line table overview (the verbose form stays in the betting menu).
func compactBetRange(minBet, maxBet int) string {
	if maxBet == maxBetUnlimited {
		return fmt.Sprintf("%d+", minBet)
	}
	return fmt.Sprintf("%d-%d", minBet, maxBet)
}

func (c *tableCore[P]) warning(name, text string) Event {
	e := c.private(name, text)
	e.Color = "casino_warning"
	return e
}

// committedMenu never advertises another bet over an already committed wager.
func (c *tableCore[P]) committedMenu(name string) Event {
	e := c.private(name, "Your wager is committed; waiting for the round.")
	e.Color = "casino_menu"
	e.Menu = &MenuView{Heading: e.Message, Commands: []MenuCommand{
		{Command: "table", Desc: "View the table"},
		{Command: "sitout", Desc: "Sit out after this round"},
		{Command: "stop", Desc: "Leave after this round"},
	}}
	return e
}

// controlLocked queues departures without changing committed hands or stakes.
func (c *tableCore[P]) controlLocked(name, action string) ([]Event, bool) {
	if action != "leave_after" && action != "sitout" {
		return nil, false
	}
	for _, p := range c.players.participants() {
		if p.Name != name {
			continue
		}
		if action == "leave_after" {
			p.LeaveAfter = true
			return []Event{c.private(name, "You’ll leave after this round. Your current hand still needs your actions.")}, true
		}
		if p.HasBet {
			p.SitOutAfter = true
			return []Event{c.private(name, "You’ll sit out after this round. Your current wager and actions are unchanged.")}, true
		}
		p.SittingOut = true
		return []Event{c.private(name, "You’re sitting out. Place a bet to rejoin; stop to leave.")}, true
	}
	return []Event{c.private(name, "You aren’t seated at this table.")}, true
}

// Called only after resetRound, when seat removal cannot disturb active indices.
func (c *tableCore[P]) finishControlsLocked() []Event {
	var events []Event
	for _, p := range c.players.participants() {
		if p.LeaveAfter {
			c.removeSeatLocked(p.Name)
			events = append(events, c.playerAction(p.Name, p.Name+" stands up.", "Round complete. You stand up."))
		} else if p.SitOutAfter {
			p.SitOutAfter = false
			p.SittingOut = true
			events = append(events, c.private(p.Name, "You’re now sitting out. Place a bet to rejoin."))
		}
	}
	return c.closeIfEmptyLocked(events)
}

func (c *tableCore[P]) seatStatusLocked(name string) string {
	for _, p := range c.players.participants() {
		if p.Name != name {
			continue
		}
		if p.LeaveAfter {
			return "Leaving after this round"
		}
		if p.SitOutAfter {
			return "Sitting out after this round"
		}
		if p.SittingOut {
			return "Sitting out | Bet to rejoin"
		}
		if p.HasBet {
			return fmt.Sprintf("Wager committed: %d", p.Wager.Total)
		}
	}
	var waiting []string
	for _, p := range c.players.participants() {
		if p.Connected && !p.SittingOut && !p.HasBet {
			waiting = append(waiting, p.Name)
		}
	}
	if len(waiting) > 0 {
		return "Waiting for bets: " + strings.Join(waiting, ", ")
	}
	return ""
}

func (t *blackjackTable) status(name string) []Event {
	t.mu.Lock()
	defer t.mu.Unlock()
	e := t.private(name, t.overviewLocked())
	if text := t.seatStatusLocked(name); text != "" {
		e.Message += "\n" + text
	}
	events := []Event{e}
	switch t.phase {
	case blackjackPlaying:
		events[0].Snapshot = t.snapshot(false)
		if t.activeName() == name {
			events = append(events, t.turnMenuLocked(name))
		} else {
			events[0].Message += "\n" + t.activeName() + "’s turn | You are waiting"
		}
	case blackjackInsurance:
		events[0].Snapshot = t.snapshot(false)
		if p := t.players.get(name); p != nil && p.HasBet && !p.declinedInsurance && p.insurance == 0 {
			events = append(events, t.insuranceMenuLocked(p))
		}
	default:
		if p := t.players.get(name); p != nil && !p.HasBet {
			events = append(events, t.menuEvent(name))
		}
	}
	return events
}

func (t *baccaratTable) status(name string) []Event {
	t.mu.Lock()
	defer t.mu.Unlock()
	e := t.private(name, t.overviewLocked())
	if text := t.seatStatusLocked(name); text != "" {
		e.Message += "\n" + text
	}
	events := []Event{e}
	if p := t.players.get(name); p != nil && !p.HasBet {
		events = append(events, t.menuEvent(name))
	}
	return events
}

func (t *blackjackTable) insuranceMenuLocked(p *blackjackPlayer) Event {
	cost := p.hands[0].bet / 2
	e := t.private(p.Name, "Insurance decision")
	e.Color = "casino_menu"
	e.Menu = &MenuView{Heading: fmt.Sprintf("Insurance | Costs %d | Pays %g:1 | %d ticks remaining", cost, t.Rules.InsurancePayout, t.timer.remaining()), Commands: []MenuCommand{{Command: "insurance", Desc: "Buy insurance", Cost: cost}, {Command: "decline", Desc: "Continue without insurance (also the timeout default)"}}}
	if cost == 0 {
		e.Menu.Commands = e.Menu.Commands[1:]
		e.Menu.Heading = "Bet too small to insure | decline to continue"
	}
	return e
}

// settlementLine is one settled bet within a round. Label names the bet for
// the itemized line (empty for a lone anonymous hand); Result is the engine's
// settlement word ("win", "loss", "bust", "push", "blackjack",
// "surrender", "insurance").
type settlementLine struct {
	Label    string
	Result   string
	Stake    int
	Returned int
	Tag      string // optional color-category override (jackpot, for example)
}

func (l settlementLine) net() int { return l.Returned - l.Stake }

// resultTextLabel renders a settled wager as a colored outcome plus its net,
// naming the bet on its own line.
func resultTextLabel(label, result string, stake, returned int) string {
	return settlementText([]settlementLine{{Label: label, Result: result, Stake: stake, Returned: returned}})
}

// settlementText renders a settlement as a colored headline followed by one
// line per named bet. The net is the only figure shown: the old
// "Net ... | ... returned (stake included)" split is gone. Wins are green,
// losses red and pushes white, with the headline taking the round's overall
// result and each line its own.
func settlementText(lines []settlementLine) string {
	net := 0
	for _, line := range lines {
		net += line.net()
	}
	var sb strings.Builder
	fmt.Fprintf(&sb, "{%s}%s{/} {casino_payout}%s{/}", settlementTag(lines), settlementLabel(lines), creditsText(net))
	for _, line := range lines {
		if line.Label == "" {
			continue
		}
		fmt.Fprintf(&sb, "\n  {casino_action}%s:{/} {%s}%s{/}", line.Label, lineTag(line), creditsText(line.net()))
	}
	return sb.String()
}

// creditsText formats a signed credit total with the right plural.
func creditsText(n int) string {
	word := "credits"
	if n == 1 || n == -1 {
		word = "credit"
	}
	return fmt.Sprintf("%+d %s", n, word)
}

// settlementLabel returns the headline word for a round.
func settlementLabel(lines []settlementLine) string {
	if len(lines) == 1 {
		switch lines[0].Result {
		case "blackjack":
			return "BLACKJACK"
		case "surrender":
			return "SURRENDER"
		}
	}
	switch {
	case settlementNet(lines) > 0:
		return "WIN"
	case settlementNet(lines) < 0:
		return "LOSS"
	default:
		return "PUSH"
	}
}

// settlementTag returns the headline's color tag. A lone natural keeps the
// jackpot gradient; otherwise the net decides green, red or white.
func settlementTag(lines []settlementLine) string {
	if len(lines) == 1 && lines[0].Tag != "" {
		return lines[0].Tag
	}
	if len(lines) == 1 && lines[0].Result == "blackjack" {
		return "casino_jackpot_win"
	}
	switch {
	case settlementNet(lines) > 0:
		return "casino_result_win"
	case settlementNet(lines) < 0:
		return "casino_result_loss"
	default:
		return "casino_result_push"
	}
}

// lineTag colors one bet's outcome. Insurance is judged by its net because the
// same result word covers a paid and a lost premium.
func lineTag(line settlementLine) string {
	if line.Tag != "" {
		return line.Tag
	}
	switch line.Result {
	case "blackjack":
		return "casino_jackpot_win"
	case "push":
		return "casino_result_push"
	case "win":
		return "casino_result_win"
	case "insurance":
		switch {
		case line.net() > 0:
			return "casino_result_win"
		case line.net() < 0:
			return "casino_result_loss"
		default:
			return "casino_result_push"
		}
	default:
		return "casino_result_loss"
	}
}

func settlementNet(lines []settlementLine) int {
	net := 0
	for _, line := range lines {
		net += line.net()
	}
	return net
}