// Writer (Go)
version := quotePtr.Version.Add(1)  // Odd = writing
*quotePtr = *quote
quotePtr.Version.Add(1)  // Even = readable

// ============================================================
// Writer Implementation (Already Correct in Doc 30.2)
// ============================================================

func (w *SharedMemoryWriter) WriteQuote(pairIndex uint32, quote *QuoteMetadata) {
    quotePtr := &w.quotes[pairIndex]

    // Step 1: Mark as "write in progress" (odd version)
    version := quotePtr.Version.Add(1)  // e.g., 122 → 123 (odd)

    // Step 2: Write entire struct (may take 50-100ns)
    *quotePtr = *quote

    // Step 3: Commit write (even version)
    quotePtr.Version.Add(1)  // e.g., 123 → 124 (even)

    // Step 4: Notify in ring buffer (optional, for change detection)
    w.notifyChange(pairIndex, version + 1)
}

// Parallel fan-out (NON-blocking already!)
go func() {
    localQuote := localClient.GetQuote(ctx, pair)
    localChan <- localQuote
}()

go func() {
    externalQuote := externalClient.GetQuote(ctx, pair)
    externalChan <- externalQuote
}()

// Non-blocking select
for {
    select {
    case local := <-localChan:
        bestLocal = local
        stream.Send(aggregated)  // ✅ Emit partial result
    case external := <-externalChan:
        bestExternal = external
        stream.Send(aggregated)  // ✅ Update with better quote
    }
}

// ============================================================
// Explicit Non-Blocking Guarantees
// ============================================================

const (
    LocalQuoteTimeout    = 10 * time.Millisecond   // Fast fail
    ExternalQuoteTimeout = 100 * time.Millisecond  // Opportunistic
)

func (s *AggregatorService) StreamQuotes(req, stream) error {
    localChan := make(chan *LocalQuote, 1)
    externalChan := make(chan *ExternalQuote, 1)

    // Launch parallel requests with EXPLICIT timeouts
    go func() {
        ctx, cancel := context.WithTimeout(context.Background(), LocalQuoteTimeout)
        defer cancel()

        quote, err := s.localClient.GetQuote(ctx, req)
        if err != nil {
            // ❗ CRITICAL: Never block on local failure
            log.Warn("Local quote failed", "error", err)
            return
        }
        localChan <- quote
    }()

    go func() {
        ctx, cancel := context.WithTimeout(context.Background(), ExternalQuoteTimeout)
        defer cancel()

        quote, err := s.externalClient.GetQuote(ctx, req)
        if err != nil {
            // ✅ OPPORTUNISTIC: External is optional
            log.Debug("External quote failed (expected)", "error", err)
            return
        }
        externalChan <- quote
    }()

    // ✅ EMIT IMMEDIATELY when local quote arrives
    // ✅ UPDATE later if external quote is better

    firstEmit := false
    for {
        select {
        case local := <-localChan:
            bestLocal = local
            if !firstEmit {
                // ⭐ EMIT LOCAL-ONLY RESULT IMMEDIATELY
                stream.Send(AggregatedQuote{
                    BestLocal:  local,
                    BestSource: LOCAL,  // No external yet
                    Comparison: nil,    // Can't compare yet
                })
                firstEmit = true
            }

        case external := <-externalChan:
            bestExternal = external
            // ⭐ UPDATE with comparison (external arrived later)
            stream.Send(AggregatedQuote{
                BestLocal:    bestLocal,
                BestExternal: external,
                BestSource:   selectBest(bestLocal, external),
                Comparison:   compare(bestLocal, external),
            })

        case <-time.After(LocalQuoteTimeout + 1*time.Millisecond):
            // ❗ FAIL-SAFE: If local quote didn't arrive, emit error
            if !firstEmit {
                stream.Send(AggregatedQuote{
                    Error: "Local quote timeout",
                })
                return errors.New("local quote service unavailable")
            }
            // If local already emitted, just wait for external (optional)
        }
    }
}

type ConfidenceFactors struct {
    PoolStateAge      float64  // 0.0-1.0 (0=stale, 1=fresh)
    RouteHopCount     float64  // 0.0-1.0 (0=many hops, 1=direct)
    OracleDeviation   float64  // 0.0-1.0 (0=large deviation, 1=matches oracle)
    ProviderReliabili float64  // 0.0-1.0 (0=low uptime, 1=high uptime)
    SlippageVsDepth   float64  // 0.0-1.0 (0=high slippage, 1=low slippage)
}

func CalculateConfidence(quote *Quote, oracle *OraclePrice) float64 {
    factors := ConfidenceFactors{}

    // 1. Pool State Age (30% weight)
    ageSeconds := time.Since(quote.PoolLastUpdate).Seconds()
    factors.PoolStateAge = math.Max(0, 1.0 - ageSeconds/60.0)  // 60s = 0% confidence

    // 2. Route Hop Count (20% weight)
    hopPenalty := float64(quote.RouteHops - 1) * 0.2  // -20% per extra hop
    factors.RouteHopCount = math.Max(0, 1.0 - hopPenalty)

    // 3. Oracle Deviation (30% weight)
    oraclePrice := oracle.PriceUSD
    quotePrice := float64(quote.OutputAmount) / float64(quote.InputAmount)
    deviation := math.Abs(quotePrice - oraclePrice) / oraclePrice
    factors.OracleDeviation = math.Max(0, 1.0 - deviation*10)  // 10% deviation = 0% confidence

    // 4. Provider Reliability (10% weight, external quotes only)
    if quote.Source == EXTERNAL {
        factors.ProviderReliability = GetProviderUptime(quote.Provider)  // Historical 99.9% = 0.999
    } else {
        factors.ProviderReliability = 1.0  // Local always 100%
    }

    // 5. Slippage vs Depth (10% weight)
    expectedSlippage := EstimateSlippage(quote.InputAmount, quote.Pool.Depth)
    actualSlippage := quote.PriceImpactBps / 10000.0
    slippageRatio := expectedSlippage / math.Max(actualSlippage, 0.0001)
    factors.SlippageVsDepth = math.Min(1.0, slippageRatio)  // Actual <= Expected = high confidence

    // Weighted sum
    confidence := 0.0
    confidence += factors.PoolStateAge * 0.30
    confidence += factors.RouteHopCount * 0.20
    confidence += factors.OracleDeviation * 0.30
    confidence += factors.ProviderReliability * 0.10
    confidence += factors.SlippageVsDepth * 0.10

    return confidence
}

// ============================================================
// Volatility-Triggered CLMM Refresh
// ============================================================

type VolatilityMonitor struct {
    priceHistory map[string]*CircularBuffer  // Last 100 prices per pool
}

func (vm *VolatilityMonitor) CheckVolatility(poolID string, newPrice float64) bool {
    history := vm.priceHistory[poolID]
    history.Add(newPrice)

    // Calculate 1-minute standard deviation
    stdDev := history.StdDev()
    avgPrice := history.Average()

    // Volatility threshold: 2% stddev in 1 minute
    volatility := stdDev / avgPrice
    return volatility > 0.02  // 2% volatility = trigger refresh
}

// Refresh logic
func (rm *RefreshManager) RefreshCLMMWithTriggers(poolID string) {
    // Normal refresh: every 30s (Phase 1)
    ticker := time.NewTicker(30 * time.Second)

    // Listen to swap events
    swapEvents := rm.subscribeToDEXSwaps(poolID)

    for {
        select {
        case <-ticker.C:
            // ✅ Time-based refresh (30s)
            rm.refreshCLMMPool(poolID)

        case event := <-swapEvents:
            // ✅ Event-based refresh (large swap detected)
            if event.Amount > 1_000_000_000 {  // >1 SOL swap
                rm.refreshCLMMPool(poolID)
            }

            // ✅ Volatility-based refresh
            if rm.volatilityMonitor.CheckVolatility(poolID, event.Price) {
                rm.refreshCLMMPool(poolID)
            }
        }
    }
}

// ============================================================
// Split Cache: Route (Static) vs Price (Dynamic)
// ============================================================

type ExternalQuoteCache struct {
    // Cache 1: Route topology (30s TTL)
    routeCache map[string]*RouteTopology
    routeTTL   time.Duration  // 30s

    // Cache 2: Price data (2s TTL for arb, 10s for LST)
    priceCache map[string]*PriceData
    priceTTL   time.Duration  // Configurable: 2s (arb) or 10s (LST)
}

type RouteTopology struct {
    RouteSteps    []RouteStep  // DEX hops (rarely changes)
    PoolAddresses []string     // Pool pubkeys
    LastUpdate    time.Time
}

type PriceData struct {
    OutputAmount     uint64    // Changes frequently
    PriceImpactBps   uint32
    OraclePriceUSD   float64
    LastUpdate       time.Time
}

// GetQuote logic
func (c *ExternalQuoteCache) GetQuote(pair string) (*ExternalQuote, bool) {
    route, routeOK := c.routeCache[pair]
    price, priceOK := c.priceCache[pair]

    // Route is cached (30s), but price is stale (>2s)
    if routeOK && !priceOK {
        // ✅ Re-fetch ONLY price data (faster than full quote)
        newPrice := c.fetchPriceOnly(route)
        c.priceCache[pair] = newPrice
        return &ExternalQuote{Route: route, Price: newPrice}, true
    }

    // Both cached
    if routeOK && priceOK {
        return &ExternalQuote{Route: route, Price: price}, true
    }

    // Cache miss: fetch full quote
    return nil, false
}