// Pool Discovery: Simplified to discovery only
func (s *PoolDiscoveryService) ScanForPools(ctx context.Context, baseMint, quoteMint string) error {
    // 1. RPC scan for pools
    pools, err := s.protocolClient.FetchPoolsByPair(ctx, baseMint, quoteMint)
    if err != nil {
        return err
    }

    for _, pool := range pools {
        // 2. Set default reserves (NEVER nil or zero)
        if pool.BaseReserve.IsNil() || pool.BaseReserve.IsZero() {
            pool.BaseReserve = math.NewInt(1_000_000_000_000) // 1 trillion
        }
        if pool.QuoteReserve.IsNil() || pool.QuoteReserve.IsZero() {
            pool.QuoteReserve = math.NewInt(1_000_000_000_000) // 1 trillion
        }

        // 3. Enrich with Solscan (best effort, non-blocking)
        go func(p *domain.Pool) {
            enriched, err := s.solscanEnricher.EnrichPool(ctx, p)
            if err != nil {
                observability.LogWarn("Solscan enrichment failed, using defaults",
                    observability.String("poolId", p.ID[:8]),
                    observability.Error(err))
                // Use default reserves already set
                s.publishPoolDiscovered(p)
            } else {
                // Use enriched data
                s.publishPoolDiscovered(enriched)
            }
        }(pool)
    }

    return nil
}

func (s *PoolDiscoveryService) publishPoolDiscovered(pool *domain.Pool) {
    // Publish to NATS: pool.discovered.*
    event := &PoolDiscoveredEvent{
        PoolID:       pool.ID,
        ProgramID:    pool.ProgramID,
        DEX:          pool.DEX,
        BaseMint:     pool.BaseMint,
        QuoteMint:    pool.QuoteMint,
        BaseReserve:  pool.BaseReserve.String(),
        QuoteReserve: pool.QuoteReserve.String(),
        LiquidityUSD: pool.LiquidityUSD,
        Timestamp:    time.Now().Unix(),
    }

    s.natsPublisher.Publish("pool.discovered."+pool.DEX, event)
}

// Local Quote Service: Enhanced pool state ownership
func (s *LocalQuoteService) Start(ctx context.Context) error {
    // 1. Load persisted pools from Redis (crash recovery)
    if err := s.loadPoolsFromRedis(ctx); err != nil {
        observability.LogWarn("Failed to load pools from Redis", observability.Error(err))
    }

    // 2. Subscribe to pool discovery events
    go s.subscribeToPoolDiscovery(ctx)

    // 3. Start WebSocket manager
    go s.wsManager.Start(ctx)

    // 4. Start RPC backup poller
    go s.rpcBackupPoller(ctx)

    // 5. Start Redis persistence worker
    go s.redisPersistenceWorker(ctx)

    return nil
}

func (s *LocalQuoteService) subscribeToPoolDiscovery(ctx context.Context) {
    // Subscribe to NATS: pool.discovered.*
    sub, err := s.natsClient.Subscribe("pool.discovered.*", func(msg *nats.Msg) {
        var event PoolDiscoveredEvent
        if err := json.Unmarshal(msg.Data, &event); err != nil {
            observability.LogError("Failed to unmarshal pool discovered event",
                observability.Error(err))
            return
        }

        s.handlePoolDiscovered(ctx, &event)
    })

    if err != nil {
        observability.LogError("Failed to subscribe to pool discovery",
            observability.Error(err))
        return
    }

    observability.LogInfo("Subscribed to pool discovery events")

    // Keep subscription alive
    <-ctx.Done()
    sub.Unsubscribe()
}

func (s *LocalQuoteService) handlePoolDiscovered(ctx context.Context, event *PoolDiscoveredEvent) {
    // Convert event to pool
    pool := s.eventToPool(event)

    // Add to in-memory cache
    s.poolCache.Set(pool.ID, &PoolState{
        Pool:        pool,
        LastUpdate:  time.Now(),
        IsStale:     false,
    })

    observability.LogInfo("Pool added to cache",
        observability.String("poolId", pool.ID[:8]),
        observability.String("dex", pool.DEX),
        observability.Uint64("baseReserve", pool.BaseReserve.Uint64()),
        observability.Uint64("quoteReserve", pool.QuoteReserve.Uint64()))

    // Subscribe to WebSocket updates
    if err := s.wsManager.SubscribePool(pool.ID, pool.ProgramID); err != nil {
        observability.LogError("Failed to subscribe to pool updates",
            observability.String("poolId", pool.ID[:8]),
            observability.Error(err))
    }

    // Queue high-priority RPC fetch (get fresh data)
    s.refreshQueue <- RefreshCommand{
        PoolID:   pool.ID,
        PoolType: pool.Type,
        Priority: HIGH,
    }
}

func (s *PoolDiscoveryService) scanPool(pool *domain.Pool) {
    // Set defaults FIRST (before enrichment)
    if pool.BaseReserve.IsNil() || pool.BaseReserve.IsZero() {
        pool.BaseReserve = math.NewInt(1_000_000_000_000) // 1 trillion
        observability.LogInfo("Set default base reserve",
            observability.String("poolId", pool.ID[:8]))
    }

    if pool.QuoteReserve.IsNil() || pool.QuoteReserve.IsZero() {
        pool.QuoteReserve = math.NewInt(1_000_000_000_000) // 1 trillion
        observability.LogInfo("Set default quote reserve",
            observability.String("poolId", pool.ID[:8]))
    }

    // Try to enrich (best effort, non-blocking)
    enriched, err := s.solscanEnricher.EnrichPool(ctx, pool)
    if err != nil {
        observability.LogWarn("Solscan enrichment failed, using defaults",
            observability.String("poolId", pool.ID[:8]),
            observability.Error(err))

        // Publish with defaults
        s.publishPoolDiscovered(pool)
    } else {
        // Publish with enriched data
        s.publishPoolDiscovered(enriched)
    }
}

func (s *LocalQuoteService) handlePoolDiscovered(ctx context.Context, event *PoolDiscoveredEvent) {
    pool := s.eventToPool(event)

    // Validate reserves (should never be nil/zero at this point)
    if pool.BaseReserve.IsNil() || pool.BaseReserve.IsZero() {
        observability.LogError("Received pool with nil/zero base reserve",
            observability.String("poolId", pool.ID[:8]))
        // Re-apply defaults
        pool.BaseReserve = math.NewInt(1_000_000_000_000)
    }

    if pool.QuoteReserve.IsNil() || pool.QuoteReserve.IsZero() {
        observability.LogError("Received pool with nil/zero quote reserve",
            observability.String("poolId", pool.ID[:8]))
        // Re-apply defaults
        pool.QuoteReserve = math.NewInt(1_000_000_000_000)
    }

    // Add to cache
    s.poolCache.Set(pool.ID, &PoolState{
        Pool:        pool,
        LastUpdate:  time.Now(),
        IsStale:     false,
        NeedsRefresh: true, // Mark for immediate refresh
    })

    // Subscribe to WebSocket (will get actual values)
    s.wsManager.SubscribePool(pool.ID, pool.ProgramID)

    // Queue HIGH priority RPC fetch (verify actual reserves)
    s.refreshQueue <- RefreshCommand{
        PoolID:   pool.ID,
        Priority: HIGH,
    }
}

type WebSocketManager struct {
    conn           *websocket.Conn
    rpcURL         string
    subscriptions  map[string]uint64            // poolID -> subscriptionID
    reverseMap     map[uint64]string            // subscriptionID -> poolID
    updateHandlers map[string]PoolUpdateHandler // poolID -> handler
    reconnectDelay time.Duration
    maxReconnect   int
    mu             sync.RWMutex
}

type PoolUpdateHandler interface {
    HandleUpdate(accountData []byte, slot uint64) error
    GetPoolType() PoolType
}

func (w *WebSocketManager) SubscribePool(poolID, programID string) error {
    w.mu.Lock()
    defer w.mu.Unlock()

    // Check if already subscribed
    if _, exists := w.subscriptions[poolID]; exists {
        observability.LogDebug("Pool already subscribed",
            observability.String("poolId", poolID[:8]))
        return nil
    }

    // Build accountSubscribe request
    req := &rpc.AccountSubscribeRequest{
        Account: poolID,
        Config: &rpc.AccountSubscribeConfig{
            Encoding:   "base64",
            Commitment: "confirmed",
        },
    }

    // Send subscription
    subID, err := w.conn.AccountSubscribe(req)
    if err != nil {
        return fmt.Errorf("failed to subscribe: %w", err)
    }

    // Track subscription (bidirectional maps)
    w.subscriptions[poolID] = subID
    w.reverseMap[subID] = poolID

    observability.LogInfo("Subscribed to pool updates",
        observability.String("poolId", poolID[:8]),
        observability.Uint64("subscriptionId", subID))

    // Record metric
    metrics.RecordPoolSubscription(poolID, programID)

    return nil
}

func (w *WebSocketManager) handleAccountNotification(notification *rpc.AccountNotification) {
    // Find pool by subscription ID
    w.mu.RLock()
    poolID, exists := w.reverseMap[notification.Subscription]
    w.mu.RUnlock()

    if !exists {
        observability.LogWarn("Received notification for unknown subscription",
            observability.Uint64("subscriptionId", notification.Subscription))
        return
    }

    // Decode account data (base64 -> bytes)
    accountData, err := base64.StdEncoding.DecodeString(notification.Result.Value.Data[0])
    if err != nil {
        observability.LogError("Failed to decode account data",
            observability.String("poolId", poolID[:8]),
            observability.Error(err))
        return
    }

    // Get update handler for this pool
    w.mu.RLock()
    handler, exists := w.updateHandlers[poolID]
    w.mu.RUnlock()

    if !exists {
        observability.LogWarn("No update handler for pool",
            observability.String("poolId", poolID[:8]))
        return
    }

    // Handle update (pool-specific decoding)
    if err := handler.HandleUpdate(accountData, notification.Result.Value.Slot); err != nil {
        observability.LogError("Failed to handle pool update",
            observability.String("poolId", poolID[:8]),
            observability.Error(err))
        return
    }

    // Record metric
    metrics.RecordPoolUpdate(poolID, time.Since(notification.Result.Value.Timestamp))
}

func (w *WebSocketManager) Start(ctx context.Context) {
    reconnectAttempts := 0

    for {
        select {
        case <-ctx.Done():
            return
        default:
        }

        // Connect to WebSocket
        conn, err := websocket.Dial(w.rpcURL)
        if err != nil {
            reconnectAttempts++
            delay := w.calculateBackoff(reconnectAttempts)

            observability.LogWarn("WebSocket connection failed, retrying",
                observability.Error(err),
                observability.Int("attempt", reconnectAttempts),
                observability.Duration("delay", delay))

            time.Sleep(delay)
            continue
        }

        w.conn = conn
        reconnectAttempts = 0

        observability.LogInfo("WebSocket connected")

        // Resubscribe to all pools
        w.resubscribeAll()

        // Listen for messages
        w.listen(ctx)

        // Connection closed, reconnect
        observability.LogWarn("WebSocket connection closed, reconnecting")
    }
}

func (w *WebSocketManager) calculateBackoff(attempts int) time.Duration {
    // Exponential backoff: 1s, 2s, 4s, 8s, 16s, max 30s
    delay := time.Duration(1<<uint(attempts-1)) * time.Second
    if delay > 30*time.Second {
        delay = 30 * time.Second
    }
    return delay
}

func (w *WebSocketManager) resubscribeAll() {
    w.mu.RLock()
    poolIDs := make([]string, 0, len(w.subscriptions))
    for poolID := range w.subscriptions {
        poolIDs = append(poolIDs, poolID)
    }
    w.mu.RUnlock()

    // Clear old subscriptions
    w.mu.Lock()
    w.subscriptions = make(map[string]uint64)
    w.reverseMap = make(map[uint64]string)
    w.mu.Unlock()

    // Resubscribe
    for _, poolID := range poolIDs {
        if err := w.SubscribePool(poolID, ""); err != nil {
            observability.LogError("Failed to resubscribe pool",
                observability.String("poolId", poolID[:8]),
                observability.Error(err))
        }
    }

    observability.LogInfo("Resubscribed to all pools",
        observability.Int("count", len(poolIDs)))
}

type InMemoryPoolCache struct {
    hotPools  *lru.Cache // LRU cache for frequently accessed pools
    coldPools sync.Map   // Infrequently accessed pools
    hotLimit  int        // Max hot pool count (default: 500)
    mu        sync.RWMutex
}

type PoolState struct {
    Pool         *domain.Pool
    CLMMData     *CLMMPoolData // Tick arrays for CLMM
    DLMMData     *DLMMPoolData // Bin arrays for DLMM
    LastUpdate   time.Time
    RefreshCount int
    IsStale      bool
    NeedsRefresh bool
    mu           sync.RWMutex
}

func (c *InMemoryPoolCache) Get(poolID string) (*PoolState, error) {
    // 1. Check hot cache (LRU)
    if val, ok := c.hotPools.Get(poolID); ok {
        observability.LogDebug("Hot pool cache hit",
            observability.String("poolId", poolID[:8]))
        metrics.RecordCacheHit("hot")
        return val.(*PoolState), nil
    }

    // 2. Check cold cache (sync.Map)
    if val, ok := c.coldPools.Load(poolID); ok {
        poolState := val.(*PoolState)

        // Check if stale
        if time.Since(poolState.LastUpdate) < 60*time.Second {
            observability.LogDebug("Cold pool cache hit",
                observability.String("poolId", poolID[:8]))
            metrics.RecordCacheHit("cold")

            // Promote to hot if accessed again
            c.promoteToHot(poolID, poolState)

            return poolState, nil
        }

        // Stale, remove from cold
        c.coldPools.Delete(poolID)
    }

    // 3. Cache miss - fetch from RPC
    observability.LogDebug("Pool cache miss, fetching from RPC",
        observability.String("poolId", poolID[:8]))
    metrics.RecordCacheMiss()

    poolState, err := c.fetchPoolFromRPC(poolID)
    if err != nil {
        return nil, err
    }

    // Add to cold cache
    c.coldPools.Store(poolID, poolState)

    return poolState, nil
}

func (c *InMemoryPoolCache) promoteToHot(poolID string, poolState *PoolState) {
    c.mu.Lock()
    defer c.mu.Unlock()

    // Add to hot cache (LRU evicts oldest if full)
    c.hotPools.Add(poolID, poolState)

    // Remove from cold
    c.coldPools.Delete(poolID)

    observability.LogDebug("Promoted pool to hot cache",
        observability.String("poolId", poolID[:8]))
    metrics.RecordCachePromotion()
}

func (s *LocalQuoteService) redisPersistenceWorker(ctx context.Context) {
    ticker := time.NewTicker(10 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            s.persistPoolsToRedis(ctx)
        case <-ctx.Done():
            // Final persist before shutdown
            s.persistPoolsToRedis(context.Background())
            return
        }
    }
}

func (s *LocalQuoteService) persistPoolsToRedis(ctx context.Context) {
    // Get snapshot of hot pools
    hotPools := s.poolCache.GetAllHotPools()

    observability.LogDebug("Persisting pools to Redis",
        observability.Int("count", len(hotPools)))

    // Persist in batches (non-blocking)
    for _, poolState := range hotPools {
        go func(ps *PoolState) {
            // Marshal to JSON
            data, err := json.Marshal(ps.Pool)
            if err != nil {
                observability.LogError("Failed to marshal pool",
                    observability.String("poolId", ps.Pool.ID[:8]),
                    observability.Error(err))
                metrics.RecordRedisPersistError()
                return
            }

            // Write to Redis (fire-and-forget)
            key := fmt.Sprintf("pool:state:%s", ps.Pool.ID)
            if err := s.redisClient.Set(ctx, key, data, 24*time.Hour).Err(); err != nil {
                observability.LogError("Failed to persist pool to Redis",
                    observability.String("poolId", ps.Pool.ID[:8]),
                    observability.Error(err))
                metrics.RecordRedisPersistError()
                return
            }

            metrics.RecordRedisPersistSuccess()
        }(poolState)
    }
}

func (s *LocalQuoteService) loadPoolsFromRedis(ctx context.Context) error {
    observability.LogInfo("Loading pools from Redis (crash recovery)")

    // Scan for all pool keys
    var cursor uint64
    var keys []string

    for {
        var batch []string
        var err error

        batch, cursor, err = s.redisClient.Scan(ctx, cursor, "pool:state:*", 100).Result()
        if err != nil {
            return fmt.Errorf("failed to scan Redis: %w", err)
        }

        keys = append(keys, batch...)

        if cursor == 0 {
            break
        }
    }

    observability.LogInfo("Found pools in Redis",
        observability.Int("count", len(keys)))

    // Load pools (parallel)
    var wg sync.WaitGroup
    poolsChan := make(chan *domain.Pool, len(keys))

    for _, key := range keys {
        wg.Add(1)

        go func(k string) {
            defer wg.Done()

            // Get pool data
            data, err := s.redisClient.Get(ctx, k).Bytes()
            if err != nil {
                observability.LogError("Failed to get pool from Redis",
                    observability.String("key", k),
                    observability.Error(err))
                return
            }

            // Unmarshal
            var pool domain.Pool
            if err := json.Unmarshal(data, &pool); err != nil {
                observability.LogError("Failed to unmarshal pool",
                    observability.String("key", k),
                    observability.Error(err))
                return
            }

            poolsChan <- &pool
        }(key)
    }

    // Wait for all loads to complete
    wg.Wait()
    close(poolsChan)

    // Add pools to cache
    loadedCount := 0
    for pool := range poolsChan {
        s.poolCache.Set(pool.ID, &PoolState{
            Pool:         pool,
            LastUpdate:   time.Now(),
            IsStale:      true, // Mark as stale, will refresh
            NeedsRefresh: true,
        })

        // Subscribe to WebSocket
        s.wsManager.SubscribePool(pool.ID, pool.ProgramID)

        // Queue RPC refresh (verify freshness)
        s.refreshQueue <- RefreshCommand{
            PoolID:   pool.ID,
            Priority: NORMAL,
        }

        loadedCount++
    }

    observability.LogInfo("Loaded pools from Redis",
        observability.Int("loaded", loadedCount),
        observability.Int("failed", len(keys)-loadedCount))

    return nil
}