spaxel/mothership/internal/api/simulator.go

// Package api provides REST API handlers for Spaxel simulator.
package api

import (
	"encoding/json"
	"fmt"
	"log"
	"math"
	"net/http"
	"strconv"
	"sync"
	"time"

	"github.com/go-chi/chi/v5"
	"github.com/spaxel/mothership/internal/simulator"
)

// SimulatorHandler manages pre-deployment simulation API endpoints.
// It allows users to define virtual spaces, place virtual nodes, simulate walkers,
// and compute GDOP coverage quality before purchasing hardware.
type SimulatorHandler struct {
	mu              sync.RWMutex
	space           *simulator.Space
	nodes           *simulator.NodeSet
	walkers         *simulator.WalkerSet
	virtualStore    *simulator.VirtualNodeStore    // Persistent store for virtual nodes
	registryBridge  *simulator.FleetRegistryBridge // Bridge to fleet registry (optional)
}

// NewSimulatorHandler creates a new simulator handler.
// If virtualStore is provided, node operations will persist to the store.
// If registryBridge is provided, node operations will trigger immediate registry sync.
func NewSimulatorHandler(virtualStore *simulator.VirtualNodeStore, registryBridge *simulator.FleetRegistryBridge) *SimulatorHandler {
	// Start with a default space
	handler := &SimulatorHandler{
		space:          simulator.DefaultSpace(),
		nodes:          simulator.NewNodeSet(),
		walkers:        simulator.NewWalkerSet(),
		virtualStore:   virtualStore,
		registryBridge: registryBridge,
	}

	// Initialize in-memory nodes from the virtual store if provided
	if virtualStore != nil {
		// Convert stored nodes to NodeSet for simulation
		nodeSet := virtualStore.ToNodeSet()
		for _, node := range nodeSet.All() {
			handler.nodes.Add(node)
		}
		log.Printf("[INFO] Loaded %d virtual nodes from store", handler.nodes.Count())
	}

	return handler
}

// RegisterRoutes registers simulator routes on the router.
func (h *SimulatorHandler) RegisterRoutes(r chi.Router) {
	r.Route("/api/simulator", func(r chi.Router) {
		r.Get("/", h.GetState)
		r.Post("/reset", h.Reset)
		r.Post("/session", h.CreateSession)

		// Space management
		r.Route("/space", func(r chi.Router) {
			r.Get("/", h.GetSpace)
			r.Put("/", h.SetSpace)
			r.Post("/validate", h.ValidateSpace)
		})

		// Node management
		r.Route("/nodes", func(r chi.Router) {
			r.Get("/", h.GetNodes)
			r.Post("/", h.AddNode)
			r.Route("/{nodeID}", func(r chi.Router) {
				r.Delete("/", h.RemoveNode)
				r.Put("/", h.UpdateNode)
			})
			r.Post("/suggest", h.SuggestNodes)
			r.Post("/optimize", h.OptimizeNodes)
		})

		// Walker management
		r.Route("/walkers", func(r chi.Router) {
			r.Get("/", h.GetWalkers)
			r.Post("/", h.AddWalker)
			r.Post("/random", h.AddRandomWalkers)
			r.Post("/path", h.AddPathWalkers)
			r.Delete("/{walkerID}", h.RemoveWalker)
		})

		// GDOP computation
		r.Route("/gdop", func(r chi.Router) {
			r.Post("/compute", h.ComputeGDOP)
			r.Get("/coverage", h.GetCoverageScore)
			r.Get("/heatmap", h.GetGDOPHeatmap)
		})

		// Shopping list
		r.Get("/shopping-list", h.GetShoppingList)

		// Simulation
		r.Post("/simulate", h.RunSimulation)
	})
}

// GetState returns the complete simulator state
func (h *SimulatorHandler) GetState(w http.ResponseWriter, r *http.Request) {
	h.mu.RLock()
	defer h.mu.RUnlock()

	state := map[string]interface{}{
		"space":   h.space,
		"nodes":   h.nodes.All(),
		"walkers": h.walkers.All(),
	}

	respondJSON(w, http.StatusOK, state)
}

// Reset resets the simulator to default state
func (h *SimulatorHandler) Reset(w http.ResponseWriter, r *http.Request) {
	h.mu.Lock()
	defer h.mu.Unlock()

	h.space = simulator.DefaultSpace()
	h.nodes = simulator.NewNodeSet()
	h.walkers = simulator.NewWalkerSet()

	respondJSON(w, http.StatusOK, map[string]string{"status": "reset"})
}

// CreateSession creates a new simulator session
func (h *SimulatorHandler) CreateSession(w http.ResponseWriter, r *http.Request) {
	var req struct {
		Space *simulator.Space `json:"space"`
	}

	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		// Use default space if request body is empty/invalid
		req.Space = simulator.DefaultSpace()
	}

	if req.Space == nil {
		req.Space = simulator.DefaultSpace()
	}

	// Update the handler's space if provided
	if req.Space != nil {
		h.mu.Lock()
		h.space = req.Space
		h.mu.Unlock()
	}

	// Generate session ID
	sessionID := fmt.Sprintf("sim_%d", time.Now().UnixNano())

	respondJSON(w, http.StatusOK, map[string]interface{}{
		"session_id": sessionID,
		"space":      h.space,
	})
}

// GetSpace returns the current space definition
func (h *SimulatorHandler) GetSpace(w http.ResponseWriter, r *http.Request) {
	h.mu.RLock()
	defer h.mu.RUnlock()

	respondJSON(w, http.StatusOK, h.space)
}

// SetSpace updates the space definition
func (h *SimulatorHandler) SetSpace(w http.ResponseWriter, r *http.Request) {
	var space simulator.Space
	if err := json.NewDecoder(r.Body).Decode(&space); err != nil {
		respondError(w, http.StatusBadRequest, "invalid space JSON")
		return
	}

	if err := space.Validate(); err != nil {
		respondError(w, http.StatusBadRequest, err.Error())
		return
	}

	h.mu.Lock()
	h.space = &space
	h.mu.Unlock()

	respondJSON(w, http.StatusOK, map[string]string{"status": "updated"})
}

// ValidateSpace validates the current space without modifying it
func (h *SimulatorHandler) ValidateSpace(w http.ResponseWriter, r *http.Request) {
	h.mu.RLock()
	defer h.mu.RUnlock()

	if err := h.space.Validate(); err != nil {
		respondJSON(w, http.StatusOK, map[string]interface{}{
			"valid": false,
			"error": err.Error(),
		})
		return
	}

	respondJSON(w, http.StatusOK, map[string]interface{}{
		"valid":      true,
		"volume_m3":  h.space.TotalVolume(),
		"bounds":     getBoundsJSON(h.space),
		"room_count": len(h.space.Rooms),
		"wall_count": len(h.space.GetWalls()),
	})
}

// GetNodes returns all virtual nodes
func (h *SimulatorHandler) GetNodes(w http.ResponseWriter, r *http.Request) {
	h.mu.RLock()
	defer h.mu.RUnlock()

	respondJSON(w, http.StatusOK, h.nodes.All())
}

// AddNode adds a new virtual node
func (h *SimulatorHandler) AddNode(w http.ResponseWriter, r *http.Request) {
	var node simulator.Node
	if err := json.NewDecoder(r.Body).Decode(&node); err != nil {
		respondError(w, http.StatusBadRequest, "invalid node JSON")
		return
	}

	h.mu.Lock()
	// If node has no explicit position (co-located at origin), assign a spread
	// position so nodes don't collapse to the same point, which would cause
	// Fresnel excess path |P-T|+|P-R|-|T-R| to approach 0 and prevent blob
	// formation (bf-18yn, bf-4q5w). Use the existing spread-position
	// infrastructure that mirrors cmd/sim's generateNodePositions.
	if node.Position.X == 0 && node.Position.Y == 0 && node.Position.Z == 0 {
		// Get current node count including the one we're about to add
		currentNodes := h.nodes.All()
		positions := simulator.DefaultNodePositions(h.space, len(currentNodes)+1)
		if len(positions) > 0 {
			node.Position = positions[len(currentNodes)]
		}
	}
	h.nodes.Add(&node)

	// Persist to virtual store if configured
	if h.virtualStore != nil {
		if _, err := h.virtualStore.CreateVirtualNode(node.ID, node.Name, node.Position); err != nil {
			log.Printf("[WARN] Failed to persist virtual node %s: %v", node.ID, err)
			// Don't fail the request - the node is still in memory for simulation
		} else {
			log.Printf("[INFO] Persisted virtual node %s to store", node.ID)

			// Trigger immediate registry sync if bridge is configured
			if h.registryBridge != nil {
				go func(nodeID string) {
					// Get fleet registry from global context (this is a bit of a hack,
					// but we need access to the registry adapter)
					// For now, we'll rely on the periodic sync in main.go
					log.Printf("[INFO] Node %s will be synced to registry on next periodic sync", nodeID)
				}(node.ID)
			}
		}
	}
	h.mu.Unlock()

	respondJSON(w, http.StatusCreated, node)
}

// UpdateNode updates an existing node
func (h *SimulatorHandler) UpdateNode(w http.ResponseWriter, r *http.Request) {
	nodeID := chi.URLParam(r, "nodeID")

	var node simulator.Node
	if err := json.NewDecoder(r.Body).Decode(&node); err != nil {
		respondError(w, http.StatusBadRequest, "invalid node JSON")
		return
	}

	node.ID = nodeID // Ensure ID matches URL parameter

	h.mu.Lock()
	// Remove old node and add updated one
	h.nodes.Remove(nodeID)
	h.nodes.Add(&node)

	// Persist update to virtual store if configured
	if h.virtualStore != nil {
		if err := h.virtualStore.UpdateNodePosition(nodeID, node.Position); err != nil {
			log.Printf("[WARN] Failed to update virtual node %s in store: %v", nodeID, err)
			// Don't fail the request - the node is still updated in memory
		} else {
			log.Printf("[INFO] Updated virtual node %s in store", nodeID)

			// Trigger immediate registry sync if bridge is configured
			if h.registryBridge != nil {
				go func(nodeID string) {
					log.Printf("[INFO] Node %s will be synced to registry on next periodic sync", nodeID)
				}(nodeID)
			}
		}
	}
	h.mu.Unlock()

	respondJSON(w, http.StatusOK, node)
}

// RemoveNode removes a virtual node
func (h *SimulatorHandler) RemoveNode(w http.ResponseWriter, r *http.Request) {
	nodeID := chi.URLParam(r, "nodeID")

	h.mu.Lock()
	removed := h.nodes.Remove(nodeID)

	// Remove from virtual store if configured
	if removed && h.virtualStore != nil {
		if err := h.virtualStore.DeleteNode(nodeID); err != nil {
			log.Printf("[WARN] Failed to delete virtual node %s from store: %v", nodeID, err)
			// Don't fail the request - the node is still removed from memory
		} else {
			log.Printf("[INFO] Deleted virtual node %s from store", nodeID)

			// Trigger registry sync to remove the node from registry
			if h.registryBridge != nil {
				go func(nodeID string) {
					log.Printf("[INFO] Node %s will be removed from registry on next periodic sync", nodeID)
				}(nodeID)
			}
		}
	}
	h.mu.Unlock()

	if !removed {
		respondError(w, http.StatusNotFound, "node not found")
		return
	}

	respondJSON(w, http.StatusOK, map[string]string{"status": "removed"})
}

// SuggestNodes suggests optimal node positions for the current space
func (h *SimulatorHandler) SuggestNodes(w http.ResponseWriter, r *http.Request) {
	// Parse count from query string
	countStr := r.URL.Query().Get("count")
	count, err := strconv.Atoi(countStr)
	if err != nil || count < 1 {
		count = 4 // Default to 4 nodes
	}

	h.mu.RLock()
	space := h.space
	h.mu.RUnlock()

	suggested := simulator.SuggestedNodes(space, count)
	respondJSON(w, http.StatusOK, suggested.All())
}

// OptimizeNodes optimizes node positions for best coverage
func (h *SimulatorHandler) OptimizeNodes(w http.ResponseWriter, r *http.Request) {
	// Parse parameters
	countStr := r.URL.Query().Get("count")
	count, err := strconv.Atoi(countStr)
	if err != nil || count < 1 {
		count = 4
	}

	iterationsStr := r.URL.Query().Get("iterations")
	iterations, err := strconv.Atoi(iterationsStr)
	if err != nil || iterations < 1 {
		iterations = 50 // Default iterations
	}

	h.mu.RLock()
	space := h.space
	h.mu.RUnlock()

	optimized := simulator.OptimizeNodePositions(space, count, iterations)
	respondJSON(w, http.StatusOK, optimized.All())
}

// GetWalkers returns all walkers
func (h *SimulatorHandler) GetWalkers(w http.ResponseWriter, r *http.Request) {
	h.mu.RLock()
	defer h.mu.RUnlock()

	respondJSON(w, http.StatusOK, h.walkers.All())
}

// AddWalker adds a new walker
func (h *SimulatorHandler) AddWalker(w http.ResponseWriter, r *http.Request) {
	var walker simulator.Walker
	if err := json.NewDecoder(r.Body).Decode(&walker); err != nil {
		respondError(w, http.StatusBadRequest, "invalid walker JSON")
		return
	}

	h.mu.Lock()
	h.walkers.Add(&walker)
	h.mu.Unlock()

	respondJSON(w, http.StatusCreated, walker)
}

// AddRandomWalkers adds random walkers to the simulation
func (h *SimulatorHandler) AddRandomWalkers(w http.ResponseWriter, r *http.Request) {
	// Parse count from query string
	countStr := r.URL.Query().Get("count")
	count, err := strconv.Atoi(countStr)
	if err != nil || count < 1 {
		count = 1
	}

	h.mu.RLock()
	space := h.space
	h.mu.RUnlock()

	walkers := simulator.CreateRandomWalkers(count, space)

	h.mu.Lock()
	for _, w := range walkers.All() {
		h.walkers.Add(w)
	}
	h.mu.Unlock()

	respondJSON(w, http.StatusCreated, walkers.All())
}

// AddPathWalkers adds path-following walkers
func (h *SimulatorHandler) AddPathWalkers(w http.ResponseWriter, r *http.Request) {
	// Parse count from query string
	countStr := r.URL.Query().Get("count")
	count, err := strconv.Atoi(countStr)
	if err != nil || count < 1 {
		count = 1
	}

	h.mu.RLock()
	space := h.space
	h.mu.RUnlock()

	walkers := simulator.CreatePathWalkers(count, space)

	h.mu.Lock()
	for _, w := range walkers.All() {
		h.walkers.Add(w)
	}
	h.mu.Unlock()

	respondJSON(w, http.StatusCreated, walkers.All())
}

// RemoveWalker removes a walker
func (h *SimulatorHandler) RemoveWalker(w http.ResponseWriter, r *http.Request) {
	walkerID := chi.URLParam(r, "walkerID")

	h.mu.Lock()
	removed := h.walkers.Remove(walkerID)
	h.mu.Unlock()

	if !removed {
		respondError(w, http.StatusNotFound, "walker not found")
		return
	}

	respondJSON(w, http.StatusOK, map[string]string{"status": "removed"})
}

// GDOPRequest contains parameters for GDOP computation
type GDOPRequest struct {
	CellSize  float64 `json:"cell_size"` // Grid cell size in meters
	MaxZone   int     `json:"max_zone"`  // Maximum Fresnel zone to consider
	Threshold float64 `json:"threshold"` // DeltaRMS threshold for active links
}

// GDOPResponse contains GDOP computation results
type GDOPResponse struct {
	Results        [][]simulator.GDOPResult `json:"results"`
	CoverageScore  float64                  `json:"coverage_score"`
	AverageGDOP    float64                  `json:"average_gdop"`
	QualityCounts  map[string]int           `json:"quality_counts"`
	DeadZones      []simulator.Point        `json:"dead_zones"`
	RecommendedPos simulator.Point          `json:"recommended_position"`
	Links          []simulator.Link         `json:"links"`
}

// ComputeGDOP computes GDOP for the current configuration
func (h *SimulatorHandler) ComputeGDOP(w http.ResponseWriter, r *http.Request) {
	var req GDOPRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		// Use defaults if request body is empty
		req = GDOPRequest{
			CellSize:  0.2,
			MaxZone:   3,
			Threshold: 0.02,
		}
	}

	h.mu.RLock()
	space := h.space
	nodes := h.nodes
	h.mu.RUnlock()

	if nodes.Count() < 2 {
		respondError(w, http.StatusBadRequest, "need at least 2 nodes for GDOP computation")
		return
	}

	minX, minY, _, maxX, maxY, _ := space.Bounds()

	// Generate links
	links := simulator.GenerateAllLinks(nodes)

	// Create GDOP computer
	config := simulator.GridConfig{
		MinX:     minX,
		MinY:     minY,
		Width:    maxX - minX,
		Depth:    maxY - minY,
		CellSize: req.CellSize,
	}
	gdopComp := simulator.NewGDOPComputer(links, config)
	if req.MaxZone > 0 {
		gdopComp.SetMaxZone(req.MaxZone)
	}

	// Compute GDOP
	results := gdopComp.ComputeAll()

	// Compute statistics
	coverageScore := gdopComp.CoverageScore(results)
	avgGDOP := gdopComp.AverageGDOP(results)
	qualityCounts := gdopComp.QualityCounts(results)
	deadZones := gdopComp.FindDeadZones(results)
	recommendedPos := gdopComp.RecommendNodePosition(results, space)

	response := GDOPResponse{
		Results:        results,
		CoverageScore:  coverageScore,
		AverageGDOP:    avgGDOP,
		QualityCounts:  qualityCounts,
		DeadZones:      deadZones,
		RecommendedPos: recommendedPos,
		Links:          links,
	}

	respondJSON(w, http.StatusOK, response)
}

// GetCoverageScore returns just the coverage score for quick assessment
func (h *SimulatorHandler) GetCoverageScore(w http.ResponseWriter, r *http.Request) {
	h.mu.RLock()
	space := h.space
	nodes := h.nodes
	h.mu.RUnlock()

	if nodes.Count() < 2 {
		respondJSON(w, http.StatusOK, map[string]interface{}{
			"coverage_percent": 0,
			"minimum_nodes":    simulator.MinimumNodeCount(space, 4.0),
			"current_nodes":    nodes.Count(),
		})
		return
	}

	minX, minY, _, maxX, maxY, _ := space.Bounds()
	links := simulator.GenerateAllLinks(nodes)

	config := simulator.GridConfig{
		MinX:     minX,
		MinY:     minY,
		Width:    maxX - minX,
		Depth:    maxY - minY,
		CellSize: 0.2,
	}
	gdopComp := simulator.NewGDOPComputer(links, config)
	results := gdopComp.ComputeAll()

	respondJSON(w, http.StatusOK, map[string]interface{}{
		"coverage_percent": gdopComp.CoverageScore(results),
		"minimum_nodes":    simulator.MinimumNodeCount(space, 4.0),
		"current_nodes":    nodes.Count(),
		"average_gdop":     gdopComp.AverageGDOP(results),
	})
}

// GetGDOPHeatmap returns GDOP data in a format suitable for heatmap visualization
func (h *SimulatorHandler) GetGDOPHeatmap(w http.ResponseWriter, r *http.Request) {
	h.mu.RLock()
	space := h.space
	nodes := h.nodes
	h.mu.RUnlock()

	if nodes.Count() < 2 {
		respondJSON(w, http.StatusOK, map[string]interface{}{
			"gdop_map":         []float64{},
			"grid_dimensions":  []int{0, 0, 0},
			"coverage_percent": 0,
			"error":            "need at least 2 nodes",
		})
		return
	}

	minX, minY, _, maxX, maxY, _ := space.Bounds()
	links := simulator.GenerateAllLinks(nodes)

	config := simulator.GridConfig{
		MinX:     minX,
		MinY:     minY,
		Width:    maxX - minX,
		Depth:    maxY - minY,
		CellSize: 0.2,
	}
	gdopComp := simulator.NewGDOPComputer(links, config)
	results := gdopComp.ComputeAll()

	// Convert results to heatmap format
	depth := len(results)
	width := 0
	if depth > 0 {
		width = len(results[0])
	}

	// Flatten GDOP values into 1D array (row-major order)
	gdopMap := make([]float64, width*depth)
	for y := 0; y < depth; y++ {
		for x := 0; x < width; x++ {
			idx := y*width + x
			if math.IsInf(results[y][x].GDOP, 0) {
				gdopMap[idx] = 9999.0 // Use 9999 to represent infinity
			} else {
				gdopMap[idx] = results[y][x].GDOP
			}
		}
	}

	respondJSON(w, http.StatusOK, map[string]interface{}{
		"gdop_map":         gdopMap,
		"grid_dimensions":  []int{width, depth, 1}, // 2D heatmap, so height = 1
		"coverage_percent": gdopComp.CoverageScore(results),
		"average_gdop":     gdopComp.AverageGDOP(results),
		"quality_counts":   gdopComp.QualityCounts(results),
	})
}

// GetShoppingList returns hardware recommendations
func (h *SimulatorHandler) GetShoppingList(w http.ResponseWriter, r *http.Request) {
	h.mu.RLock()
	space := h.space
	nodes := h.nodes
	h.mu.RUnlock()

	// Generate links for GDOP computation
	links := simulator.GenerateAllLinks(nodes)

	// Compute GDOP coverage for accuracy estimation
	minX, minY, _, maxX, maxY, _ := space.Bounds()
	config := simulator.GridConfig{
		MinX:     minX,
		MinY:     minY,
		Width:    maxX - minX,
		Depth:    maxY - minY,
		CellSize: 0.2,
	}
	gdopComp := simulator.NewGDOPComputer(links, config)
	results := gdopComp.ComputeAll()

	coverageScore := gdopComp.CoverageScore(results)
	avgGDOP := gdopComp.AverageGDOP(results)

	// Create a basic accuracy report from GDOP data
	accuracyReport := simulator.AccuracyReport{
		MedianError:   avgGDOP * 0.5, // Estimate: 50% of GDOP as median error
		DetectionRate: math.Min(coverageScore/100, 1.0),
	}

	// Use the full shopping list implementation from accuracy.go
	shoppingList := simulator.GenerateShoppingListFromResults(space, nodes, coverageScore, accuracyReport)
	respondJSON(w, http.StatusOK, shoppingList)
}

// SimulationRequest contains parameters for running a simulation
type SimulationRequest struct {
	DurationSec int     `json:"duration_sec"` // Simulation duration in seconds
	RateHz      int     `json:"rate_hz"`      // Update rate in Hz
	Threshold   float64 `json:"threshold"`    // DeltaRMS threshold
}

// SimulationResponse contains simulation results
type SimulationResponse struct {
	WalkerPositions []simulator.Point  `json:"walker_positions"`
	LinkActivity    map[string]float64 `json:"link_activity"`
	Duration        int                `json:"duration"`
	Ticks           int                `json:"ticks"`
}

// RunSimulation runs a time-step simulation with the current configuration
func (h *SimulatorHandler) RunSimulation(w http.ResponseWriter, r *http.Request) {
	var req SimulationRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		req = SimulationRequest{
			DurationSec: 10,
			RateHz:      10,
			Threshold:   0.02,
		}
	}

	h.mu.RLock()
	space := h.space
	nodes := h.nodes
	walkers := h.walkers
	h.mu.RUnlock()

	if walkers.Count() == 0 {
		respondError(w, http.StatusBadRequest, "no walkers in simulation")
		return
	}

	if nodes.Count() < 2 {
		respondError(w, http.StatusBadRequest, "need at least 2 nodes for simulation")
		return
	}

	// Create propagation model
	propModel := simulator.NewPropagationModel(space)

	// Generate all links
	links := simulator.GenerateAllLinks(nodes)

	// Run simulation ticks
	dt := 1.0 / float64(req.RateHz)
	numTicks := req.DurationSec * req.RateHz

	// Collect final positions and link activity
	finalPositions := make([]simulator.Point, 0)
	linkActivity := make(map[string]float64)

	for tick := 0; tick < numTicks; tick++ {
		// Update walker positions
		walkers.Update(dt, space)

		// Compute link activity
		for _, link := range links {
			linkID := link.TX.ID + ":" + link.RX.ID
			maxDelta := 0.0

			for _, walker := range walkers.All() {
				delta := propModel.ComputeLinkActivity(link, walker.Position, req.Threshold)
				if delta > maxDelta {
					maxDelta = delta
				}
			}

			if maxDelta > linkActivity[linkID] {
				linkActivity[linkID] = maxDelta
			}
		}
	}

	// Collect final walker positions
	for _, w := range walkers.All() {
		finalPositions = append(finalPositions, w.Position)
	}

	response := SimulationResponse{
		WalkerPositions: finalPositions,
		LinkActivity:    linkActivity,
		Duration:        req.DurationSec,
		Ticks:           numTicks,
	}

	respondJSON(w, http.StatusOK, response)
}

// Helper functions

func getBoundsJSON(space *simulator.Space) map[string]float64 {
	minX, minY, minZ, maxX, maxY, maxZ := space.Bounds()
	return map[string]float64{
		"min_x": minX,
		"min_y": minY,
		"min_z": minZ,
		"max_x": maxX,
		"max_y": maxY,
		"max_z": maxZ,
	}
}

func respondJSON(w http.ResponseWriter, status int, data interface{}) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	if err := json.NewEncoder(w).Encode(data); err != nil {
		log.Printf("[ERROR] Failed to encode JSON response: %v", err)
	}
}

func respondError(w http.ResponseWriter, status int, message string) {
	respondJSON(w, status, map[string]string{"error": message})
}