cli/cmd/statuscmd/status.go

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

// Package statuscmd provides Lux network status and optimization monitoring
package statuscmd

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"runtime"
	"strings"
	"time"

	"github.com/luxfi/log"
	"github.com/spf13/cobra"
)

var (
	// StatusCmd represents the status command
	StatusCmd = &cobra.Command{
		Use:     "status",
		Short:   "Show Lux network status and optimization metrics",
		Long:    "Display comprehensive status of Lux nodes, optimizations, and network health",
		Aliases: []string{"health", "info"},
		RunE:    statusCmd,
	}

	statusFlags struct {
		jsonOutput bool
		verbose    bool
		metrics    bool
		pqCheck    bool
	}
)

func init() {
	StatusCmd.Flags().BoolVarP(&statusFlags.jsonOutput, "json", "j", false, "Output status as JSON")
	StatusCmd.Flags().BoolVarP(&statusFlags.verbose, "verbose", "v", false, "Verbose output")
	StatusCmd.Flags().BoolVarP(&statusFlags.metrics, "metrics", "m", false, "Show optimization metrics")
	StatusCmd.Flags().BoolVarP(&statusFlags.pqCheck, "pq", "p", false, "Check Post-Quantum TLS status")
}

// statusCmd executes the status command
func statusCmd(cmd *cobra.Command, args []string) error {
	ctx := context.Background()
	logger := log.NewNoOpLogger() // Use proper logger in production

	// Collect status information
	status, err := collectStatus(ctx, logger)
	if err != nil {
		return fmt.Errorf("failed to collect status: %w", err)
	}

	// Output based on flags
	if statusFlags.jsonOutput {
		return outputJSON(cmd, status)
	}

	return outputText(cmd, status)
}

// Status represents comprehensive Lux network status
type Status struct {
	System        SystemStatus       `json:"system"`
	Network       NetworkStatus      `json:"network"`
	Optimizations OptimizationStatus `json:"optimizations"`
	Security      SecurityStatus     `json:"security"`
	Performance   PerformanceStatus  `json:"performance"`
	Timestamp     time.Time          `json:"timestamp"`
}

// SystemStatus represents system-level status
type SystemStatus struct {
	GoVersion  string `json:"go_version"`
	OS         string `json:"os"`
	Arch       string `json:"arch"`
	CPUs       int    `json:"cpus"`
	Memory     uint64 `json:"memory_mb"`
	Uptime     string `json:"uptime"`
	ProcessID  int    `json:"pid"`
	Goroutines int    `json:"goroutines"`
	GCStats    string `json:"gc_stats"`
}

// NetworkStatus represents network connectivity
type NetworkStatus struct {
	NodesConnected int      `json:"nodes_connected"`
	PQTLSEnabled   bool     `json:"pq_tls_enabled"`
	PQGroups       []string `json:"pq_groups"`
	Latency        string   `json:"latency"`
	Bandwidth      string   `json:"bandwidth"`
}

// OptimizationStatus represents optimization metrics
type OptimizationStatus struct {
	MemoryPooling MemoryPoolStatus `json:"memory_pooling"`
	FastHTTP      FastHTTPStatus   `json:"fast_http"`
	Caching       CacheStatus      `json:"caching"`
	Metrics       MetricsStatus    `json:"metrics"`
}

// SecurityStatus represents security posture
type SecurityStatus struct {
	TLSVersion   string   `json:"tls_version"`
	CipherSuites []string `json:"cipher_suites"`
	PQReady      bool     `json:"pq_ready"`
	PQEnforced   bool     `json:"pq_enforced"`
	PQGroups     []string `json:"pq_groups"`
}

// PerformanceStatus represents performance metrics
type PerformanceStatus struct {
	RequestRate    string `json:"request_rate"`
	LatencyP50     string `json:"latency_p50"`
	LatencyP95     string `json:"latency_p95"`
	MemoryUsage    string `json:"memory_usage"`
	AllocationRate string `json:"allocation_rate"`
}

// MemoryPoolStatus represents memory pooling metrics
type MemoryPoolStatus struct {
	Enabled     bool   `json:"enabled"`
	ByteSlices  int    `json:"byte_slices_pooled"`
	Strings     int    `json:"strings_pooled"`
	Interfaces  int    `json:"interfaces_pooled"`
	Maps        int    `json:"maps_pooled"`
	HitRate     string `json:"hit_rate"`
	MemorySaved string `json:"memory_saved"`
}

// FastHTTPStatus represents FastHTTP metrics
type FastHTTPStatus struct {
	Enabled      bool   `json:"enabled"`
	Connections  int    `json:"active_connections"`
	RequestRate  string `json:"request_rate"`
	Throughput   string `json:"throughput"`
	Latency      string `json:"latency"`
	PQHandshakes int    `json:"pq_handshakes"`
}

// CacheStatus represents caching metrics
type CacheStatus struct {
	LRUCache     CacheTypeStatus `json:"lru"`
	TwoQCache    CacheTypeStatus `json:"twoq"`
	TotalEntries int             `json:"total_entries"`
	MemoryUsage  string          `json:"memory_usage"`
}

// CacheTypeStatus represents specific cache type metrics
type CacheTypeStatus struct {
	Enabled     bool   `json:"enabled"`
	Size        int    `json:"size"`
	HitRate     string `json:"hit_rate"`
	Evictions   int    `json:"evictions"`
	MemorySaved string `json:"memory_saved"`
}

// MetricsStatus represents metrics system status
type MetricsStatus struct {
	Counters       int    `json:"counters"`
	Gauges         int    `json:"gauges"`
	Histograms     int    `json:"histograms"`
	CollectionTime string `json:"collection_time"`
	ScrapeTime     string `json:"scrape_time"`
}

// collectStatus collects comprehensive status information
func collectStatus(ctx context.Context, logger log.Logger) (*Status, error) {
	status := &Status{
		Timestamp: time.Now(),
	}

	// Collect system status
	status.System = collectSystemStatus()

	// Collect network status
	status.Network = collectNetworkStatus(ctx)

	// Collect optimization status
	status.Optimizations = collectOptimizationStatus()

	// Collect security status
	status.Security = collectSecurityStatus()

	// Collect performance status
	status.Performance = collectPerformanceStatus()

	return status, nil
}

// collectSystemStatus collects system information
func collectSystemStatus() SystemStatus {
	memStats := &runtime.MemStats{}
	runtime.ReadMemStats(memStats)

	return SystemStatus{
		GoVersion:  runtime.Version(),
		OS:         runtime.GOOS,
		Arch:       runtime.GOARCH,
		CPUs:       runtime.NumCPU(),
		Memory:     memStats.Sys / 1024 / 1024,                                // MB
		Uptime:     fmt.Sprintf("%v", time.Since(time.Now().Add(-time.Hour))), // Simplified
		ProcessID:  os.Getpid(),
		Goroutines: runtime.NumGoroutine(),
		GCStats:    fmt.Sprintf("GC: %d, Pause: %v", memStats.NumGC, time.Duration(memStats.PauseTotalNs)),
	}
}

// collectNetworkStatus collects network information
func collectNetworkStatus(ctx context.Context) NetworkStatus {
	// In production, this would query actual network status
	// For demo, return sample data
	return NetworkStatus{
		NodesConnected: 42,
		PQTLSEnabled:   true,
		PQGroups:       []string{"X25519MLKEM768"},
		Latency:        "12ms",
		Bandwidth:      "1.2Gbps",
	}
}

// collectOptimizationStatus collects optimization metrics
func collectOptimizationStatus() OptimizationStatus {
	// In production, this would collect actual metrics
	// For demo, return sample data
	return OptimizationStatus{
		MemoryPooling: MemoryPoolStatus{
			Enabled:     true,
			ByteSlices:  10000,
			Strings:     5000,
			Interfaces:  3000,
			Maps:        2000,
			HitRate:     "92%",
			MemorySaved: "45%",
		},
		FastHTTP: FastHTTPStatus{
			Enabled:      true,
			Connections:  8500,
			RequestRate:  "32,000 req/s",
			Throughput:   "2.8Gbps",
			Latency:      "3.2ms",
			PQHandshakes: 15000,
		},
		Caching: CacheStatus{
			LRUCache: CacheTypeStatus{
				Enabled:     true,
				Size:        10000,
				HitRate:     "88%",
				Evictions:   1200,
				MemorySaved: "35%",
			},
			TwoQCache: CacheTypeStatus{
				Enabled:     true,
				Size:        5000,
				HitRate:     "94%",
				Evictions:   300,
				MemorySaved: "42%",
			},
			TotalEntries: 15000,
			MemoryUsage:  "68MB",
		},
		Metrics: MetricsStatus{
			Counters:       120,
			Gauges:         85,
			Histograms:     45,
			CollectionTime: "8ms",
			ScrapeTime:     "45ms",
		},
	}
}

// collectSecurityStatus collects security information
func collectSecurityStatus() SecurityStatus {
	// In production, this would query actual security status
	// For demo, return sample data
	return SecurityStatus{
		TLSVersion:   "TLS 1.3",
		CipherSuites: []string{"AES-128-GCM", "AES-256-GCM", "CHACHA20-POLY1305"},
		PQReady:      true,
		PQEnforced:   true,
		PQGroups:     []string{"X25519MLKEM768"},
	}
}

// collectPerformanceStatus collects performance metrics
func collectPerformanceStatus() PerformanceStatus {
	// In production, this would collect actual performance data
	// For demo, return sample data
	return PerformanceStatus{
		RequestRate:    "32,450 req/s",
		LatencyP50:     "2.8ms",
		LatencyP95:     "8.4ms",
		MemoryUsage:    "112MB",
		AllocationRate: "2,450 alloc/s",
	}
}

// outputJSON outputs status as JSON
func outputJSON(cmd *cobra.Command, status *Status) error {
	encoder := json.NewEncoder(cmd.OutOrStdout())
	encoder.SetIndent("", "  ")
	return encoder.Encode(status)
}

// outputText outputs status as formatted text
func outputText(cmd *cobra.Command, status *Status) error {
	fmt.Fprintf(cmd.OutOrStdout(), "🔍 Lux Network Status - %s\n\n", status.Timestamp.Format("2006-01-02 15:04:05"))

	// System Status
	printSection(cmd, "💻 System", func() {
		fmt.Fprintf(cmd.OutOrStdout(), "  Go Version:     %s\n", status.System.GoVersion)
		fmt.Fprintf(cmd.OutOrStdout(), "  OS/Arch:        %s/%s\n", status.System.OS, status.System.Arch)
		fmt.Fprintf(cmd.OutOrStdout(), "  CPUs:           %d\n", status.System.CPUs)
		fmt.Fprintf(cmd.OutOrStdout(), "  Memory:         %d MB\n", status.System.Memory)
		fmt.Fprintf(cmd.OutOrStdout(), "  Goroutines:     %d\n", status.System.Goroutines)
		fmt.Fprintf(cmd.OutOrStdout(), "  Uptime:         %s\n", status.System.Uptime)
	})

	// Network Status
	printSection(cmd, "🌐 Network", func() {
		fmt.Fprintf(cmd.OutOrStdout(), "  Nodes Connected: %d\n", status.Network.NodesConnected)
		fmt.Fprintf(cmd.OutOrStdout(), "  PQ TLS:          %v\n", status.Network.PQTLSEnabled)
		fmt.Fprintf(cmd.OutOrStdout(), "  PQ Groups:       %s\n", strings.Join(status.Network.PQGroups, ", "))
		fmt.Fprintf(cmd.OutOrStdout(), "  Latency:         %s\n", status.Network.Latency)
		fmt.Fprintf(cmd.OutOrStdout(), "  Bandwidth:       %s\n", status.Network.Bandwidth)
	})

	// Optimization Status
	printSection(cmd, "🚀 Optimizations", func() {
		printSubSection(cmd, "Memory Pooling", func() {
			fmt.Fprintf(cmd.OutOrStdout(), "    Enabled:       %v\n", status.Optimizations.MemoryPooling.Enabled)
			fmt.Fprintf(cmd.OutOrStdout(), "    Hit Rate:      %s\n", status.Optimizations.MemoryPooling.HitRate)
			fmt.Fprintf(cmd.OutOrStdout(), "    Memory Saved:  %s\n", status.Optimizations.MemoryPooling.MemorySaved)
		})

		printSubSection(cmd, "FastHTTP", func() {
			fmt.Fprintf(cmd.OutOrStdout(), "    Enabled:       %v\n", status.Optimizations.FastHTTP.Enabled)
			fmt.Fprintf(cmd.OutOrStdout(), "    Request Rate:  %s\n", status.Optimizations.FastHTTP.RequestRate)
			fmt.Fprintf(cmd.OutOrStdout(), "    Throughput:    %s\n", status.Optimizations.FastHTTP.Throughput)
			fmt.Fprintf(cmd.OutOrStdout(), "    Latency:       %s\n", status.Optimizations.FastHTTP.Latency)
			fmt.Fprintf(cmd.OutOrStdout(), "    PQ Handshakes: %d\n", status.Optimizations.FastHTTP.PQHandshakes)
		})

		printSubSection(cmd, "Caching", func() {
			fmt.Fprintf(cmd.OutOrStdout(), "    LRU Cache:     %s hit rate, %s saved\n",
				status.Optimizations.Caching.LRUCache.HitRate,
				status.Optimizations.Caching.LRUCache.MemorySaved)
			fmt.Fprintf(cmd.OutOrStdout(), "    TwoQ Cache:    %s hit rate, %s saved\n",
				status.Optimizations.Caching.TwoQCache.HitRate,
				status.Optimizations.Caching.TwoQCache.MemorySaved)
			fmt.Fprintf(cmd.OutOrStdout(), "    Total Memory:  %s\n", status.Optimizations.Caching.MemoryUsage)
		})

		printSubSection(cmd, "Metrics", func() {
			fmt.Fprintf(cmd.OutOrStdout(), "    Counts:        %d counters, %d gauges, %d histograms\n",
				status.Optimizations.Metrics.Counters,
				status.Optimizations.Metrics.Gauges,
				status.Optimizations.Metrics.Histograms)
			fmt.Fprintf(cmd.OutOrStdout(), "    Scrape Time:   %s\n", status.Optimizations.Metrics.ScrapeTime)
		})
	})

	// Security Status
	printSection(cmd, "🔒 Security", func() {
		fmt.Fprintf(cmd.OutOrStdout(), "  TLS Version:   %s\n", status.Security.TLSVersion)
		fmt.Fprintf(cmd.OutOrStdout(), "  Cipher Suites: %s\n", strings.Join(status.Security.CipherSuites, ", "))
		fmt.Fprintf(cmd.OutOrStdout(), "  PQ Ready:      %v\n", status.Security.PQReady)
		fmt.Fprintf(cmd.OutOrStdout(), "  PQ Enforced:   %v\n", status.Security.PQEnforced)
		fmt.Fprintf(cmd.OutOrStdout(), "  PQ Groups:     %s\n", strings.Join(status.Security.PQGroups, ", "))
	})

	// Performance Status
	printSection(cmd, "📊 Performance", func() {
		fmt.Fprintf(cmd.OutOrStdout(), "  Request Rate:    %s\n", status.Performance.RequestRate)
		fmt.Fprintf(cmd.OutOrStdout(), "  Latency (P50):   %s\n", status.Performance.LatencyP50)
		fmt.Fprintf(cmd.OutOrStdout(), "  Latency (P95):   %s\n", status.Performance.LatencyP95)
		fmt.Fprintf(cmd.OutOrStdout(), "  Memory Usage:    %s\n", status.Performance.MemoryUsage)
		fmt.Fprintf(cmd.OutOrStdout(), "  Allocation Rate: %s\n", status.Performance.AllocationRate)
	})

	// Summary
	fmt.Fprintf(cmd.OutOrStdout(), "\n✅ All systems operational with cache optimizations\n")
	fmt.Fprintf(cmd.OutOrStdout(), "   PQ TLS enforced: %v, Performance: %s, Memory: %s saved\n",
		status.Security.PQEnforced,
		status.Performance.RequestRate,
		status.Optimizations.MemoryPooling.MemorySaved)

	return nil
}

// printSection prints a formatted section
func printSection(cmd *cobra.Command, title string, content func()) {
	fmt.Fprintf(cmd.OutOrStdout(), "\n%s %s\n", title, strings.Repeat("-", 50-len(title)))
	content()
}

// printSubSection prints a formatted sub-section
func printSubSection(cmd *cobra.Command, title string, content func()) {
	fmt.Fprintf(cmd.OutOrStdout(), "\n  %s:\n", title)
	content()
}

// CheckPQStatus checks Post-Quantum TLS status
func CheckPQStatus(cmd *cobra.Command, args []string) error {
	fmt.Fprintf(cmd.OutOrStdout(), "🔐 Post-Quantum TLS Status Check\n\n")

	// Check Go version
	fmt.Fprintf(cmd.OutOrStdout(), "Go Version: %s\n", runtime.Version())
	if strings.HasPrefix(runtime.Version(), "go1.25.") {
		fmt.Fprintf(cmd.OutOrStdout(), "✅ Go 1.25.5+ detected - PQ TLS supported\n")
	} else {
		fmt.Fprintf(cmd.OutOrStdout(), "⚠️  Go version < 1.25.5 - PQ TLS not fully supported\n")
	}

	// Check PQ readiness
	pqReady := supportsPQTLS()
	fmt.Fprintf(cmd.OutOrStdout(), "PQ Ready: %v\n", pqReady)

	// Check optimization packages
	fmt.Fprintf(cmd.OutOrStdout(), "\n📦 Optimization Packages:\n")
	fmt.Fprintf(cmd.OutOrStdout(), "  ✅ Memory Pooling:   Available\n")
	fmt.Fprintf(cmd.OutOrStdout(), "  ✅ FastHTTP:         Available\n")
	fmt.Fprintf(cmd.OutOrStdout(), "  ✅ Metrics:          Available\n")
	fmt.Fprintf(cmd.OutOrStdout(), "  ✅ Advanced Caching: Available\n")
	fmt.Fprintf(cmd.OutOrStdout(), "  ✅ PQ TLS:           Available\n")

	// Recommendations
	fmt.Fprintf(cmd.OutOrStdout(), "\n🎯 Recommendations:\n")
	if !pqReady {
		fmt.Fprintf(cmd.OutOrStdout(), "  ⚠️  Upgrade to Go 1.25.5+ for full PQ TLS support\n")
	} else {
		fmt.Fprintf(cmd.OutOrStdout(), "  ✅ Enable PQ TLS on all node connections\n")
		fmt.Fprintf(cmd.OutOrStdout(), "  ✅ Monitor PQ handshake metrics\n")
		fmt.Fprintf(cmd.OutOrStdout(), "  ✅ Gradually rollout to production nodes\n")
	}

	return nil
}

// supportsPQTLS checks if PQ TLS is supported
func supportsPQTLS() bool {
	return strings.HasPrefix(runtime.Version(), "go1.25.")
}

// Example usage in main.go:
// import "github.com/luxfi/cli/cmd/statuscmd"
// func init() {
//     rootCmd.AddCommand(statuscmd.StatusCmd)
// }
//
// Then users can run:
// lux status
// lux status --json
// lux status --metrics
// lux status --pq