Function bodies 285 total

func (m *Model) handleNextCategory() tea.Cmd {
	next := int(m.category) + 1
	if next > int(domain.DedicatedAICluster) {
		next = int(domain.Tenant)
	}
	category := domain.Category(next)
	return tea.Sequence(m.updateCategory(category)...)
}

func (m *Model) handlePrevCategory() tea.Cmd {
	prev := int(m.category) - 1
	if prev < int(domain.Tenant) {
		prev = int(domain.DedicatedAICluster)
	}
	category := domain.Category(prev)
	return tea.Sequence(m.updateCategory(category)...)
}

func (m *Model) handleEditKeys(msg tea.KeyMsg) []tea.Cmd {
	var cmds []tea.Cmd
	updatedTextInput, cmd := m.textInput.Update(msg)
	m.textInput = &updatedTextInput
	cmds = append(cmds, cmd)

	switch {
	case msg.Type == tea.KeyCtrlC:
		cmds = append(cmds, tea.Quit)
	case key.Matches(msg, keys.Confirm):
		if m.editTarget == common.AliasTarget {
			cmd := m.changeCategory()
			if cmd != nil {
				cmds = append(cmds, cmd)
			}
		}
		m.exitEditMode(m.editTarget == common.AliasTarget)
	case key.Matches(msg, keys.Back):
		m.exitEditMode(true)
	default:
		if m.editTarget == common.FilterTarget {
			cmds = append(cmds, DebounceFilter(m))
		}
	}
	return cmds
}

func (m *Model) pushHistory(cat domain.Category) {
	// ignore dups
	if m.historyIdx >= 0 && m.history[m.historyIdx] == cat {
		return
	}
	// truncate forward part when user branches
	if m.historyIdx+1 < len(m.history) {
		m.history = m.history[:m.historyIdx+1]
	}
	m.history = append(m.history, cat)
	m.historyIdx = len(m.history) - 1

	// Cap history size
	if len(m.history) > maxHistory {
		shift := len(m.history) - maxHistory
		m.history = m.history[shift:]
		m.historyIdx -= shift
		if m.historyIdx < 0 {
			m.historyIdx = 0
		}
	}
}

func (m *Model) moveHistory(dir int) tea.Cmd {
	target := m.historyIdx + dir
	if target < 0 || target >= len(m.history) {
		return nil // out of bounds
	}
	m.historyIdx = target
	cat := m.history[m.historyIdx]
	return tea.Sequence(m.updateCategoryNoHist(cat)...)
}

func (m *Model) updateLoadingView(msg tea.Msg) (tea.Model, tea.Cmd) {
	cmds, quit := m.routeLoadingMsg(msg)
	if quit {
		return m, tea.Quit
	}
	cmds = append(cmds, m.handleStopwatchMsg(msg))
	return m, tea.Batch(cmds...)
}

func (m *Model) routeLoadingMsg(msg tea.Msg) ([]tea.Cmd, bool) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		if key.Matches(msg, keys.Quit) {
			m.cancelInFlight()
			return nil, true
		}
		return nil, false
	case DataMsg:
		return []tea.Cmd{m.handleDataMsg(msg)}, false
	case datasetLoadedMsg:
		return []tea.Cmd{m.handleDataMsg(DataMsg{Data: msg.Dataset, Gen: msg.Gen})}, false
	case ErrMsg:
		m.handleErrMsg(msg)
		return nil, false
	case spinner.TickMsg:
		return []tea.Cmd{m.handleSpinnerTickMsg(msg)}, false
	default:
		return m.routeLoadingDataMsg(msg), false
	}
}

func (m *Model) routeLoadingDataMsg(msg tea.Msg) []tea.Cmd {
	switch msg := msg.(type) {
	case baseModelsLoadedMsg:
		m.handleBaseModelsLoaded(msg.Items, msg.Gen)
	case gpuPoolsLoadedMsg:
		return []tea.Cmd{m.handleGpuPoolsLoaded(msg.Items, msg.Gen)}
	case gpuNodesLoadedMsg:
		m.handleGpuNodesLoaded(msg.Items, msg.Gen)
	case dedicatedAIClustersLoadedMsg:
		m.handleDedicatedAIClustersLoaded(msg.Items, msg.Gen)
	case tenancyOverridesLoadedMsg:
		m.handleTenancyOverridesLoaded(msg.Group, msg.Gen)
	case limitRegionalOverridesLoadedMsg:
		m.handleLimitRegionalOverridesLoaded(msg.Items, msg.Gen)
	case consolePropertyRegionalOverridesLoadedMsg:
		m.handleConsolePropertyRegionalOverridesLoaded(msg.Items, msg.Gen)
	case propertyRegionalOverridesLoadedMsg:
		m.handlePropertyRegionalOverridesLoaded(msg.Items, msg.Gen)
	default:
		// Future-proof: ignore unknown message types
	}
	return nil
}

func CenterText(text string, width, height int) string {
	style := lipgloss.NewStyle().
		Width(width).
		Height(height).
		Align(lipgloss.Center, lipgloss.Center)

	return style.Render(text)
}

func (ProductionRenderer) RenderJSON(data any, width int) (string, error) {
	renderer, err := glamour.NewTermRenderer(
		glamour.WithStandardStyle(styles.DarkStyle), // auto style has delay of 5 to 10s after upgrade
		glamour.WithWordWrap(width),
	)
	if err != nil {
		return "", fmt.Errorf("error creating TermRenderer: %w", err)
	}
	details := fmt.Sprintf("```json\n%v\n```", data)
	return renderer.Render(details)
}

func (l *zapLogger) Sync() error {
	// zap.Sync can return os.ErrInvalid on Windows; ignore it
	if err := l.s.Sync(); err != nil && !errors.Is(err, os.ErrInvalid) {
		return err
	}
	return nil
}

func NewLogger(debug bool) (Logger, error) {
	var zl *zap.Logger
	var err error
	if debug {
		zl, err = zap.NewDevelopment()
	} else {
		zl, err = zap.NewProduction()
	}
	if err != nil {
		return nil, err
	}
	return NewZapLogger(zl.Sugar(), debug), nil
}

func MustNewLogger(debug bool) Logger {
	l, err := NewLogger(debug)
	if err != nil {
		panic(err)
	}
	return l
}

func parseZapLevel(level string, debug bool) zapcore.Level {
	l := strings.ToLower(strings.TrimSpace(level))
	switch l {
	case "debug":
		return zapcore.DebugLevel
	case "info", "":
		if l == "" {
			if debug {
				return zapcore.DebugLevel
			}
			return zapcore.InfoLevel
		}
		return zapcore.InfoLevel
	case "warn", "warning":
		return zapcore.WarnLevel
	case "error":
		return zapcore.ErrorLevel
	default:
		return zapcore.InfoLevel
	}
}

func parseSlogLevel(level string, debug bool) slog.Level {
	l := strings.ToLower(strings.TrimSpace(level))
	switch l {
	case "debug":
		return slog.LevelDebug
	case "info", "":
		if l == "" {
			if debug {
				return slog.LevelDebug
			}
			return slog.LevelInfo
		}
		return slog.LevelInfo
	case "warn", "warning":
		return slog.LevelWarn
	case "error":
		return slog.LevelError
	default:
		return slog.LevelInfo
	}
}

func NewFileLoggerWithLevel(debug bool, filename string, logFormat string, logLevel string) (Logger, error) {
	// Configure a rotating writer to avoid truncation and unbounded growth.
	w := &lumberjack.Logger{
		Filename:   filename,
		MaxSize:    50, // megabytes
		MaxBackups: 3,
		MaxAge:     28,   // days
		Compress:   true, // gzip old logs
	}

	if logFormat == "slog" {
		level := parseSlogLevel(logLevel, debug)
		handler := slog.NewJSONHandler(w, &slog.HandlerOptions{Level: level})
		return NewSlogLogger(slog.New(handler), debug), nil
	}

	// Configure zap encoder based on debug flag.
	var encCfg zapcore.EncoderConfig
	if debug {
		encCfg = zap.NewDevelopmentEncoderConfig()
	} else {
		encCfg = zap.NewProductionEncoderConfig()
	}
	encCfg.EncodeTime = zapcore.ISO8601TimeEncoder

	var encoder zapcore.Encoder
	if logFormat == "console" {
		encoder = zapcore.NewConsoleEncoder(encCfg)
	} else {
		encoder = zapcore.NewJSONEncoder(encCfg)
	}

	level := parseZapLevel(logLevel, debug)
	cor

func MustNewFileLogger(debug bool, filename string) Logger {
	l, err := NewFileLogger(debug, filename, "console")
	if err != nil {
		panic(err)
	}
	return l
}

func FromContext(ctx context.Context) Logger {
	if ctx == nil {
		return noopLogger{}
	}
	if logger, ok := ctx.Value(ctxKeyLogger{}).(Logger); ok && logger != nil {
		return logger
	}
	return noopLogger{}
}

func (m BaseModel) GetDefaultDacShape() *DACShape {
	shapes := make(map[string]*DACShape)

	if m.DacShapeConfigs != nil {
		for _, config := range m.DacShapeConfigs.CompatibleDACShapes {
			if config.Default {
				shapes[config.Name] = &config
			}
		}
	}

	if len(shapes) > 1 {
		panic(fmt.Sprintf("More than 1 default DAC shapes found for model: %s", m.InternalName))
	}

	for _, value := range shapes {
		return value
	}

	return nil
}

func (m BaseModel) GetFilterableFields() []string {
	var shapeName string
	shape := m.GetDefaultDacShape()
	if shape != nil {
		shapeName = shape.Name
	}

	return append(m.Capabilities, m.Name, m.DisplayName, m.Status,
		m.Type, m.GetFlags(), shapeName, m.Runtime)
}

func (m BaseModel) GetFlags() string {
	flags := []string{}
	if m.IsExperimental {
		flags = append(flags, "EXP")
	}
	if m.IsInternal {
		flags = append(flags, "INT")
	}
	switch m.LifeCyclePhase {
	case "DEPRECATED":
		flags = append(flags, "RTD")
	case "ONDEMAND_SERVING_DISABLED":
		flags = append(flags, "DAC")
	}

	if m.IsImageTextToText {
		flags = append(flags, "IMG")
	}

	return strings.Join(flags, "/")
}

func (d *Dataset) buildTenantIDSuffixMap() map[string]int {
	suffixMap := make(map[string]int)

	for i, tenant := range d.Tenants {
		for _, id := range tenant.IDs {
			parts := strings.Split(id, ".")
			suffix := parts[len(parts)-1]
			suffixMap[suffix] = i
		}
	}

	return suffixMap
}

func (d *Dataset) SetDedicatedAIClusterMap(m map[string][]DedicatedAICluster) {
	dacMap := make(map[string][]DedicatedAICluster)
	suffixMap := d.buildTenantIDSuffixMap()

	for k, v := range m {
		name := k
		var tenant *Tenant
		if idx, ok := suffixMap[k]; ok {
			tenant = &d.Tenants[idx]
			name = tenant.Name
		}

		dacMap[name] = v
		for i := range v {
			v[i].Owner = tenant
		}
	}

	d.DedicatedAIClusterMap = dacMap
}

func (d *Dataset) ResetScopedData() {
	d.LimitTenancyOverrideMap = nil
	d.ConsolePropertyTenancyOverrideMap = nil
	d.PropertyTenancyOverrideMap = nil
	d.Tenants = nil
	d.LimitRegionalOverrides = nil
	d.ConsolePropertyRegionalOverrides = nil
	d.PropertyRegionalOverrides = nil
	d.BaseModels = nil
	d.GpuPools = nil
	d.GpuNodeMap = nil
	d.DedicatedAIClusterMap = nil
}

func (n DedicatedAICluster) GetFilterableFields() []string {
	return []string{
		n.Name,
		n.Type,
		n.UnitShape,
		n.Status,
		n.TenantID,
		n.Profile,
		n.GetOwnerState(),
		n.ModelName,
		n.GetUsage(),
		n.Age,
	}
}

func (n DedicatedAICluster) GetOwnerState() string {
	var state string
	if n.Owner != nil {
		state = fmt.Sprint(n.Owner.IsInternal)
	}
	return state
}

func (n DedicatedAICluster) GetUsage() string {
	if n.TotalReplicas <= 0 {
		return ""
	}

	rate := 1.0 - float64(n.IdleReplicas)/float64(n.TotalReplicas)
	return fmt.Sprintf("%.0f%%", rate*100)
}

func (n DedicatedAICluster) IsFaulty() bool {
	switch s := n.Status; {
	case len(s) == 0:
		return false
	default:
		lower := strings.ToLower(s)
		return lower == "fail" || lower == "failed"
	}
}

func normalizeRegion(region string) string {
	r := Region(region)
	if r == RegionIAD || r == RegionPHX {
		return r.GetCode()
	}
	return region
}

func (e Environment) GetKubeContext() string {
	envType := e.Type
	if envType == "preprod" {
		envType = "ppe"
	}

	return fmt.Sprintf("dp-%s-%s", envType, Region(e.Region).GetCode())
}

func (n GpuNode) GetStatus() string {
	if n.status != "" {
		return n.status
	}

	parts := strings.Split(n.InstanceType, ".")
	count, _ := strconv.Atoi(parts[len(parts)-1])
	switch {
	case n.IsSchedulingDisabled:
		return "WARN: CORDONED"
	case n.Allocatable != count:
		return "ERROR: Missing GPUs"
	case !n.IsHealthy():
		return "ERROR: Unhealthy"
	case !n.IsReady:
		return "ERROR: Not ready"
	}
	return "OK"
}

func (m *Metadata) GetTenants(realm string) []TenantMetadata {
	var out []TenantMetadata
	for _, t := range m.Tenants {
		parts := strings.Split(t.ID, ".")
		if len(parts) >= 3 && parts[2] == realm {
			out = append(out, t)
		}
	}
	return out
}

func (r Region) GetCode() string {
	for k, v := range shortNameRegion {
		if v == r {
			return k
		}
	}

	return "UNKNOWN"
}

func (t ServiceTenancy) Environments() []Environment {
	environments := make([]Environment, 0, len(t.Regions))
	for _, region := range t.Regions {
		env := Environment{
			Type:   t.Environment,
			Region: region,
			Realm:  t.Realm,
		}
		environments = append(environments, env)
	}

	return environments
}

func (t Tenant) GetTenantID() string {
	if len(t.IDs) > 1 {
		return fmt.Sprintf("%s (+%d)", t.IDs[0], len(t.IDs)-1)
	}
	if len(t.IDs) == 1 {
		return t.IDs[0]
	}
	return ""
}