cli/pkg/ux/output.go

// Copyright (C) 2022-2025, Lux Industries Inc. All rights reserved.
// See the file LICENSE for licensing terms.

package ux

import (
	"fmt"
	"io"
	"os"
	"strings"
	"time"

	"golang.org/x/text/language"
	"golang.org/x/text/message"

	"github.com/luxfi/cli/pkg/route"
	luxlog "github.com/luxfi/log"
	"github.com/luxfi/netrunner/rpcpb"
	"github.com/olekukonko/tablewriter"
)

var Logger *UserLog

type UserLog struct {
	log    luxlog.Logger
	writer io.Writer
}

func NewUserLog(log luxlog.Logger, userwriter io.Writer) {
	if Logger == nil {
		Logger = &UserLog{
			log:    log,
			writer: userwriter,
		}
	}
}

// PrintToUser prints msg directly to stdout (command output)
// Does NOT log to avoid duplication - logs should go to stderr separately
func (ul *UserLog) PrintToUser(msg string, args ...interface{}) {
	formattedMsg := fmt.Sprintf(msg, args...)
	_, _ = fmt.Fprintln(ul.writer, formattedMsg)
}

// Info logs an info message
func (ul *UserLog) Info(msg string, args ...interface{}) {
	formattedMsg := fmt.Sprintf(msg, args...)
	ul.log.Info(formattedMsg)
}

// PrintLineSeparator prints a line separator
func (ul *UserLog) PrintLineSeparator(msg ...string) {
	separator := "=========================================="
	if len(msg) > 0 && msg[0] != "" {
		separator = msg[0]
	}
	_, _ = fmt.Fprintln(ul.writer, separator)
	ul.log.Info(separator)
}

// Error logs an error message
func (ul *UserLog) Error(msg string, args ...interface{}) {
	formattedMsg := fmt.Sprintf(msg, args...)
	ul.log.Error(formattedMsg)
}

// RedXToUser prints a red X error message to the user
func (ul *UserLog) RedXToUser(msg string, args ...interface{}) {
	formattedMsg := fmt.Sprintf("✗ %s", fmt.Sprintf(msg, args...))
	_, _ = fmt.Fprintln(ul.writer, formattedMsg)
	ul.log.Error(formattedMsg)
}

// GreenCheckmarkToUser prints a green checkmark success message to the user
func (ul *UserLog) GreenCheckmarkToUser(msg string, args ...interface{}) {
	formattedMsg := fmt.Sprintf("✓ %s", fmt.Sprintf(msg, args...))
	_, _ = fmt.Fprintln(ul.writer, formattedMsg)
	ul.log.Info(formattedMsg)
}

// PrintError prints a visible error message with ERROR prefix to the user
func (ul *UserLog) PrintError(msg string, args ...interface{}) {
	formattedMsg := fmt.Sprintf(msg, args...)
	errorMsg := fmt.Sprintf("\nERROR: %s\n", formattedMsg)
	_, _ = fmt.Fprintln(ul.writer, errorMsg)
	ul.log.Error(formattedMsg)
}

// PrintWait does some dot printing to entertain the user
func PrintWait(cancel chan struct{}) {
	for {
		select {
		case <-time.After(1 * time.Second):
			fmt.Print(".")
		case <-cancel:
			return
		}
	}
}

// StepTracker tracks progress of multi-step operations with elapsed time
type StepTracker struct {
	stepStart    time.Time
	warnAfter    time.Duration
	warningShown bool
	stepName     string
	ul           *UserLog
}

// NewStepTracker creates a tracker that warns if a step takes longer than warnAfter
func NewStepTracker(ul *UserLog, warnAfter time.Duration) *StepTracker {
	return &StepTracker{
		ul:        ul,
		warnAfter: warnAfter,
	}
}

// Start begins tracking a new step
func (st *StepTracker) Start(stepName string) {
	st.stepStart = time.Now()
	st.stepName = stepName
	st.warningShown = false
	st.ul.PrintToUser("%s...", stepName)
}

// Elapsed returns the elapsed time for the current step
func (st *StepTracker) Elapsed() time.Duration {
	return time.Since(st.stepStart)
}

// CheckWarn prints a warning if the step has taken longer than the threshold
// Returns true if warning was printed
func (st *StepTracker) CheckWarn() bool {
	if st.warningShown {
		return false
	}
	elapsed := st.Elapsed()
	if elapsed > st.warnAfter {
		st.ul.PrintToUser("Warning: %s taking longer than expected (%.1fs)...", st.stepName, elapsed.Seconds())
		st.warningShown = true
		return true
	}
	return false
}

// Complete marks the step as done with success
func (st *StepTracker) Complete(suffix string) {
	elapsed := st.Elapsed()
	if suffix != "" {
		st.ul.GreenCheckmarkToUser("%s (%.1fs) - %s", st.stepName, elapsed.Seconds(), suffix)
	} else {
		st.ul.GreenCheckmarkToUser("%s (%.1fs)", st.stepName, elapsed.Seconds())
	}
}

// CompleteSuccess is shorthand for Complete with "Success" suffix
func (st *StepTracker) CompleteSuccess() {
	st.Complete("Success")
}

// Failed marks the step as failed with an error
func (st *StepTracker) Failed(reason string) {
	elapsed := st.Elapsed()
	st.ul.RedXToUser("%s (%.1fs) - FAILED: %s", st.stepName, elapsed.Seconds(), reason)
}

// PrintTableEndpoints prints the endpoints coming from the healthy call
func PrintTableEndpoints(clusterInfo *rpcpb.ClusterInfo) {
	table := tablewriter.NewWriter(os.Stdout)
	// Note: SetHeader is not available in v1.0.9, use Append for header row

	nodeInfos := map[string]*rpcpb.NodeInfo{}
	for _, nodeInfo := range clusterInfo.NodeInfos {
		nodeInfos[nodeInfo.Name] = nodeInfo
	}
	for _, nodeName := range clusterInfo.NodeNames {
		nodeInfo := nodeInfos[nodeName]
		for blockchainID, chainInfo := range clusterInfo.CustomChains {
			_ = table.Append([]string{
				nodeInfo.Name,
				chainInfo.GetChainName(),
				route.Chain(nodeInfo.GetUri(), blockchainID) + "/rpc",
				route.Chain(nodeInfo.GetUri(), chainInfo.GetChainName()) + "/rpc",
			})
		}
	}
	_ = table.Render()
}

// DefaultTable creates a default table with the given title and headers
func DefaultTable(title string, headers []string) *tablewriter.Table {
	table := tablewriter.NewWriter(os.Stdout)
	// Note: v1.0.9 API doesn't have SetCaption, SetBorder, SetAutoWrapText, SetAlignment
	// These would need to be set via Options during creation or not at all
	return table
}

func ConvertToStringWithThousandSeparator(input uint64) string {
	p := message.NewPrinter(language.English)
	s := p.Sprintf("%d", input)
	return strings.ReplaceAll(s, ",", "_")
}

// NativeChainInfo holds info for pretty-printing a native chain
type NativeChainInfo struct {
	Letter string // P, C, X, Q, A, B, T, Z, G, K, D
	Name   string // Platform, EVM, Exchange, etc.
	Type   string // RPC or WS
	Under  string // what the chain answers under: nothing at its root, "/rpc", "/ws"
}

// Address is where this chain answers on the node at uri.
func (c NativeChainInfo) Address(uri string) string {
	return route.Chain(uri, c.Letter) + c.Under
}

// GetNativeChains returns all native chain definitions for RPC display. P and
// X answer at the chain's root; the EVM chains answer under /rpc.
func GetNativeChains() []NativeChainInfo {
	return []NativeChainInfo{
		{Letter: "P", Name: "Platform", Type: "RPC"},
		{Letter: "C", Name: "EVM", Type: "RPC", Under: "/rpc"},
		{Letter: "C", Name: "EVM", Type: "WS", Under: "/ws"},
		{Letter: "X", Name: "Exchange", Type: "RPC"},
		{Letter: "Q", Name: "Quantum", Type: "RPC", Under: "/rpc"},
		{Letter: "A", Name: "AI", Type: "RPC", Under: "/rpc"},
		{Letter: "B", Name: "Bridge", Type: "RPC", Under: "/rpc"},
		{Letter: "T", Name: "Threshold", Type: "RPC", Under: "/rpc"},
		{Letter: "Z", Name: "ZK", Type: "RPC", Under: "/rpc"},
		{Letter: "G", Name: "Graph", Type: "RPC", Under: "/rpc"},
		{Letter: "K", Name: "KMS", Type: "RPC", Under: "/rpc"},
		{Letter: "D", Name: "DEX", Type: "RPC", Under: "/rpc"},
	}
}

// PrintCompactChainEndpoints prints chain endpoints in a compact format.
//
// Labels and addresses are measured rather than hand-padded, so the box stays
// square whatever the route segment is. It used to be padded by hand against a
// segment two characters long, and would have come out ragged the moment that
// changed.
func PrintCompactChainEndpoints(portBase int) {
	chains := GetNativeChains()

	// A letter with more than one row needs its type to tell them apart.
	rows := map[string]int{}
	for _, c := range chains {
		rows[c.Letter]++
	}

	labels := make([]string, len(chains))
	addresses := make([]string, len(chains))
	labelWidth, addressWidth := 0, 0
	for i, c := range chains {
		label := fmt.Sprintf("%s-Chain (%s)", c.Letter, c.Name)
		if rows[c.Letter] > 1 {
			label += " " + c.Type
		}
		scheme := "http"
		if c.Type == "WS" {
			scheme = "ws"
		}
		labels[i] = label + ":"
		addresses[i] = c.Address(fmt.Sprintf("%s://localhost:%d", scheme, portBase))
		labelWidth = max(labelWidth, len(labels[i]))
		addressWidth = max(addressWidth, len(addresses[i]))
	}

	Logger.PrintToUser("\n📡 Native Chain RPC Endpoints:")
	Logger.PrintToUser("  ┌%s┐", strings.Repeat("─", labelWidth+addressWidth+3))
	for i := range chains {
		Logger.PrintToUser("  │ %-*s %-*s │", labelWidth, labels[i], addressWidth, addresses[i])
	}
	Logger.PrintToUser("  └%s┘", strings.Repeat("─", labelWidth+addressWidth+3))
	Logger.PrintToUser("\n🔧 Utility Endpoints:")
	Logger.PrintToUser("  Health:  %s", route.Health(fmt.Sprintf("http://localhost:%d", portBase)))
	Logger.PrintToUser("  Info:    http://localhost:%d/v1/info", portBase)
	Logger.PrintToUser("  Admin:   http://localhost:%d/v1/admin", portBase)
}

// ValidatorKeyInfo holds derived key info for a validator
type ValidatorKeyInfo struct {
	Index      int
	NodeID     string
	PChainAddr string
	XChainAddr string
	CChainAddr string // Ethereum-style 0x address
	BLSPubKey  string // Hex-encoded BLS public key
}

// PrintValidatorKeys prints validator key information in a formatted table
func PrintValidatorKeys(validators []ValidatorKeyInfo, networkHRP string) {
	if len(validators) == 0 {
		return
	}

	Logger.PrintToUser("\n🔑 Validator Keys (derived from MNEMONIC):")
	Logger.PrintToUser("  ╔═══════╤════════════════════════════════════════════════════════════════╗")
	Logger.PrintToUser("  ║  #    │ Validator Details                                              ║")
	Logger.PrintToUser("  ╠═══════╪════════════════════════════════════════════════════════════════╣")

	for _, v := range validators {
		Logger.PrintToUser("  ║  %d    │ NodeID:  %s", v.Index, v.NodeID)
		Logger.PrintToUser("  ║       │ P-Chain: %s", v.PChainAddr)
		Logger.PrintToUser("  ║       │ X-Chain: %s", v.XChainAddr)
		Logger.PrintToUser("  ║       │ C-Chain: %s", v.CChainAddr)
		if v.Index < len(validators)-1 {
			Logger.PrintToUser("  ╟───────┼────────────────────────────────────────────────────────────────╢")
		}
	}
	Logger.PrintToUser("  ╚═══════╧════════════════════════════════════════════════════════════════╝")
}

// PrintValidatorKeysCompact prints validator keys in a compact single-line format
func PrintValidatorKeysCompact(validators []ValidatorKeyInfo) {
	if len(validators) == 0 {
		return
	}

	Logger.PrintToUser("\n🔑 Validator Keys (from MNEMONIC):")
	for _, v := range validators {
		Logger.PrintToUser("  [%d] %s | C: %s", v.Index, v.NodeID, v.CChainAddr)
	}
}