gateway_handlers.go

// gateway_handlers.go
// Gateway-proxied implementations of API handlers
package main

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

	"github.com/go-chi/chi/v5"
)

// handleDashboardMetricsViaGateway computes dashboard metrics from gateway ledger data
func (app *App) handleDashboardMetricsViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	// Fetch recent ledgers from gateway (last 100)
	ledgers, err := app.gateway.GetLedgers(ctx, network, 1, 999999999, 100, "")
	if err != nil {
		log.Printf("Error fetching ledgers from gateway for metrics: %v", err)
		w.Write([]byte(`
			<div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-6 mb-8">
				<div class="bg-red-900 border border-red-700 rounded-lg p-6">
					<p class="text-red-200">Error fetching data from gateway</p>
				</div>
			</div>
		`))
		return
	}

	if len(ledgers) == 0 {
		w.Write([]byte(`
			<div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-6 mb-8">
				<div class="bg-yellow-900 border border-yellow-700 rounded-lg p-6">
					<p class="text-yellow-200">No ledger data available</p>
				</div>
			</div>
		`))
		return
	}

	// Compute metrics from ledgers
	// Note: Gateway returns ledgers in ascending order (oldest first)
	var totalTx, successfulTx, failedTx int64
	var latestLedger, earliestLedger int64
	var latestTime, earliestTime string

	for _, ledger := range ledgers {
		successCount := getInt64(ledger, "successful_tx_count")
		failedCount := getInt64(ledger, "failed_tx_count")
		seq := getInt64(ledger, "sequence")
		closedAt := getString(ledger, "closed_at")

		totalTx += successCount + failedCount
		successfulTx += successCount
		failedTx += failedCount

		// Track min/max ledger sequences regardless of order
		if earliestLedger == 0 || seq < earliestLedger {
			earliestLedger = seq
			earliestTime = closedAt
		}
		if seq > latestLedger {
			latestLedger = seq
			latestTime = closedAt
		}
	}

	successRate := float64(0)
	if totalTx > 0 {
		successRate = float64(successfulTx) / float64(totalTx) * 100
	}
	avgTxPerLedger := float64(totalTx) / float64(len(ledgers))

	// Render HTML response (same format as original handler)
	html := fmt.Sprintf(`
		<div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-6 mb-8">
			<div class="bg-gray-800 border border-gray-700 rounded-lg p-6">
				<div class="flex items-center justify-between">
					<div>
						<p class="text-gray-400 text-sm">Latest Ledger</p>
						<p class="text-2xl font-bold text-white mt-1">%d</p>
					</div>
					<div class="w-12 h-12 bg-blue-900/50 rounded-lg flex items-center justify-center">
						<svg class="w-6 h-6 text-blue-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
							<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10"/>
						</svg>
					</div>
				</div>
			</div>
			<div class="bg-gray-800 border border-gray-700 rounded-lg p-6">
				<div class="flex items-center justify-between">
					<div>
						<p class="text-gray-400 text-sm">Transactions (Last 100 Ledgers)</p>
						<p class="text-2xl font-bold text-white mt-1">%d</p>
					</div>
					<div class="w-12 h-12 bg-green-900/50 rounded-lg flex items-center justify-center">
						<svg class="w-6 h-6 text-green-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
							<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"/>
						</svg>
					</div>
				</div>
			</div>
			<div class="bg-gray-800 border border-gray-700 rounded-lg p-6">
				<div class="flex items-center justify-between">
					<div>
						<p class="text-gray-400 text-sm">Success Rate</p>
						<p class="text-2xl font-bold text-white mt-1">%.1f%%</p>
					</div>
					<div class="w-12 h-12 bg-purple-900/50 rounded-lg flex items-center justify-center">
						<svg class="w-6 h-6 text-purple-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
							<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"/>
						</svg>
					</div>
				</div>
			</div>
			<div class="bg-gray-800 border border-gray-700 rounded-lg p-6">
				<div class="flex items-center justify-between">
					<div>
						<p class="text-gray-400 text-sm">Avg TX/Ledger</p>
						<p class="text-2xl font-bold text-white mt-1">%.1f</p>
					</div>
					<div class="w-12 h-12 bg-orange-900/50 rounded-lg flex items-center justify-center">
						<svg class="w-6 h-6 text-orange-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
							<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 7h8m0 0v8m0-8l-8 8-4-4-6 6"/>
						</svg>
					</div>
				</div>
			</div>
		</div>
		<p class="text-gray-500 text-xs">Data from %s to %s via gateway</p>
	`, latestLedger, totalTx, successRate, avgTxPerLedger, earliestTime, latestTime)

	w.Write([]byte(html))
}

// Helper functions for extracting values from map[string]interface{}
func getInt64(m map[string]interface{}, key string) int64 {
	if v, ok := m[key]; ok {
		switch val := v.(type) {
		case float64:
			return int64(val)
		case int64:
			return val
		case int:
			return int64(val)
		case json.Number:
			i, _ := val.Int64()
			return i
		}
	}
	return 0
}

func getString(m map[string]interface{}, key string) string {
	if v, ok := m[key]; ok {
		if s, ok := v.(string); ok {
			return s
		}
	}
	return ""
}

// handleAPILedgersViaGateway fetches ledgers from the gateway
func (app *App) handleAPILedgersViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	// Parse query parameters
	limitStr := r.URL.Query().Get("limit")
	offsetStr := r.URL.Query().Get("offset")
	minSequenceStr := r.URL.Query().Get("min_sequence")
	maxSequenceStr := r.URL.Query().Get("max_sequence")
	sort := r.URL.Query().Get("sort") // sequence_asc, sequence_desc, closed_at_asc, closed_at_desc, tx_count_desc

	limit := 100
	if limitStr != "" {
		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 1000 {
			limit = l
		}
	}

	offset := 0
	if offsetStr != "" {
		if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
			offset = o
		}
	}

	// Validate sort parameter, default to sequence_desc (newest first)
	validSorts := map[string]bool{
		"sequence_asc":   true,
		"sequence_desc":  true,
		"closed_at_asc":  true,
		"closed_at_desc": true,
		"tx_count_desc":  true,
	}
	if sort == "" || !validSorts[sort] {
		sort = "sequence_desc" // Default to newest first
	}

	// For gateway, we need start/end ledger sequences
	// Default to a reasonable recent range if not specified
	var start, end int64 = 0, 0

	if minSequenceStr != "" {
		if minSeq, err := strconv.ParseInt(minSequenceStr, 10, 64); err == nil {
			start = minSeq
		}
	}

	if maxSequenceStr != "" {
		if maxSeq, err := strconv.ParseInt(maxSequenceStr, 10, 64); err == nil {
			end = maxSeq
		}
	}

	// If no range specified, use a default range (requires knowing latest ledger)
	if start == 0 && end == 0 {
		// Default to fetching recent ledgers - set end high to get latest
		start = 1
		end = 999999999 // Gateway will return what's available
	}

	// Gateway doesn't support offset natively, so we fetch offset+limit+1 records
	// to detect if there's more data, then slice the result
	fetchLimit := offset + limit + 1
	if fetchLimit > 1000 {
		fetchLimit = 1000
	}

	queryStart := time.Now()
	ledgers, err := app.gateway.GetLedgers(ctx, network, start, end, fetchLimit, sort)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Ledgers query took: %v (limit=%d, offset=%d)", network, queryDuration, limit, offset)

	if err != nil {
		log.Printf("Error fetching ledgers from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching ledgers: %v", err), http.StatusInternalServerError)
		return
	}

	// Apply offset by slicing the result
	if offset >= len(ledgers) {
		response := map[string]interface{}{
			"ledgers":  []map[string]interface{}{},
			"count":    0,
			"has_more": false,
		}
		json.NewEncoder(w).Encode(response)
		return
	}

	endIdx := offset + limit
	if endIdx > len(ledgers) {
		endIdx = len(ledgers)
	}
	result := ledgers[offset:endIdx]

	// has_more is true if we have more data after this page
	hasMore := len(ledgers) > endIdx

	response := map[string]interface{}{
		"ledgers":  result,
		"count":    len(result),
		"has_more": hasMore,
	}
	json.NewEncoder(w).Encode(response)
}

// handleAPILedgerViaGateway fetches a single ledger from the gateway
func (app *App) handleAPILedgerViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	sequenceStr := chi.URLParam(r, "sequence")
	sequence, err := strconv.ParseInt(sequenceStr, 10, 64)
	if err != nil {
		http.Error(w, "Invalid sequence number", http.StatusBadRequest)
		return
	}

	ledgers, err := app.gateway.GetLedgers(ctx, network, sequence, sequence, 1, "")
	if err != nil {
		log.Printf("Error fetching ledger from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching ledger: %v", err), http.StatusInternalServerError)
		return
	}

	if len(ledgers) == 0 {
		http.Error(w, "Ledger not found", http.StatusNotFound)
		return
	}

	json.NewEncoder(w).Encode(ledgers[0])
}

// handleAPITransactionsViaGateway fetches transactions from the gateway
func (app *App) handleAPITransactionsViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	limitStr := r.URL.Query().Get("limit")
	offsetStr := r.URL.Query().Get("offset")
	ledgerStr := r.URL.Query().Get("ledger_sequence")
	if ledgerStr == "" {
		ledgerStr = r.URL.Query().Get("ledger") // backward compatibility
	}

	limit := 100
	if limitStr != "" {
		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 1000 {
			limit = l
		}
	}

	offset := 0
	if offsetStr != "" {
		if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {
			offset = o
		}
	}

	var start, end int64 = 1, 999999999
	if ledgerStr != "" {
		if ledger, err := strconv.ParseInt(ledgerStr, 10, 64); err == nil {
			start = ledger
			end = ledger
		}
	}

	// Gateway doesn't support offset natively, so we fetch offset+limit+1 records
	// to detect if there's more data, then slice the result.
	fetchLimit := offset + limit + 1
	if fetchLimit > 1000 {
		fetchLimit = 1000 // Cap at 1000 to avoid excessive data transfer
	}

	queryStart := time.Now()
	transactions, err := app.gateway.GetTransactions(ctx, network, start, end, fetchLimit)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Transactions query took: %v (limit=%d, offset=%d)", network, queryDuration, limit, offset)

	if err != nil {
		log.Printf("Error fetching transactions from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching transactions: %v", err), http.StatusInternalServerError)
		return
	}

	// Apply offset by slicing the result
	if offset >= len(transactions) {
		response := map[string]interface{}{
			"transactions": []map[string]interface{}{},
			"count":        0,
			"has_more":     false,
		}
		json.NewEncoder(w).Encode(response)
		return
	}

	// Slice from offset to offset+limit
	endIdx := offset + limit
	if endIdx > len(transactions) {
		endIdx = len(transactions)
	}
	result := transactions[offset:endIdx]

	// has_more is true if we have more data after this page
	hasMore := len(transactions) > endIdx

	response := map[string]interface{}{
		"transactions": result,
		"count":        len(result),
		"has_more":     hasMore,
	}
	json.NewEncoder(w).Encode(response)
}

// handleAPITransactionViaGateway fetches a single transaction from the gateway
func (app *App) handleAPITransactionViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	txHash := chi.URLParam(r, "hash")
	if txHash == "" {
		http.Error(w, "Missing transaction hash", http.StatusBadRequest)
		return
	}

	details, err := app.gateway.GetTransactionDetails(ctx, network, txHash)
	if err != nil {
		log.Printf("Error fetching transaction from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching transaction: %v", err), http.StatusInternalServerError)
		return
	}

	json.NewEncoder(w).Encode(details)
}

// handleAPIOperationsViaGateway fetches operations from the gateway with cursor pagination
func (app *App) handleAPIOperationsViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	params := make(map[string]string)

	// Pagination params
	if limit := r.URL.Query().Get("limit"); limit != "" {
		params["limit"] = limit
	} else {
		params["limit"] = "100"
	}
	if cursor := r.URL.Query().Get("cursor"); cursor != "" {
		params["cursor"] = cursor
	}

	// Filter params
	if accountID := r.URL.Query().Get("account_id"); accountID != "" {
		params["account_id"] = accountID
	}
	if txHash := r.URL.Query().Get("tx_hash"); txHash != "" {
		params["tx_hash"] = txHash
	}
	if txHash := r.URL.Query().Get("transaction_hash"); txHash != "" {
		params["tx_hash"] = txHash
	}
	if startLedger := r.URL.Query().Get("start_ledger"); startLedger != "" {
		params["start_ledger"] = startLedger
	}
	if endLedger := r.URL.Query().Get("end_ledger"); endLedger != "" {
		params["end_ledger"] = endLedger
	}

	queryStart := time.Now()
	result, err := app.gateway.GetOperationsWithCursor(ctx, network, params)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Operations query took: %v", network, queryDuration)

	if err != nil {
		log.Printf("Error fetching operations from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching operations: %v", err), http.StatusInternalServerError)
		return
	}

	// Return paginated response with cursor info
	response := map[string]interface{}{
		"operations": result.Data,
		"count":      result.Count,
		"has_more":   result.HasMore,
	}
	if result.Cursor != "" {
		response["cursor"] = result.Cursor
	}

	json.NewEncoder(w).Encode(response)
}

// handleAPIEffectsViaGateway fetches effects from the gateway silver layer with cursor pagination
func (app *App) handleAPIEffectsViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	params := make(map[string]string)

	// Pagination params
	if limit := r.URL.Query().Get("limit"); limit != "" {
		params["limit"] = limit
	} else {
		params["limit"] = "100"
	}
	if cursor := r.URL.Query().Get("cursor"); cursor != "" {
		params["cursor"] = cursor
	}

	// Optional filter params
	if accountID := r.URL.Query().Get("account_id"); accountID != "" {
		params["account_id"] = accountID
	}
	if effectType := r.URL.Query().Get("effect_type"); effectType != "" {
		params["effect_type"] = effectType
	}

	queryStart := time.Now()
	result, err := app.gateway.GetEffectsWithCursor(ctx, network, params)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Effects query took: %v", network, queryDuration)

	if err != nil {
		log.Printf("Error fetching effects from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching effects: %v", err), http.StatusInternalServerError)
		return
	}

	// Return paginated response with cursor info
	response := map[string]interface{}{
		"effects":  result.Data,
		"count":    result.Count,
		"has_more": result.HasMore,
	}
	if result.Cursor != "" {
		response["cursor"] = result.Cursor
	}

	json.NewEncoder(w).Encode(response)
}

// handleAPITradesViaGateway fetches trades from the gateway silver layer with cursor pagination
func (app *App) handleAPITradesViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	params := make(map[string]string)

	// Pagination params
	if limit := r.URL.Query().Get("limit"); limit != "" {
		params["limit"] = limit
	} else {
		params["limit"] = "100"
	}
	if cursor := r.URL.Query().Get("cursor"); cursor != "" {
		params["cursor"] = cursor
	}

	// Optional filter params
	if sellerAccount := r.URL.Query().Get("seller_account"); sellerAccount != "" {
		params["seller_account"] = sellerAccount
	}
	if buyerAccount := r.URL.Query().Get("buyer_account"); buyerAccount != "" {
		params["buyer_account"] = buyerAccount
	}
	if sellingAsset := r.URL.Query().Get("selling_asset"); sellingAsset != "" {
		params["selling_asset"] = sellingAsset
	}
	if buyingAsset := r.URL.Query().Get("buying_asset"); buyingAsset != "" {
		params["buying_asset"] = buyingAsset
	}
	if tradeType := r.URL.Query().Get("trade_type"); tradeType != "" {
		params["trade_type"] = tradeType
	}

	queryStart := time.Now()
	result, err := app.gateway.GetTradesWithCursor(ctx, network, params)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Trades query took: %v", network, queryDuration)

	if err != nil {
		log.Printf("Error fetching trades from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching trades: %v", err), http.StatusInternalServerError)
		return
	}

	// Return paginated response with cursor info
	response := map[string]interface{}{
		"trades":   result.Data,
		"count":    result.Count,
		"has_more": result.HasMore,
	}
	if result.Cursor != "" {
		response["cursor"] = result.Cursor
	}

	json.NewEncoder(w).Encode(response)
}

// handleAPIOffersViaGateway fetches offers from the gateway
func (app *App) handleAPIOffersViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	params := make(map[string]string)

	// Pagination params
	if limit := r.URL.Query().Get("limit"); limit != "" {
		params["limit"] = limit
	} else {
		params["limit"] = "50"
	}
	if cursor := r.URL.Query().Get("cursor"); cursor != "" {
		params["cursor"] = cursor
	}

	// Optional filter params - seller_id is now OPTIONAL in silver layer
	if sellerID := r.URL.Query().Get("seller_id"); sellerID != "" {
		params["seller_id"] = sellerID
	}
	if sellerID := r.URL.Query().Get("seller"); sellerID != "" {
		params["seller_id"] = sellerID // backward compatibility
	}

	queryStart := time.Now()
	result, err := app.gateway.GetOffersWithCursor(ctx, network, params)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Offers query took: %v", network, queryDuration)

	if err != nil {
		log.Printf("Error fetching offers from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching offers: %v", err), http.StatusInternalServerError)
		return
	}

	// Return paginated response with cursor info
	response := map[string]interface{}{
		"offers":   result.Data,
		"count":    result.Count,
		"has_more": result.HasMore,
	}
	if result.Cursor != "" {
		response["cursor"] = result.Cursor
	}

	json.NewEncoder(w).Encode(response)
}

// handleAccountsAPIViaGateway fetches accounts from the gateway with cursor pagination
func (app *App) handleAccountsAPIViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	params := make(map[string]string)

	// Pagination params
	if limit := r.URL.Query().Get("limit"); limit != "" {
		params["limit"] = limit
	} else {
		params["limit"] = "50"
	}
	if cursor := r.URL.Query().Get("cursor"); cursor != "" {
		params["cursor"] = cursor
	}

	// Filter params
	if minBalance := r.URL.Query().Get("min_balance"); minBalance != "" {
		params["min_balance"] = minBalance
	}
	if sortBy := r.URL.Query().Get("sort_by"); sortBy != "" {
		params["sort_by"] = sortBy
	}
	if order := r.URL.Query().Get("order"); order != "" {
		params["order"] = order
	}

	queryStart := time.Now()
	result, err := app.gateway.GetAccountsWithCursor(ctx, network, params)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Accounts query took: %v", network, queryDuration)

	if err != nil {
		log.Printf("Error fetching accounts from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching accounts: %v", err), http.StatusInternalServerError)
		return
	}

	// Return paginated response with cursor info
	response := map[string]interface{}{
		"accounts": result.Data,
		"count":    result.Count,
		"has_more": result.HasMore,
	}
	if result.Cursor != "" {
		response["cursor"] = result.Cursor
	}

	json.NewEncoder(w).Encode(response)
}

// handleAccountAPIViaGateway fetches a single account from the gateway
func (app *App) handleAccountAPIViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	accountID := chi.URLParam(r, "id")
	if accountID == "" {
		http.Error(w, "Missing account ID", http.StatusBadRequest)
		return
	}

	account, err := app.gateway.GetAccountOverview(ctx, network, accountID)
	if err != nil {
		log.Printf("Error fetching account from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching account: %v", err), http.StatusInternalServerError)
		return
	}

	json.NewEncoder(w).Encode(account)
}

// handleAPILiquidityPoolsViaGateway fetches liquidity pools from the gateway silver layer
func (app *App) handleAPILiquidityPoolsViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	params := make(map[string]string)

	// Pagination params
	if limit := r.URL.Query().Get("limit"); limit != "" {
		params["limit"] = limit
	} else {
		params["limit"] = "50"
	}
	if cursor := r.URL.Query().Get("cursor"); cursor != "" {
		params["cursor"] = cursor
	}

	// Filter params
	if assetA := r.URL.Query().Get("asset_a"); assetA != "" {
		params["asset_a"] = assetA
	}
	if assetB := r.URL.Query().Get("asset_b"); assetB != "" {
		params["asset_b"] = assetB
	}

	queryStart := time.Now()
	result, err := app.gateway.GetLiquidityPoolsWithCursor(ctx, network, params)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Liquidity pools query took: %v", network, queryDuration)

	if err != nil {
		log.Printf("Error fetching liquidity pools from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching liquidity pools: %v", err), http.StatusInternalServerError)
		return
	}

	// Return paginated response with cursor info
	response := map[string]interface{}{
		"liquidity_pools": result.Data,
		"count":           result.Count,
		"has_more":        result.HasMore,
	}
	if result.Cursor != "" {
		response["cursor"] = result.Cursor
	}

	json.NewEncoder(w).Encode(response)
}

// handleAPINetworkStatsViaGateway fetches network statistics from the gateway silver layer
func (app *App) handleAPINetworkStatsViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	queryStart := time.Now()
	result, err := app.gateway.GetNetworkStats(ctx, network)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Network stats query took: %v", network, queryDuration)

	if err != nil {
		log.Printf("Error fetching network stats from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching network stats: %v", err), http.StatusInternalServerError)
		return
	}

	json.NewEncoder(w).Encode(result)
}

// handleAPIContractsViaGateway fetches top contracts from the gateway silver layer
func (app *App) handleAPIContractsViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	params := make(map[string]string)

	// Pagination params
	if limit := r.URL.Query().Get("limit"); limit != "" {
		params["limit"] = limit
	} else {
		params["limit"] = "50"
	}
	if cursor := r.URL.Query().Get("cursor"); cursor != "" {
		params["cursor"] = cursor
	}

	// Filter params
	if period := r.URL.Query().Get("period"); period != "" {
		params["period"] = period
	}

	queryStart := time.Now()
	result, err := app.gateway.GetTopContracts(ctx, network, params)
	queryDuration := time.Since(queryStart)
	log.Printf("[%s/gateway] Top contracts query took: %v", network, queryDuration)

	if err != nil {
		log.Printf("Error fetching contracts from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching contracts: %v", err), http.StatusInternalServerError)
		return
	}

	// Return paginated response with cursor info
	response := map[string]interface{}{
		"contracts": result.Data,
		"count":     result.Count,
		"has_more":  result.HasMore,
	}
	if result.Cursor != "" {
		response["cursor"] = result.Cursor
	}

	json.NewEncoder(w).Encode(response)
}

// handleAPIContractViaGateway fetches a contract from the gateway
func (app *App) handleAPIContractViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	contractID := chi.URLParam(r, "id")
	if contractID == "" {
		http.Error(w, "Missing contract ID", http.StatusBadRequest)
		return
	}

	contract, err := app.gateway.GetContractSummary(ctx, network, contractID)
	if err != nil {
		log.Printf("Error fetching contract from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching contract: %v", err), http.StatusInternalServerError)
		return
	}

	json.NewEncoder(w).Encode(contract)
}

// handleAPIContractEventsViaGateway fetches contract events from the gateway
func (app *App) handleAPIContractEventsViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	contractID := chi.URLParam(r, "id")
	if contractID == "" {
		http.Error(w, "Missing contract ID", http.StatusBadRequest)
		return
	}

	startLedgerStr := r.URL.Query().Get("start_ledger")
	endLedgerStr := r.URL.Query().Get("end_ledger")

	var startLedger, endLedger int64
	if startLedgerStr != "" {
		startLedger, _ = strconv.ParseInt(startLedgerStr, 10, 64)
	}
	if endLedgerStr != "" {
		endLedger, _ = strconv.ParseInt(endLedgerStr, 10, 64)
	}

	events, err := app.gateway.GetContractEvents(ctx, network, contractID, startLedger, endLedger)
	if err != nil {
		log.Printf("Error fetching contract events from gateway: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching contract events: %v", err), http.StatusInternalServerError)
		return
	}

	json.NewEncoder(w).Encode(events)
}

// handleAPIMetricsSummaryViaGateway computes metrics summary from gateway ledger data
func (app *App) handleAPIMetricsSummaryViaGateway(w http.ResponseWriter, r *http.Request, network string) {
	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
	defer cancel()

	// Fetch recent ledgers from gateway (last 100)
	ledgers, err := app.gateway.GetLedgers(ctx, network, 1, 999999999, 100, "")
	if err != nil {
		log.Printf("Error fetching ledgers from gateway for metrics: %v", err)
		http.Error(w, fmt.Sprintf("Error fetching metrics: %v", err), http.StatusInternalServerError)
		return
	}

	if len(ledgers) == 0 {
		json.NewEncoder(w).Encode(map[string]interface{}{
			"error": "No ledger data available",
		})
		return
	}

	// Compute metrics from ledgers
	var totalTx, successfulTx, failedTx int64
	var latestLedger, earliestLedger int64
	var latestTime, earliestTime string

	for _, ledger := range ledgers {
		successCount := getInt64(ledger, "successful_tx_count")
		failedCount := getInt64(ledger, "failed_tx_count")
		seq := getInt64(ledger, "sequence")
		closedAt := getString(ledger, "closed_at")

		totalTx += successCount + failedCount
		successfulTx += successCount
		failedTx += failedCount

		if earliestLedger == 0 || seq < earliestLedger {
			earliestLedger = seq
			earliestTime = closedAt
		}
		if seq > latestLedger {
			latestLedger = seq
			latestTime = closedAt
		}
	}

	successRate := float64(0)
	if totalTx > 0 {
		successRate = float64(successfulTx) / float64(totalTx) * 100
	}
	avgTxPerLedger := float64(totalTx) / float64(len(ledgers))

	summary := map[string]interface{}{
		"total_ledgers":           len(ledgers),
		"total_transactions":      totalTx,
		"successful_transactions": successfulTx,
		"failed_transactions":     failedTx,
		"success_rate":            successRate,
		"avg_tps":                 avgTxPerLedger,
		"latest_ledger":           latestLedger,
		"earliest_time":           earliestTime,
		"latest_time":             latestTime,
	}

	json.NewEncoder(w).Encode(summary)
}