Function bodies 285 total

func (m *Model) enterEditMode(target common.EditTarget) tea.Cmd {
	m.table.Blur()
	m.inputMode = common.EditInput
	m.editTarget = target
	m.textInput.Focus()

	// Provide category suggestions using domain.Aliases.
	keys := domain.Aliases
	if target == common.AliasTarget {
		m.textInput.Reset()
	} else if len(m.textInput.Value()) > 0 {
		keys = append(keys, m.textInput.Value())
		cmd := m.backToLastState()
		m.textInput.ShowSuggestions = len(keys) > 0
		m.textInput.SetSuggestions(keys)
		return cmd
	}

	m.textInput.ShowSuggestions = len(keys) > 0
	m.textInput.SetSuggestions(keys)
	return nil
}

func (m *Model) backToLastState() tea.Cmd {
	if m.curFilter != "" {
		m.textInput.Reset()
		return filterTableAsync(m, "")
	} else if m.context != nil && m.context.Category.IsScopeOf(m.category) {
		m.context = nil
		return m.updateRowsAsync()
	}
	return nil
}

func (m *Model) exitEditMode(resetInput bool) {
	if m.editTarget == common.AliasTarget || resetInput {
		m.textInput.SetSuggestions([]string{})
		m.textInput.ShowSuggestions = false
	}

	m.inputMode = common.NormalInput
	m.editTarget = common.NoneTarget
	if resetInput {
		m.textInput.Reset()
	}
	m.textInput.Blur()
	m.table.Focus()
}

func (m *Model) exportTableCSV(outPath string) (err error) {
	if m == nil || m.table == nil {
		return fmt.Errorf("no table data to export")
	}
	outPath = filepath.Clean(outPath)
	f, err := os.Create(outPath)
	if err != nil {
		return err
	}
	defer func() {
		cerr := f.Close()
		if err == nil && cerr != nil {
			err = cerr
		}
	}()
	err = m.writeCSV(f)
	return
}

func (m *Model) writeCSV(w io.Writer) error {
	cw := csv.NewWriter(w)

	// Write headers
	headers := make([]string, 0, len(m.headers))
	for _, h := range m.headers {
		headers = append(headers, h.text)
	}
	if err := cw.Write(headers); err != nil {
		return err
	}

	// Write rows
	rows := m.table.Rows()
	if m.category == domain.DedicatedAICluster {
		realm := m.environment.Realm
		region := m.environment.Region
		rows = filterRowsScoped(
			m.dataset.DedicatedAIClusterMap, domain.Tenant,
			m.context, m.curFilter, m.showFaulty,
			func(val models.DedicatedAICluster, _ string) table.Row {
				id := val.GetID(realm, region)
				return dedicatedAIClusterToRowInternal(
					val, val.GetTenantID(realm), &id)
			})
	}

	for _, row := range rows {
		if err := cw.Write(row); err != nil {
			return err
		}
	}
	cw.Flush()
	return cw.Error()
}

func filterTableAsync(m *Model, filter string) tea.Cmd {
	if filter == m.curFilter {
		return nil
	}
	m.curFilter = filter
	return m.updateRowsAsync()
}

func DebounceFilter(m *Model) tea.Cmd {
	val := strings.ToLower(m.textInput.Value())
	m.filterNonce++
	nonce := m.filterNonce
	return tea.Tick(100*time.Millisecond, func(_ time.Time) tea.Msg {
		return FilterApplyMsg{Value: val, Nonce: nonce}
	})
}

func (k KeyMap) FullHelp() [][]key.Binding {
	cat := slices.Concat(k.Global, k.Mode, k.Context)
	// skip sort keys
	cat = slices.DeleteFunc(cat, func(b key.Binding) bool {
		return strings.HasPrefix(b.Help().Desc, SortPrefix)
	})
	slices.SortFunc(cat, func(c1, c2 key.Binding) int {
		return strings.Compare(c1.Help().Desc, c2.Help().Desc)
	})

	rows := [][]key.Binding{}
	for chunk := range slices.Chunk(cat, 5) {
		rows = append(rows, chunk)
	}
	return rows
}

func (k KeyMap) Help() key.Binding {
	for _, b := range k.Global {
		h := b.Help()
		if strings.EqualFold(h.Key, "h") || strings.EqualFold(h.Desc, "help") {
			return b
		}
	}
	return key.Binding{}
}

func (k KeyMap) Quit() key.Binding {
	for _, b := range k.Global {
		h := b.Help()
		if strings.EqualFold(h.Key, "q") || strings.EqualFold(h.Desc, "quit") {
			return b
		}
	}
	return key.Binding{}
}

func ResolveKeys(cat domain.Category, mode common.ViewMode) KeyMap {
	km := KeyMap{
		Global: globalKeys,
	}
	switch mode { //nolint:exhaustive
	case common.ListView:
		km.Mode = listModeKeys
	case common.DetailsView:
		km.Mode = detailsModeKeys
	}
	if ctxByMode, ok := catContext[cat]; ok {
		km.Context = ctxByMode[mode]
	}
	return km
}

func loadBaseModelsCmd(ctx context.Context, ld loader.Loader, kubeCfg string, env models.Environment, gen int) tea.Cmd {
	return func() tea.Msg {
		items, err := ld.LoadBaseModels(ctx, kubeCfg, env)
		if err != nil {
			return ErrMsg(fmt.Errorf("failed to load %s: %w", domain.BaseModel, err))
		}
		return baseModelsLoadedMsg{Items: items, Gen: gen}
	}
}

func loadGpuPoolsCmd(ctx context.Context, ld loader.Loader, repoPath string, env models.Environment, gen int) tea.Cmd {
	return func() tea.Msg {
		items, err := ld.LoadGpuPools(ctx, repoPath, env)
		if err != nil {
			return ErrMsg(fmt.Errorf("failed to load %s: %w", domain.GpuPool, err))
		}
		return gpuPoolsLoadedMsg{Items: items, Gen: gen}
	}
}

func loadGpuNodesCmd(ctx context.Context, ld loader.Loader, kubeCfg string, env models.Environment, gen int) tea.Cmd {
	return func() tea.Msg {
		items, err := ld.LoadGpuNodes(ctx, kubeCfg, env)
		if err != nil {
			return ErrMsg(fmt.Errorf("failed to load %s: %w", domain.GpuNode, err))
		}
		return gpuNodesLoadedMsg{Items: items, Gen: gen}
	}
}

func loadDedicatedAIClustersCmd(ctx context.Context, ld loader.Loader, kubeCfg string, env models.Environment, gen int) tea.Cmd {
	return func() tea.Msg {
		items, err := ld.LoadDedicatedAIClusters(ctx, kubeCfg, env)
		if err != nil {
			return ErrMsg(fmt.Errorf("failed to load %s: %w", domain.DedicatedAICluster, err))
		}
		return dedicatedAIClustersLoadedMsg{Items: items, Gen: gen}
	}
}

func loadTenancyOverrideGroupCmd(ctx context.Context, ld loader.Loader, repoPath string, env models.Environment, gen int) tea.Cmd {
	return func() tea.Msg {
		group, err := ld.LoadTenancyOverrideGroup(ctx, repoPath, env)
		if err != nil {
			return ErrMsg(fmt.Errorf("failed to load %s: %w", domain.Tenant, err))
		}
		return tenancyOverridesLoadedMsg{Group: group, Gen: gen}
	}
}

func loadLimitRegionalOverridesCmd(ctx context.Context, ld loader.Loader, repoPath string, env models.Environment, gen int) tea.Cmd {
	return func() tea.Msg {
		items, err := ld.LoadLimitRegionalOverrides(ctx, repoPath, env)
		if err != nil {
			return ErrMsg(fmt.Errorf("failed to load %s: %w", domain.LimitRegionalOverride, err))
		}
		return limitRegionalOverridesLoadedMsg{Items: items, Gen: gen}
	}
}

func loadConsolePropertyRegionalOverridesCmd(ctx context.Context, ld loader.Loader, repoPath string, env models.Environment, gen int) tea.Cmd {
	return func() tea.Msg {
		items, err := ld.LoadConsolePropertyRegionalOverrides(ctx, repoPath, env)
		if err != nil {
			return ErrMsg(fmt.Errorf("failed to load %s: %w", domain.ConsolePropertyRegionalOverride, err))
		}
		return consolePropertyRegionalOverridesLoadedMsg{Items: items, Gen: gen}
	}
}

func loadPropertyRegionalOverridesCmd(ctx context.Context, ld loader.Loader, repoPath string, env models.Environment, gen int) tea.Cmd {
	return func() tea.Msg {
		items, err := ld.LoadPropertyRegionalOverrides(ctx, repoPath, env)
		if err != nil {
			return ErrMsg(fmt.Errorf("failed to load %s: %w", domain.PropertyRegionalOverride, err))
		}
		return propertyRegionalOverridesLoadedMsg{Items: items, Gen: gen}
	}
}

func (m *Model) loadData() []tea.Cmd {
	// bump generation so that responses from previous loads are ignored
	gen := m.bumpGen()
	m.newLoadContext()

	return []tea.Cmd{
		m.loadingTimer.Init(),
		m.beginTask(),
		func() tea.Msg {
			dataset, err := m.loader.LoadDataset(m.loadCtx, m.repoPath, m.environment)
			if err != nil {
				return ErrMsg(err)
			}
			return datasetLoadedMsg{Dataset: dataset, Gen: gen}
		},
	}
}

func setFilter(filter string) tea.Cmd {
	if filter == "" {
		return nil
	}

	return func() tea.Msg {
		return SetFilterMsg(filter)
	}
}

func (m *Model) Init() tea.Cmd {
	cmds := m.loadData()

	if _, ok := lazyLoadedCategories[m.category]; ok {
		cmds = append(cmds, m.updateCategory(m.category)...)
	}

	cmds = append(cmds, setFilter(m.initialFilter))
	return tea.Sequence(cmds...)
}

func (m *Model) getCompartmentID(ctx context.Context) (string, error) {
	if m.dataset != nil && m.dataset.GpuNodeMap != nil {
		for _, v := range m.dataset.GpuNodeMap {
			for _, n := range v {
				return n.CompartmentID, nil
			}
		}
	}

	clientset, err := k8s.NewClientsetFromKubeConfig(m.kubeConfig, m.environment.GetKubeContext())
	if err != nil {
		return "", err
	}
	nodes, err := k8s.ListGpuNodes(ctx, clientset, 1)
	if err != nil || len(nodes) == 0 {
		return "", err
	}

	return nodes[0].CompartmentID, nil
}

func (m *Model) updateGpuPoolState() tea.Cmd {
	return func() tea.Msg {
		ctx, cancel := m.opContext()
		defer cancel()
		var err error
		var compartmentID string
		if compartmentID, err = m.getCompartmentID(ctx); err == nil {
			err = actions.PopulateGpuPools(ctx, m.dataset.GpuPools, m.environment, compartmentID)
		}
		return updateDoneMsg{err: err, category: domain.GpuPool}
	}
}

func (m *Model) updateRowsAsync() tea.Cmd {
	m.rowsNonce++
	nonce := m.rowsNonce
	dataset := m.dataset
	category := m.category
	context := m.context
	filter := m.curFilter
	sortColumn := m.sortColumn
	sortAsc := m.sortAsc
	showFaulty := m.showFaulty
	return func() tea.Msg {
		rows, stats := getTableRows(dataset, category, context, filter, sortColumn, sortAsc, showFaulty)
		return tableRowsComputedMsg{
			Rows:  rows,
			Stats: stats,
			Nonce: nonce,
		}
	}
}

func (m *Model) handleTableRowsComputedMsg(msg tableRowsComputedMsg) {
	if msg.Nonce != m.rowsNonce {
		return
	}
	m.applyRows(msg.Rows, msg.Stats, true)
}

func (m *Model) applyRows(rows []table.Row, stats tableStats, autoSelect bool) {
	m.stats = stats
	table.WithRows(rows)(m.table)

	if autoSelect {
		idx := m.findContextIndex(rows)
		if idx >= 0 {
			m.table.SetCursor(idx)
		} else {
			m.table.GotoTop()
		}
	} else {
		m.table.UpdateViewport()
	}
}

func (m *Model) updateColumns() {
	m.headers = getHeaders(m.category)
	columns := make([]table.Column, len(m.headers))
	remaining := m.table.Width()
	for i, header := range m.headers {
		width := remaining
		if i+1 < len(m.headers) {
			width = int(math.Floor(float64(m.table.Width()) * float64(header.ratio)))
			remaining -= width
		}
		width -= m.styles.Header.GetHorizontalFrameSize()
		title := header.text
		if m.sortColumn != "" && strings.EqualFold(header.text, m.sortColumn) {
			if m.sortAsc {
				title += " ↑"
			} else {
				title += " ↓"
			}
		}
		columns[i] = table.Column{Title: title, Width: width}
	}
	table.WithColumns(columns)(m.table)
}

func (m *Model) findContextIndex(rows []table.Row) int {
	if len(rows) == 0 {
		return -1
	}

	var name string
	switch {
	case m.category == domain.Environment:
		name = m.environment.GetName()
	case m.context != nil && m.category == m.context.Category:
		name = m.context.Name
	default:
		return -1
	}

	for i, r := range rows {
		if r[0] == name {
			return i
		}
	}

	return -1
}

func (m *Model) updateLayout(w, h int) {
	m.viewWidth, m.viewHeight = w, h
	m.help.Width = w
	var borderStyle lipgloss.Border
	if m.viewMode == common.DetailsView {
		borderStyle = m.viewport.Style.GetBorderStyle()
	} else {
		borderStyle = m.baseStyle.GetBorderStyle()
	}
	borderWidth := borderStyle.GetLeftSize() + borderStyle.GetRightSize()
	borderHeight := borderStyle.GetTopSize() + borderStyle.GetBottomSize()
	statusHeight := lipgloss.Height(m.statusView())
	infoHeight := lipgloss.Height(m.infoView())
	top := statusHeight + infoHeight
	if m.viewMode == common.DetailsView {
		m.viewport.Width = w
		m.viewport.Height = h - top
	} else {
		table.WithWidth(w - borderWidth)(m.table)
		table.WithHeight(h - borderHeight - top)(m.table)
		m.updateColumns()
		m.table.UpdateViewport()
	}
}

func (m *Model) refreshDisplay() {
	m.curFilter = ""
	m.textInput.Reset()
	m.updateColumns()
	m.updateRows(true)
}

func (m *Model) processData(msg DataMsg) tea.Cmd {
	var cmd tea.Cmd
	// Drop stale responses based on generation token (allow zero-value Gen).
	if msg.Gen != 0 && msg.Gen != m.gen {
		return nil
	}
	switch data := msg.Data.(type) {
	case *models.Dataset:
		m.dataset = data
	case []models.BaseModel:
		m.dataset.BaseModels = data
	case []models.GpuPool:
		m.dataset.GpuPools = data
		cmd = m.updateGpuPoolState()
	case map[string][]models.GpuNode:
		m.dataset.GpuNodeMap = data
	case map[string][]models.DedicatedAICluster:
		m.dataset.SetDedicatedAIClusterMap(data)
	case models.TenancyOverrideGroup:
		m.dataset.Tenants = data.Tenants
		m.dataset.LimitTenancyOverrideMap = data.LimitTenancyOverrideMap
		m.dataset.ConsolePropertyTenancyOverrideMap = data.ConsolePropertyTenancyOverrideMap
		m.dataset.PropertyTenancyOverrideMap = data.PropertyTenancyOverrideMap
	}

	if msg.Data != nil {
		m.endTask(true)
		m.logger.Infow("data loaded", "category", m.category, "pendingTasks", m.pendingTasks)
	}
	

func (m *Model) applyDataset(mut func(*models.Dataset), category domain.Category, count int) {
	if m.dataset == nil {
		m.dataset = &models.Dataset{}
	}
	mut(m.dataset)
	m.endTask(true)
	m.logger.Infow("data loaded", "category", category, "count", count, "pendingTasks", m.pendingTasks)
	m.refreshDisplay()
}

func (m *Model) handleBaseModelsLoaded(items []models.BaseModel, gen int) {
	if gen != m.gen {
		return
	}
	m.applyDataset(func(ds *models.Dataset) { ds.BaseModels = items }, domain.BaseModel, len(items))
}

func (m *Model) handleGpuPoolsLoaded(items []models.GpuPool, gen int) tea.Cmd {
	if gen != m.gen {
		return nil
	}
	m.applyDataset(func(ds *models.Dataset) { ds.GpuPools = items }, domain.GpuPool, len(items))
	return m.updateGpuPoolState()
}

func (m *Model) handleGpuNodesLoaded(items map[string][]models.GpuNode, gen int) {
	if gen != m.gen {
		return
	}
	total := 0
	for _, v := range items {
		total += len(v)
	}
	m.applyDataset(func(ds *models.Dataset) { ds.GpuNodeMap = items }, domain.GpuNode, total)
}

func (m *Model) handleDedicatedAIClustersLoaded(items map[string][]models.DedicatedAICluster, gen int) {
	if gen != m.gen {
		return
	}
	total := 0
	for _, v := range items {
		total += len(v)
	}
	m.applyDataset(func(ds *models.Dataset) { ds.SetDedicatedAIClusterMap(items) }, domain.DedicatedAICluster, total)
}

func (m *Model) handleTenancyOverridesLoaded(group models.TenancyOverrideGroup, gen int) {
	if gen != m.gen {
		return
	}
	m.applyDataset(func(ds *models.Dataset) {
		ds.Tenants = group.Tenants
		ds.LimitTenancyOverrideMap = group.LimitTenancyOverrideMap
		ds.ConsolePropertyTenancyOverrideMap = group.ConsolePropertyTenancyOverrideMap
		ds.PropertyTenancyOverrideMap = group.PropertyTenancyOverrideMap
	}, domain.Tenant, len(group.Tenants))
}

func (m *Model) handleLimitRegionalOverridesLoaded(items []models.LimitRegionalOverride, gen int) {
	if gen != m.gen {
		return
	}
	m.applyDataset(func(ds *models.Dataset) { ds.LimitRegionalOverrides = items }, domain.LimitRegionalOverride, len(items))
}

func (m *Model) handleConsolePropertyRegionalOverridesLoaded(items []models.ConsolePropertyRegionalOverride, gen int) {
	if gen != m.gen {
		return
	}
	m.applyDataset(func(ds *models.Dataset) { ds.ConsolePropertyRegionalOverrides = items }, domain.ConsolePropertyRegionalOverride, len(items))
}

func (m *Model) handlePropertyRegionalOverridesLoaded(items []models.PropertyRegionalOverride, gen int) {
	if gen != m.gen {
		return
	}
	m.applyDataset(func(ds *models.Dataset) { ds.PropertyRegionalOverrides = items }, domain.PropertyRegionalOverride, len(items))
}

func (m *Model) sortTableByColumn(column string) tea.Cmd {
	if m.sortColumn == column {
		m.sortAsc = !m.sortAsc
	} else {
		m.sortColumn = column
		m.sortAsc = true
	}

	m.updateColumns()
	return m.updateRowsAsync()
}

func (m *Model) handleAdditionalKeys(msg tea.KeyMsg) tea.Cmd {
	idx := slices.IndexFunc(m.keys.Context, func(b key.Binding) bool {
		return key.Matches(msg, b)
	})

	if idx < 0 {
		return nil
	}

	binding := m.keys.Context[idx]
	if column, ok := strings.CutPrefix(binding.Help().Desc, keys.SortPrefix); ok {
		return m.sortTableByColumn(column)
	}

	if key.Matches(msg, keys.ToggleFaulty) {
		return m.toggleFaultyList()
	}

	return m.handleItemActions(msg)
}

func (m *Model) handleItemActions(msg tea.KeyMsg) tea.Cmd {
	itemKey := getItemKey(m.category, m.table.SelectedRow())
	item := findItem(m.dataset, m.category, itemKey)
	switch {
	case key.Matches(msg, keys.CopyTenant):
		return m.copyTenantID(item)
	case key.Matches(msg, keys.Refresh):
		return tea.Sequence(m.updateCategoryNoHist(m.category)...)
	case key.Matches(msg, keys.ToggleCordon):
		return m.cordonNode(item)
	case key.Matches(msg, keys.DrainNode):
		return m.drainNode(item)
	case key.Matches(msg, keys.Delete):
		return m.deleteItem(itemKey)
	case key.Matches(msg, keys.RebootNode):
		return m.rebootNode(item)
	case key.Matches(msg, keys.ScaleUp):
		return m.scaleUpGpuPool(item)
	}
	return nil
}

func (m *Model) copyTenantID(item any) tea.Cmd {
	return func() tea.Msg {
		actions.CopyTenantID(item, m.environment, m.logger)
		return nil
	}
}

func (m *Model) scaleUpGpuPool(item any) tea.Cmd {
	pool, ok := item.(*models.GpuPool)
	if !ok || pool == nil {
		m.logger.Errorw("no GPU pool selected for scale up")
		return nil
	}

	key := getItemKey(m.category, m.table.SelectedRow())
	m.logger.Infow("action started", "action", "scaleUpGpuPool", "pool", getItemKeyString(key))
	return tea.Batch(
		func() tea.Msg { return gpuPoolScaleStartedMsg{key: key} },
		func() tea.Msg {
			ctx, cancel := m.opContext()
			defer cancel()
			err := actions.IncreasePoolSize(ctx, pool, m.environment, m.logger)
			return gpuPoolScaleResultMsg{key: key, err: err}
		},
	)
}

func (m *Model) cordonNode(item any) tea.Cmd {
	if item == nil {
		m.logger.Errorw("no item selected for cordon operation", "category", m.category)
		return nil
	}
	node, ok := item.(*models.GpuNode)
	if !ok {
		m.logger.Errorw("unsupported item type for cordon operation", "item", item)
		return nil
	}
	key := getItemKey(m.category, m.table.SelectedRow())
	m.logger.Infow("action started", "action", "toggleCordon", "node", getItemKeyString(key))
	return func() tea.Msg {
		ctx, cancel := m.opContext()
		defer cancel()
		state, err := k8s.ToggleCordon(ctx, m.kubeConfig, m.environment.GetKubeContext(), node.Name)
		return cordonNodeResultMsg{key: key, state: state, err: err}
	}
}

func (m *Model) drainNode(item any) tea.Cmd {
	if item == nil {
		m.logger.Errorw("no item selected for draining", "category", m.category)
		return nil
	}
	node, ok := item.(*models.GpuNode)
	if !ok {
		m.logger.Errorw("unsupported item type for draining", "item", item)
		return nil
	}
	key := getItemKey(m.category, m.table.SelectedRow())
	m.logger.Infow("action started", "action", "drainNode", "node", getItemKeyString(key))
	return func() tea.Msg {
		ctx, cancel := m.opContext()
		defer cancel()
		err := k8s.DrainNode(ctx, m.kubeConfig, m.environment.GetKubeContext(), node.Name)
		return drainNodeResultMsg{key: key, err: err}
	}
}

func (m *Model) updateCategoryCore(category domain.Category) []tea.Cmd {
	refresh := false
	if m.category == category {
		refresh = true
	} else {
		m.category = category
		m.keys = keys.ResolveKeys(m.category, m.viewMode)
		m.sortColumn = common.NameCol
		m.sortAsc = true
		m.showFaulty = false
	}

	// Dispatch table for category handlers
	type handlerFn func(*Model, bool, int) tea.Cmd
	handlers := map[domain.Category]handlerFn{
		domain.BaseModel:                       func(m *Model, _ bool, gen int) tea.Cmd { return m.handleBaseModelCategory(gen) },
		domain.GpuPool:                         func(m *Model, refresh bool, gen int) tea.Cmd { return m.handleGpuPoolCategory(refresh, gen) },
		domain.GpuNode:                         func(m *Model, refresh bool, gen int) tea.Cmd { return m.handleGpuNodeCategory(refresh, gen) },
		domain.DedicatedAICluster:              func(m *Model, refresh bool, gen int) tea.Cmd { return m.handleDedicatedAIClusterCategory(refresh, gen) },
		domain.LimitRe

func (m *Model) handleTenancyOverridesGroup(gen int) tea.Cmd {
	if m.dataset == nil ||
		m.dataset.Tenants == nil ||
		m.dataset.LimitTenancyOverrideMap == nil ||
		m.dataset.ConsolePropertyTenancyOverrideMap == nil ||
		m.dataset.PropertyTenancyOverrideMap == nil {
		return loadTenancyOverrideGroupCmd(m.loadCtx, m.loader, m.repoPath, m.environment, gen)
	}
	return nil
}