package ui

import (
	"fmt"
	"strings"
	"time"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"

	"skyrama-tui/internal/model"
	"skyrama-tui/internal/service"
	"skyrama-tui/internal/style"
)

// ─── Messages ─────────────────────────────────────────────────────────────────

type FleetLoadedMsg struct {
	Fleet      []model.PlayerPlane
	Facilities []model.FacilityStatus
	Note       string // surfaced dispatch failure (e.g. out of fuel), if any
}
type FleetErrMsg struct{ Err error }
type FlightLaunchedMsg struct{ PlaneID uint32 }
type FlightLandedMsg struct {
	Count      int
	CashEarned int64
}
type ServiceProgressMsg struct{}
type PlaneSoldMsg struct{ Refund int64 }
type DestinationsLoadedMsg struct{ Dest []model.CentralAirport }
type DispatchResultMsg struct{ Queued int }
type DispatchCancelledMsg struct{ Count int }

// ─── Columns ──────────────────────────────────────────────────────────────────

// fleetColumns are the status lanes shown side-by-side, in lifecycle order.
var fleetColumns = []struct{ status, title string }{
	{"idle", "Waiting"},
	{"boarding", "Boarding"},
	{"taxiing", "Refueling"},
	{"flying", "In-flight"},
	{"unloading", "Unloading"},
}

// colEntry is one plane-template's planes within a single status column.
// Identical templates (same plane_id) are interchangeable, so they collapse to
// one row with a count.
type colEntry struct {
	planeID    uint32
	name       string
	aircraft   string
	size       string
	opType     string
	fuelCost   uint32
	maxPax     int32
	cash       int32
	buyingCost uint32
	members    []model.PlayerPlane // members in THIS status only
}

// ─── FleetModel ───────────────────────────────────────────────────────────────

type FleetModel struct {
	client     *service.GameService
	airportID  uint32
	fleet      []model.PlayerPlane
	facilities []model.FacilityStatus
	cols       [][]colEntry
	queued     []colEntry // RAM-queued dispatches (status "queued"), shown in Waiting
	activeCol  int
	sel        []int // cursor index per column

	// attribute filters ("" = all)
	filterSize string
	filterType string
	filterOp   string

	// dispatch sub-mode
	dispatchMode  bool
	dispatchEntry colEntry
	destinations  []model.CentralAirport
	destIdx       int
	dispatchCount int

	statusMsg string
	sellArmed bool
	focused   bool
	width     int
	height    int
}

func NewFleetModel(client *service.GameService, airportID uint32) FleetModel {
	return FleetModel{
		client:    client,
		airportID: airportID,
		sel:       make([]int, len(fleetColumns)),
	}
}

func (m FleetModel) Init() tea.Cmd {
	return tea.Batch(m.loadFleet(), m.loadDestinations())
}

func (m FleetModel) Update(msg tea.Msg) (FleetModel, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		m.width = msg.Width
		m.height = msg.Height

	case FleetLoadedMsg:
		m.fleet = msg.Fleet
		m.facilities = msg.Facilities
		m.cols = m.buildColumns()
		m.queued = m.buildQueued()
		m.clampSel()
		if msg.Note != "" {
			m.statusMsg = style.Warning.String() + msg.Note
		}

	case DestinationsLoadedMsg:
		m.destinations = msg.Dest

	case ServiceProgressMsg:
		return m, m.loadFleet()

	case FlightLaunchedMsg:
		m.statusMsg = style.Success.String() + fmt.Sprintf("Plane #%d launched!", msg.PlaneID)
		return m, m.loadFleet()

	case FlightLandedMsg:
		m.statusMsg = style.Success.String() +
			fmt.Sprintf("%d plane(s) landed! +$%d", msg.Count, msg.CashEarned)
		return m, m.loadFleet()

	case PlaneSoldMsg:
		m.statusMsg = style.Success.String() + fmt.Sprintf("Sold plane for $%d", msg.Refund)
		return m, m.loadFleet()

	case DispatchResultMsg:
		m.statusMsg = style.Success.String() +
			fmt.Sprintf("Queued %d plane(s) for dispatch", msg.Queued)
		return m, m.loadFleet()

	case DispatchCancelledMsg:
		m.statusMsg = style.Success.String() +
			fmt.Sprintf("Cancelled %d queued dispatch(es)", msg.Count)
		return m, m.loadFleet()

	case FleetErrMsg:
		m.statusMsg = style.Error.String() + msg.Err.Error()

	case tea.KeyMsg:
		if !m.focused {
			break
		}
		return m.handleKey(msg)
	}

	return m, nil
}

// handleKey routes a keypress depending on the current sub-mode.
func (m FleetModel) handleKey(msg tea.KeyMsg) (FleetModel, tea.Cmd) {
	// Dispatch modal has its own bindings.
	if m.dispatchMode {
		return m.handleDispatchKey(msg)
	}

	// A sell confirmation is pending: y confirms, anything else cancels.
	if m.sellArmed {
		m.sellArmed = false
		if msg.String() == "y" || msg.String() == "Y" {
			if e := m.currentEntry(); e != nil && len(e.members) > 0 {
				return m, m.sellPlane(&e.members[0])
			}
			m.statusMsg = style.Muted.Render("Nothing to sell.")
			return m, nil
		}
		m.statusMsg = style.Muted.Render("Sale cancelled.")
		return m, nil
	}

	switch msg.String() {
	case "r", "R":
		m.statusMsg = ""
		return m, m.loadFleet()
	case "left", "h":
		if m.activeCol > 0 {
			m.activeCol--
		}
	case "right", "l":
		if m.activeCol < len(fleetColumns)-1 {
			m.activeCol++
		}
	case "up", "k":
		if m.sel[m.activeCol] > 0 {
			m.sel[m.activeCol]--
		}
	case "down", "j":
		if m.sel[m.activeCol] < len(m.cols[m.activeCol])-1 {
			m.sel[m.activeCol]++
		}
	case "z":
		m.filterSize = cycle(m.filterSize, "small", "medium", "large", "huge")
		m.cols = m.buildColumns()
		m.clampSel()
	case "t":
		m.filterType = cycle(m.filterType, "plane", "helicopter", "seaplane", "spaceship")
		m.cols = m.buildColumns()
		m.clampSel()
	case "o":
		m.filterOp = cycle(m.filterOp, "passenger", "cargo")
		m.cols = m.buildColumns()
		m.clampSel()
	case "s", "S":
		// Sell only makes sense on a Waiting (idle) plane.
		if fleetColumns[m.activeCol].status != "idle" {
			m.statusMsg = style.Muted.Render("Select a Waiting plane to sell.")
			return m, nil
		}
		e := m.currentEntry()
		if e == nil || len(e.members) == 0 {
			break
		}
		m.sellArmed = true
		m.statusMsg = style.Warning.String() +
			fmt.Sprintf("Sell one %s for $%d? (y/n)", e.name, resaleValue(&e.members[0]))
		return m, nil
	case "x", "X":
		if len(m.queued) == 0 {
			m.statusMsg = style.Muted.Render("Nothing queued to cancel.")
			return m, nil
		}
		return m, m.cancelQueue()
	case " ", "enter":
		return m.onSelect()
	}
	return m, nil
}

// onSelect handles enter/space on the focused column entry.
func (m FleetModel) onSelect() (FleetModel, tea.Cmd) {
	e := m.currentEntry()
	if e == nil {
		return m, nil
	}
	switch fleetColumns[m.activeCol].status {
	case "idle":
		// Open the dispatch picker for this template.
		if len(m.destinations) == 0 {
			m.statusMsg = style.Muted.Render("No destinations available yet.")
			return m, nil
		}
		m.dispatchMode = true
		m.dispatchEntry = *e
		m.destIdx = 0
		m.dispatchCount = 1
		m.statusMsg = ""
	case "flying":
		// Try to land any ready members.
		return m, m.CheckLanding()
	default:
		m.statusMsg = style.Muted.Render("These planes are in service — wait for them to free up.")
	}
	return m, nil
}

// handleDispatchKey drives the destination/count modal.
func (m FleetModel) handleDispatchKey(msg tea.KeyMsg) (FleetModel, tea.Cmd) {
	idle := len(m.dispatchEntry.members)
	switch msg.String() {
	case "esc", "q":
		m.dispatchMode = false
		m.statusMsg = style.Muted.Render("Dispatch cancelled.")
	case "up", "k":
		if m.destIdx > 0 {
			m.destIdx--
		}
	case "down", "j":
		if m.destIdx < len(m.destinations)-1 {
			m.destIdx++
		}
	case "left", "h", "-":
		if m.dispatchCount > 1 {
			m.dispatchCount--
		}
	case "right", "l", "+", "=":
		if m.dispatchCount < idle {
			m.dispatchCount++
		}
	case "enter", " ":
		dest := m.destinations[m.destIdx].AirportID
		members := m.dispatchEntry.members
		count := m.dispatchCount
		m.dispatchMode = false
		return m, m.dispatchFlights(members, dest, count)
	}
	return m, nil
}

func (m FleetModel) View() string {
	if m.dispatchMode {
		return m.dispatchView()
	}
	if len(m.fleet) == 0 {
		return style.Muted.Render("No planes in your fleet. Buy some in the Shop tab (5).")
	}

	header := style.PanelHeader.Render(fmt.Sprintf("🛩  Your Fleet  (%d planes)", len(m.fleet)))

	// Active filters + facilities (runway/service-bay free/total).
	filterLine := m.filterLine()
	facilitiesLine := m.facilitiesLine()

	status := ""
	if m.statusMsg != "" {
		status = m.statusMsg
	}

	cols := m.renderColumns()

	help := style.HelpKey.Render("←→/hl") + style.HelpDesc.Render(" column  ") +
		style.HelpKey.Render("↑↓/jk") + style.HelpDesc.Render(" select  ") +
		style.HelpKey.Render("enter") + style.HelpDesc.Render(" dispatch/land  ") +
		style.HelpKey.Render("s") + style.HelpDesc.Render(" sell  ") +
		style.HelpKey.Render("x") + style.HelpDesc.Render(" cancel queue  ") +
		style.HelpKey.Render("z/t/o") + style.HelpDesc.Render(" filter  ") +
		style.HelpKey.Render("r") + style.HelpDesc.Render(" refresh")

	return lipgloss.JoinVertical(lipgloss.Left,
		header,
		filterLine,
		facilitiesLine,
		status,
		cols,
		"",
		style.Muted.Render(help),
	)
}

// ─── Rendering ──────────────────────────────────────────────────────────────

func (m FleetModel) renderColumns() string {
	n := len(fleetColumns)
	colW := 18
	if m.width > 4 {
		colW = (m.width - 4) / n
	}
	if colW < 12 {
		colW = 12
	}
	bodyH := m.height - 11
	if bodyH < 3 {
		bodyH = 3
	}

	titleSel := lipgloss.NewStyle().Foreground(style.ColorSky).Bold(true)
	titleDim := lipgloss.NewStyle().Foreground(style.ColorPassenger)
	rowSel := lipgloss.NewStyle().Foreground(style.ColorSky).Bold(true)

	rendered := make([]string, n)
	for ci := range fleetColumns {
		var b strings.Builder
		title := fmt.Sprintf("%s (%d)", fleetColumns[ci].title, columnPlaneCount(m.cols[ci]))
		// Show queued count alongside the Waiting lane.
		if ci == 0 && len(m.queued) > 0 {
			title += fmt.Sprintf(" +%d⏳", columnPlaneCount(m.queued))
		}
		if ci == m.activeCol {
			b.WriteString(titleSel.Render("▌" + title))
		} else {
			b.WriteString(titleDim.Render(" " + title))
		}
		b.WriteString("\n")

		if len(m.cols[ci]) == 0 {
			b.WriteString(style.Muted.Render(" —"))
		}
		for ri, e := range m.cols[ci] {
			line := fmt.Sprintf("%s %s ×%d", planeIcon(e.aircraft), e.name, len(e.members))
			// In-flight / service columns show the soonest countdown.
			if r, ok := soonestRemaining(e.members); ok {
				if r == 0 {
					line += " ✓"
				} else {
					line += " " + fmtDuration(r)
				}
			}
			line = truncate(line, colW-2)
			if ci == m.activeCol && ri == m.sel[ci] {
				b.WriteString(rowSel.Render("›" + line))
			} else {
				b.WriteString(" " + line)
			}
			b.WriteString("\n")
		}
		// Queued (RAM-accepted, not yet launched) dispatches hang under Waiting,
		// dimmed and non-selectable, showing their destination.
		if ci == 0 && len(m.queued) > 0 {
			dim := lipgloss.NewStyle().Foreground(style.ColorMuted)
			for _, e := range m.queued {
				dest := ""
				if len(e.members) > 0 && e.members[0].DestinationName.Valid {
					dest = " → " + e.members[0].DestinationName.String
				}
				line := truncate(fmt.Sprintf("⏳ %s ×%d%s", e.name, len(e.members), dest), colW-2)
				b.WriteString(" " + dim.Render(line) + "\n")
			}
		}
		colStyle := lipgloss.NewStyle().Width(colW).MaxHeight(bodyH)
		rendered[ci] = colStyle.Render(b.String())
	}
	return lipgloss.JoinHorizontal(lipgloss.Top, rendered...)
}

func (m FleetModel) dispatchView() string {
	e := m.dispatchEntry
	header := style.PanelHeader.Render(
		fmt.Sprintf("🛫  Dispatch %s %s", planeIcon(e.aircraft), e.name))

	info := style.Muted.Render(fmt.Sprintf("%d idle · ⛽%d each", len(e.members), e.fuelCost))
	if e.maxPax > 0 {
		info += style.Muted.Render(fmt.Sprintf(" · 👤%d each", e.maxPax))
	}

	var b strings.Builder
	b.WriteString(style.PanelHeader.Render("Destination") + "\n")
	for i, d := range m.destinations {
		label := d.Name
		if d.FactionName != "" {
			label += " — " + d.FactionName
		}
		if i == m.destIdx {
			b.WriteString(lipgloss.NewStyle().Foreground(style.ColorSky).Bold(true).Render("› "+label) + "\n")
		} else {
			b.WriteString("  " + style.Muted.Render(label) + "\n")
		}
	}

	count := style.CashChip.Render(fmt.Sprintf(" Count: %d / %d ", m.dispatchCount, len(e.members)))

	help := style.HelpKey.Render("↑↓") + style.HelpDesc.Render(" destination  ") +
		style.HelpKey.Render("←→") + style.HelpDesc.Render(" count  ") +
		style.HelpKey.Render("enter") + style.HelpDesc.Render(" confirm  ") +
		style.HelpKey.Render("esc") + style.HelpDesc.Render(" cancel")

	return lipgloss.JoinVertical(lipgloss.Left,
		header,
		info,
		"",
		b.String(),
		count,
		"",
		style.Muted.Render(help),
	)
}

func (m FleetModel) filterLine() string {
	val := func(label, v string) string {
		if v == "" {
			v = "all"
		}
		return style.Muted.Render(label+":") + style.HelpKey.Render(v)
	}
	return style.Muted.Render("Filters  ") +
		val("size", m.filterSize) + "  " +
		val("type", m.filterType) + "  " +
		val("op", m.filterOp)
}

// facilitiesLine shows runway / service-bay availability (free/total) per size,
// so the player can see why dispatched planes sit queued.
func (m FleetModel) facilitiesLine() string {
	if len(m.facilities) == 0 {
		return style.Muted.Render("Facilities  none — build runways & service bays in the Buildings tab")
	}
	byType := make(map[string][]string)
	var order []string
	for _, f := range m.facilities {
		if _, ok := byType[f.OperationType]; !ok {
			order = append(order, f.OperationType)
		}
		size := "?"
		if f.Size != "" {
			size = f.Size[:1]
		}
		byType[f.OperationType] = append(byType[f.OperationType],
			fmt.Sprintf("%s %d/%d", size, f.Total-f.Busy, f.Total))
	}
	var segs []string
	for _, t := range order {
		icon, label := "🅿", "Service"
		if t == "runway" {
			icon, label = "🛫", "Runway"
		}
		segs = append(segs, fmt.Sprintf("%s %s %s", icon, label, strings.Join(byType[t], " ")))
	}
	return style.Muted.Render("Facilities  " + strings.Join(segs, "   "))
}

// ─── Column building / selection ───────────────────────────────────────────

func (m FleetModel) buildColumns() [][]colEntry {
	cols := make([][]colEntry, len(fleetColumns))
	for ci, col := range fleetColumns {
		idx := make(map[uint32]int)
		for i := range m.fleet {
			p := m.fleet[i]
			if p.Status != col.status || !m.passesFilter(p) {
				continue
			}
			j, ok := idx[p.PlaneID]
			if !ok {
				pax := int32(0)
				if p.MaxPassengers.Valid {
					pax = p.MaxPassengers.Int32
				}
				cash := int32(0)
				if p.CashReward.Valid {
					cash = p.CashReward.Int32
				}
				cols[ci] = append(cols[ci], colEntry{
					planeID:    p.PlaneID,
					name:       p.PlaneName,
					aircraft:   p.AircraftType,
					size:       p.AircraftSize,
					opType:     p.OperationType,
					fuelCost:   p.FuelCost,
					maxPax:     pax,
					cash:       cash,
					buyingCost: p.BuyingCost,
				})
				j = len(cols[ci]) - 1
				idx[p.PlaneID] = j
			}
			cols[ci][j].members = append(cols[ci][j].members, p)
		}
	}
	return cols
}

// buildQueued groups RAM-queued planes (synthetic status "queued") by template,
// for the dimmed rows under the Waiting column.
func (m FleetModel) buildQueued() []colEntry {
	idx := make(map[uint32]int)
	var out []colEntry
	for i := range m.fleet {
		p := m.fleet[i]
		if p.Status != "queued" || !m.passesFilter(p) {
			continue
		}
		j, ok := idx[p.PlaneID]
		if !ok {
			out = append(out, colEntry{
				planeID:  p.PlaneID,
				name:     p.PlaneName,
				aircraft: p.AircraftType,
				size:     p.AircraftSize,
			})
			j = len(out) - 1
			idx[p.PlaneID] = j
		}
		out[j].members = append(out[j].members, p)
	}
	return out
}

func (m FleetModel) passesFilter(p model.PlayerPlane) bool {
	if m.filterSize != "" && p.AircraftSize != m.filterSize {
		return false
	}
	if m.filterType != "" && p.AircraftType != m.filterType {
		return false
	}
	if m.filterOp != "" && p.OperationType != m.filterOp {
		return false
	}
	return true
}

func (m *FleetModel) clampSel() {
	if len(m.sel) != len(fleetColumns) {
		m.sel = make([]int, len(fleetColumns))
	}
	for ci := range m.cols {
		if m.sel[ci] >= len(m.cols[ci]) {
			m.sel[ci] = len(m.cols[ci]) - 1
		}
		if m.sel[ci] < 0 {
			m.sel[ci] = 0
		}
	}
}

func (m FleetModel) currentEntry() *colEntry {
	if m.activeCol < 0 || m.activeCol >= len(m.cols) {
		return nil
	}
	col := m.cols[m.activeCol]
	i := m.sel[m.activeCol]
	if i < 0 || i >= len(col) {
		return nil
	}
	return &col[i]
}

// ─── Commands ────────────────────────────────────────────────────────────────

func (m FleetModel) loadFleet() tea.Cmd {
	client := m.client
	airportID := m.airportID
	return func() tea.Msg {
		fleet, err := client.GetFleet(airportID)
		if err != nil {
			return FleetErrMsg{Err: err}
		}
		facilities, err := client.Facilities(airportID)
		if err != nil {
			return FleetErrMsg{Err: err}
		}
		return FleetLoadedMsg{Fleet: fleet, Facilities: facilities, Note: client.DispatchNote(airportID)}
	}
}

func (m FleetModel) loadDestinations() tea.Cmd {
	client := m.client
	return func() tea.Msg {
		dest, err := client.GetCentralAirports()
		if err != nil {
			return FleetErrMsg{Err: err}
		}
		return DestinationsLoadedMsg{Dest: dest}
	}
}

// dispatchFlights queues up to count idle members for dispatch to destID. The
// service accepts them into RAM instantly and its background worker launches
// them to SQL as bays/runways free — so the UI never blocks on bay contention.
func (m FleetModel) dispatchFlights(members []model.PlayerPlane, destID uint32, count int) tea.Cmd {
	client := m.client
	airportID := m.airportID
	var chosen []model.PlayerPlane
	for _, p := range members {
		if p.Status != "idle" {
			continue
		}
		chosen = append(chosen, p)
		if len(chosen) >= count {
			break
		}
	}
	return func() tea.Msg {
		queued := client.DispatchFlights(airportID, chosen, destID)
		return DispatchResultMsg{Queued: queued}
	}
}

// cancelQueue clears all not-yet-launched dispatches for this airport.
func (m FleetModel) cancelQueue() tea.Cmd {
	client := m.client
	airportID := m.airportID
	return func() tea.Msg {
		return DispatchCancelledMsg{Count: client.CancelQueue(airportID)}
	}
}

func (m FleetModel) sellPlane(pp *model.PlayerPlane) tea.Cmd {
	client := m.client
	airportID := m.airportID
	id := pp.ID
	return func() tea.Msg {
		refund, err := client.SellPlane(airportID, id)
		if err != nil {
			return FleetErrMsg{Err: err}
		}
		return PlaneSoldMsg{Refund: refund}
	}
}

// ─── Exported for parent AppModel ─────────────────────────────────────────────

// LoadFleet fetches the current fleet from the DB.
func (m FleetModel) LoadFleet() tea.Cmd { return m.loadFleet() }

// LoadDestinations fetches the central-port dispatch destinations (global, so
// it does not depend on the airport id being resolved yet).
func (m FleetModel) LoadDestinations() tea.Cmd { return m.loadDestinations() }

// CheckServiceProgress advances planes through service stages.
func (m FleetModel) CheckServiceProgress() tea.Cmd {
	client := m.client
	airportID := m.airportID
	return func() tea.Msg {
		if err := client.AdvanceServiceStages(airportID); err != nil {
			return FleetErrMsg{Err: err}
		}
		return ServiceProgressMsg{}
	}
}

// CheckLanding lands every plane whose flight has elapsed (the service does the
// query + land loop). Returns nil when nothing was ready, so the tick is quiet.
func (m FleetModel) CheckLanding() tea.Cmd {
	client := m.client
	airportID := m.airportID
	return func() tea.Msg {
		landed, cash, err := client.LandReadyPlanes(airportID)
		if err != nil {
			return FleetErrMsg{Err: err}
		}
		if landed == 0 {
			return nil
		}
		return FlightLandedMsg{Count: landed, CashEarned: cash}
	}
}

// ─── Misc helpers ─────────────────────────────────────────────────────────────

// resaleValue previews what a plane sells for: full buying cost within the 5-min
// purchase window, otherwise half. (Authoritative value is computed in SQL by
// SellPlane on MySQL's clock; this preview uses Go time and may be ~seconds off.)
func resaleValue(pp *model.PlayerPlane) int64 {
	if !pp.PurchasedAt.IsZero() && time.Since(pp.PurchasedAt) <= 5*time.Minute {
		return int64(pp.BuyingCost)
	}
	return int64(pp.BuyingCost) / 2
}

// soonestRemaining returns the smallest TimeRemainingSeconds among members that
// are in a timed phase (flight/service). ok=false if none are timed.
func soonestRemaining(members []model.PlayerPlane) (int, bool) {
	best := -1
	for i := range members {
		switch members[i].Status {
		case "boarding", "taxiing", "flying", "unloading":
			r := members[i].TimeRemainingSeconds()
			if best < 0 || r < best {
				best = r
			}
		}
	}
	return best, best >= 0
}

func columnPlaneCount(entries []colEntry) int {
	n := 0
	for _, e := range entries {
		n += len(e.members)
	}
	return n
}

// cycle advances v through "" → options[0] → … → "" (wraps back to all).
func cycle(v string, options ...string) string {
	if v == "" {
		return options[0]
	}
	for i, o := range options {
		if o == v {
			if i+1 < len(options) {
				return options[i+1]
			}
			return ""
		}
	}
	return ""
}

func truncate(s string, max int) string {
	if max < 1 {
		max = 1
	}
	if len([]rune(s)) <= max {
		return s
	}
	r := []rune(s)
	if max <= 1 {
		return string(r[:max])
	}
	return string(r[:max-1]) + "…"
}

func planeIcon(aircraft string) string {
	switch aircraft {
	case "helicopter":
		return "🚁"
	case "seaplane":
		return "🛥"
	case "spaceship":
		return "🚀"
	default:
		return "✈"
	}
}

func fmtDuration(secs int) string {
	d := time.Duration(secs) * time.Second
	h := int(d.Hours())
	mn := int(d.Minutes()) % 60
	s := int(d.Seconds()) % 60
	if h > 0 {
		return fmt.Sprintf("%dh%dm", h, mn)
	}
	if mn > 0 {
		return fmt.Sprintf("%dm%ds", mn, s)
	}
	return fmt.Sprintf("%ds", s)
}