main.go

package main

import (
	"fmt"
	"log/slog"
	"math/rand"
	"net/http"
	_ "net/http/pprof" // Import pprof HTTP handlers
	"os"
	"runtime"
	"strconv"
	"sync"
	"time"

	hosthttp "github.com/Bofry/host-http"
	"github.com/Bofry/host-http/response"
)

// Configuration for stress testing scenarios
type Config struct {
	EnablePprof     bool
	PprofPort       string
	SimulateLoad    bool
	MemoryIntensive bool
	CPUIntensive    bool
}

// MemoryLeakRequest demonstrates memory-intensive operations for profiling
type MemoryLeakRequest struct {
	data [][]byte
	mu   sync.Mutex
}

func (r *MemoryLeakRequest) Get(w http.ResponseWriter, req *http.Request) {
	sizeParam := req.URL.Query().Get("size")
	size := 1024 // Default 1KB
	if s, err := strconv.Atoi(sizeParam); err == nil && s > 0 {
		size = s
	}

	// Allocate memory that may not be properly released
	r.mu.Lock()
	r.data = append(r.data, make([]byte, size*1024)) // size in KB
	currentSize := len(r.data)
	r.mu.Unlock()

	// Force garbage collection to see the effect
	var m runtime.MemStats
	runtime.ReadMemStats(&m)

	response.JSON.Success(w, map[string]any{
		"message":        "Memory allocated",
		"allocated_kb":   size,
		"total_chunks":   currentSize,
		"heap_alloc_mb":  bToMb(m.HeapAlloc),
		"heap_sys_mb":    bToMb(m.HeapSys),
		"gc_runs":        m.NumGC,
		"advice":         "Use 'go tool pprof http://localhost:6060/debug/pprof/heap' to analyze memory usage",
	})
}

func (r *MemoryLeakRequest) Delete(w http.ResponseWriter, req *http.Request) {
	r.mu.Lock()
	r.data = nil // Clear allocated memory
	r.mu.Unlock()

	runtime.GC() // Force garbage collection

	var m runtime.MemStats
	runtime.ReadMemStats(&m)

	response.JSON.Success(w, map[string]any{
		"message":       "Memory cleared",
		"heap_alloc_mb": bToMb(m.HeapAlloc),
		"heap_sys_mb":   bToMb(m.HeapSys),
		"gc_runs":       m.NumGC,
	})
}

// CPUIntensiveRequest demonstrates CPU-intensive operations
type CPUIntensiveRequest struct{}

func (r *CPUIntensiveRequest) Get(w http.ResponseWriter, req *http.Request) {
	durationParam := req.URL.Query().Get("duration")
	duration := 100 * time.Millisecond // Default duration
	if d, err := time.ParseDuration(durationParam); err == nil {
		duration = d
	}

	start := time.Now()

	// CPU-intensive calculation
	result := r.calculatePrimes(duration)

	elapsed := time.Since(start)

	response.JSON.Success(w, map[string]any{
		"message":           "CPU intensive task completed",
		"primes_calculated": result,
		"duration_ms":       elapsed.Milliseconds(),
		"requested_ms":      duration.Milliseconds(),
		"advice":            "Use 'go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30' to analyze CPU usage",
	})
}

func (r *CPUIntensiveRequest) calculatePrimes(duration time.Duration) int {
	start := time.Now()
	count := 0
	num := 2

	for time.Since(start) < duration {
		if r.isPrime(num) {
			count++
		}
		num++
	}
	return count
}

func (r *CPUIntensiveRequest) isPrime(n int) bool {
	if n < 2 {
		return false
	}
	for i := 2; i*i <= n; i++ {
		if n%i == 0 {
			return false
		}
	}
	return true
}

// GoroutineLeakRequest demonstrates goroutine management issues
type GoroutineLeakRequest struct {
	workers []chan struct{}
	mu      sync.Mutex
}

func (r *GoroutineLeakRequest) Get(w http.ResponseWriter, req *http.Request) {
	countParam := req.URL.Query().Get("count")
	count := 10 // Default goroutine count
	if c, err := strconv.Atoi(countParam); err == nil && c > 0 {
		count = c
	}

	r.mu.Lock()
	// Start goroutines that might leak
	for i := 0; i < count; i++ {
		stop := make(chan struct{})
		r.workers = append(r.workers, stop)

		go func(id int, stop chan struct{}) {
			ticker := time.NewTicker(100 * time.Millisecond)
			defer ticker.Stop()

			for {
				select {
				case <-stop:
					return
				case <-ticker.C:
					// Simulate work
					_ = rand.Intn(1000)
				}
			}
		}(i, stop)
	}
	totalWorkers := len(r.workers)
	r.mu.Unlock()

	response.JSON.Success(w, map[string]any{
		"message":         "Goroutines started",
		"started_count":   count,
		"total_workers":   totalWorkers,
		"goroutines":      runtime.NumGoroutine(),
		"advice":          "Use 'go tool pprof http://localhost:6060/debug/pprof/goroutine' to analyze goroutine usage",
	})
}

func (r *GoroutineLeakRequest) Delete(w http.ResponseWriter, req *http.Request) {
	r.mu.Lock()
	// Stop all goroutines
	for _, stop := range r.workers {
		close(stop)
	}
	r.workers = nil
	r.mu.Unlock()

	// Give time for goroutines to cleanup
	time.Sleep(200 * time.Millisecond)

	response.JSON.Success(w, map[string]any{
		"message":    "Goroutines stopped",
		"goroutines": runtime.NumGoroutine(),
	})
}

// BlockingRequest demonstrates blocking operations
type BlockingRequest struct{}

func (r *BlockingRequest) Get(w http.ResponseWriter, req *http.Request) {
	durationParam := req.URL.Query().Get("duration")
	duration := 1 * time.Second // Default duration
	if d, err := time.ParseDuration(durationParam); err == nil {
		duration = d
	}

	start := time.Now()

	// Simulate blocking I/O
	time.Sleep(duration)

	elapsed := time.Since(start)

	response.JSON.Success(w, map[string]any{
		"message":      "Blocking operation completed",
		"duration_ms":  elapsed.Milliseconds(),
		"advice":       "Use 'go tool pprof http://localhost:6060/debug/pprof/block' to analyze blocking operations",
	})
}

// ProfileStatsRequest provides runtime statistics
type ProfileStatsRequest struct{}

func (r *ProfileStatsRequest) Get(w http.ResponseWriter, req *http.Request) {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)

	response.JSON.Success(w, map[string]any{
		"timestamp":        time.Now(),
		"memory_stats": map[string]any{
			"heap_alloc_mb":     bToMb(m.HeapAlloc),
			"heap_sys_mb":       bToMb(m.HeapSys),
			"heap_objects":      m.HeapObjects,
			"gc_runs":           m.NumGC,
			"gc_pause_total_ns": m.PauseTotalNs,
		},
		"runtime_stats": map[string]any{
			"goroutines":     runtime.NumGoroutine(),
			"cpu_count":      runtime.NumCPU(),
			"gomaxprocs":     runtime.GOMAXPROCS(0),
		},
		"pprof_endpoints": map[string]string{
			"heap":         "http://localhost:6060/debug/pprof/heap",
			"profile":      "http://localhost:6060/debug/pprof/profile?seconds=30",
			"goroutine":    "http://localhost:6060/debug/pprof/goroutine",
			"block":        "http://localhost:6060/debug/pprof/block",
			"mutex":        "http://localhost:6060/debug/pprof/mutex",
			"allocs":       "http://localhost:6060/debug/pprof/allocs",
		},
		"analysis_commands": map[string]string{
			"heap_analysis":      "go tool pprof http://localhost:6060/debug/pprof/heap",
			"cpu_profile":        "go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30",
			"goroutine_analysis": "go tool pprof http://localhost:6060/debug/pprof/goroutine",
			"blocking_analysis":  "go tool pprof http://localhost:6060/debug/pprof/block",
		},
	})
}

// RequestManager defines all routes
type RequestManager struct {
	*MemoryLeakRequest     `url:"/memory"`
	*CPUIntensiveRequest   `url:"/cpu"`
	*GoroutineLeakRequest  `url:"/goroutines"`
	*BlockingRequest       `url:"/blocking"`
	*ProfileStatsRequest   `url:"/stats"`
}

// App with service provider
type App struct{}

func main() {
	// Configuration
	config := &Config{
		EnablePprof:     getEnvBool("ENABLE_PPROF", true),
		PprofPort:       getEnv("PPROF_PORT", "6060"),
		SimulateLoad:    getEnvBool("SIMULATE_LOAD", false),
		MemoryIntensive: getEnvBool("MEMORY_INTENSIVE", false),
		CPUIntensive:    getEnvBool("CPU_INTENSIVE", false),
	}

	slog.Info("=== host-http Performance Profiling Demo ===")
	slog.Info("This example demonstrates net/http/pprof integration for performance analysis")
	slog.Info("")
	slog.Info("Configuration",
		"pprof_enabled", config.EnablePprof,
		"pprof_port", config.PprofPort,
		"simulate_load", config.SimulateLoad)

	// Start pprof server if enabled
	if config.EnablePprof {
		go func() {
			slog.Info("Starting pprof server", "port", config.PprofPort)
			pprofServer := &http.Server{
				Addr: ":" + config.PprofPort,
				Handler: http.DefaultServeMux, // pprof handlers are registered here
			}
			if err := pprofServer.ListenAndServe(); err != nil {
				slog.Error("pprof server failed", "error", err)
			}
		}()

		slog.Info("pprof endpoints available:")
		slog.Info("  http://localhost:" + config.PprofPort + "/debug/pprof/")
		slog.Info("  http://localhost:" + config.PprofPort + "/debug/pprof/heap")
		slog.Info("  http://localhost:" + config.PprofPort + "/debug/pprof/profile?seconds=30")
		slog.Info("  http://localhost:" + config.PprofPort + "/debug/pprof/goroutine")
		slog.Info("  http://localhost:" + config.PprofPort + "/debug/pprof/block")
		slog.Info("")
	}

	slog.Info("Performance testing endpoints:")
	slog.Info("  GET    /memory?size=1024      - Allocate memory (size in KB)")
	slog.Info("  DELETE /memory               - Free allocated memory")
	slog.Info("  GET    /cpu?duration=100ms    - CPU intensive task")
	slog.Info("  GET    /goroutines?count=10   - Start goroutines")
	slog.Info("  DELETE /goroutines           - Stop goroutines")
	slog.Info("  GET    /blocking?duration=1s  - Blocking operation")
	slog.Info("  GET    /stats                - Runtime statistics and pprof commands")
	slog.Info("")

	if config.EnablePprof {
		slog.Info("Analysis commands:")
		slog.Info("  # Memory analysis")
		slog.Info("  go tool pprof http://localhost:" + config.PprofPort + "/debug/pprof/heap")
		slog.Info("")
		slog.Info("  # CPU profiling (30 seconds)")
		slog.Info("  go tool pprof http://localhost:" + config.PprofPort + "/debug/pprof/profile?seconds=30")
		slog.Info("")
		slog.Info("  # Goroutine analysis")
		slog.Info("  go tool pprof http://localhost:" + config.PprofPort + "/debug/pprof/goroutine")
		slog.Info("")
		slog.Info("  # Blocking analysis")
		slog.Info("  go tool pprof http://localhost:" + config.PprofPort + "/debug/pprof/block")
		slog.Info("")
	}

	// Enable blocking profile
	runtime.SetBlockProfileRate(1)

	// Start background load simulation if requested
	if config.SimulateLoad {
		go simulateBackgroundLoad(config)
	}

	slog.Info("Starting main server on port 8080...")
	slog.Info("===============================================")

	app := &App{}

	// Setup middleware chain
	hosthttp.Startup(app).
		Middlewares(
			hosthttp.UseRequestManager(&RequestManager{}),
			hosthttp.UseLogging(),
			hosthttp.UseErrorHandler(func(w http.ResponseWriter, r *http.Request, err any) {
				slog.Error("Error in request", "method", r.Method, "path", r.URL.Path, "error", err)
				response.JSON.Failure(w, map[string]any{
					"error":     "Internal Server Error",
					"message":   fmt.Sprintf("%v", err),
					"timestamp": time.Now(),
				}, http.StatusInternalServerError)
			}),
		).
		Run()
}

// Helper functions
func bToMb(b uint64) uint64 {
	return b / 1024 / 1024
}

func getEnv(key, defaultValue string) string {
	if value := os.Getenv(key); value != "" {
		return value
	}
	return defaultValue
}

func getEnvBool(key string, defaultValue bool) bool {
	if value := os.Getenv(key); value != "" {
		if b, err := strconv.ParseBool(value); err == nil {
			return b
		}
	}
	return defaultValue
}

func simulateBackgroundLoad(config *Config) {
	slog.Info("Starting background load simulation")

	for {
		if config.MemoryIntensive {
			// Allocate and release memory
			data := make([]byte, 1024*1024) // 1MB
			_ = data
			time.Sleep(500 * time.Millisecond)
		}

		if config.CPUIntensive {
			// CPU intensive calculation
			for i := 0; i < 100000; i++ {
				_ = i * i
			}
		}

		time.Sleep(1 * time.Second)
	}
}