mev-beta/pkg/arbitrage/service.go

package arbitrage

import (
	"context"
	"fmt"
	"math/big"
	"os"
	"sync"
	"time"

	"github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/fraktal/mev-beta/internal/config"
	"github.com/fraktal/mev-beta/internal/logger"
	"github.com/fraktal/mev-beta/internal/ratelimit"
	"github.com/fraktal/mev-beta/pkg/contracts"
	"github.com/fraktal/mev-beta/pkg/market"
	"github.com/fraktal/mev-beta/pkg/marketmanager"
	"github.com/fraktal/mev-beta/pkg/monitor"
	"github.com/fraktal/mev-beta/pkg/scanner"
	"github.com/fraktal/mev-beta/pkg/security"
	"github.com/holiman/uint256"
)

// TokenPair represents the two tokens in a pool
type TokenPair struct {
	Token0 common.Address
	Token1 common.Address
}

// ArbitrageOpportunity represents a detected arbitrage opportunity
type ArbitrageOpportunity struct {
	ID              string
	Path            *ArbitragePath
	TriggerEvent    *SimpleSwapEvent
	DetectedAt      time.Time
	EstimatedProfit *big.Int
	RequiredAmount  *big.Int
	Urgency         int // 1-10 priority level
	ExpiresAt       time.Time
}

// ArbitrageStats contains service statistics
type ArbitrageStats struct {
	TotalOpportunitiesDetected int64
	TotalOpportunitiesExecuted int64
	TotalSuccessfulExecutions  int64
	TotalProfitRealized        *big.Int
	TotalGasSpent              *big.Int
	AverageExecutionTime       time.Duration
	LastExecutionTime          time.Time
}

// ArbitrageDatabase interface for persistence
type ArbitrageDatabase interface {
	SaveOpportunity(ctx context.Context, opportunity *ArbitrageOpportunity) error
	SaveExecution(ctx context.Context, result *ExecutionResult) error
	GetExecutionHistory(ctx context.Context, limit int) ([]*ExecutionResult, error)
	SavePoolData(ctx context.Context, poolData *SimplePoolData) error
	GetPoolData(ctx context.Context, poolAddress common.Address) (*SimplePoolData, error)
}

// ArbitrageService is a sophisticated arbitrage service with comprehensive MEV detection
type ArbitrageService struct {
	client     *ethclient.Client
	logger     *logger.Logger
	config     *config.ArbitrageConfig
	keyManager *security.KeyManager

	// Core components
	multiHopScanner *MultiHopScanner
	executor        *ArbitrageExecutor

	// Market management
	marketManager     *market.MarketManager
	marketDataManager *marketmanager.MarketManager

	// Token cache for pool addresses
	tokenCache      map[common.Address]TokenPair
	tokenCacheMutex sync.RWMutex

	// State management
	isRunning bool
	runMutex  sync.RWMutex
	ctx       context.Context
	cancel    context.CancelFunc

	// Metrics and monitoring
	stats      *ArbitrageStats
	statsMutex sync.RWMutex

	// Database integration
	database ArbitrageDatabase
}

// SimpleSwapEvent represents a swap event for arbitrage detection
type SimpleSwapEvent struct {
	TxHash       common.Hash
	PoolAddress  common.Address
	Token0       common.Address
	Token1       common.Address
	Amount0      *big.Int
	Amount1      *big.Int
	SqrtPriceX96 *big.Int
	Liquidity    *big.Int
	Tick         int32
	BlockNumber  uint64
	LogIndex     uint
	Timestamp    time.Time
}

// SimplePoolData represents basic pool information
type SimplePoolData struct {
	Address      common.Address
	Token0       common.Address
	Token1       common.Address
	Fee          int64
	Liquidity    *big.Int
	SqrtPriceX96 *big.Int
	Tick         int32
	BlockNumber  uint64
	TxHash       common.Hash
	LogIndex     uint
	LastUpdated  time.Time
}

// NewArbitrageService creates a new sophisticated arbitrage service
func NewArbitrageService(
	client *ethclient.Client,
	logger *logger.Logger,
	config *config.ArbitrageConfig,
	keyManager *security.KeyManager,
	database ArbitrageDatabase,
) (*ArbitrageService, error) {

	ctx, cancel := context.WithCancel(context.Background())

	// Create multi-hop scanner with simple market manager
	multiHopScanner := NewMultiHopScanner(logger, nil)

	// Create arbitrage executor
	executor, err := NewArbitrageExecutor(
		client,
		logger,
		keyManager,
		common.HexToAddress(config.ArbitrageContractAddress),
		common.HexToAddress(config.FlashSwapContractAddress),
	)
	if err != nil {
		cancel()
		return nil, fmt.Errorf("failed to create arbitrage executor: %w", err)
	}

	// Initialize market manager with nil config for now (can be enhanced later)
	var marketManager *market.MarketManager = nil
	logger.Info("Market manager initialization deferred to avoid circular dependencies")

	// Initialize new market manager
	marketDataManagerConfig := &marketmanager.MarketManagerConfig{
		VerificationWindow: 500 * time.Millisecond,
		MaxMarkets:         10000,
	}
	marketDataManager := marketmanager.NewMarketManager(marketDataManagerConfig)

	// Initialize stats
	stats := &ArbitrageStats{
		TotalProfitRealized: big.NewInt(0),
		TotalGasSpent:       big.NewInt(0),
	}

	service := &ArbitrageService{
		client:            client,
		logger:            logger,
		config:            config,
		keyManager:        keyManager,
		multiHopScanner:   multiHopScanner,
		executor:          executor,
		marketManager:     marketManager,
		marketDataManager: marketDataManager,
		ctx:               ctx,
		cancel:            cancel,
		stats:             stats,
		database:          database,
		tokenCache:        make(map[common.Address]TokenPair),
	}

	return service, nil
}

// convertPoolDataToMarket converts existing PoolData to marketmanager.Market
func (sas *ArbitrageService) convertPoolDataToMarket(poolData *market.PoolData, protocol string) *marketmanager.Market {
	// Create raw ticker from token addresses
	rawTicker := fmt.Sprintf("%s_%s", poolData.Token0.Hex(), poolData.Token1.Hex())

	// Create ticker (using token symbols would require token registry)
	ticker := fmt.Sprintf("TOKEN0_TOKEN1") // Placeholder - would need token symbol lookup in real implementation

	// Convert uint256 values to big.Int/big.Float
	liquidity := new(big.Int)
	if poolData.Liquidity != nil {
		liquidity.Set(poolData.Liquidity.ToBig())
	}

	sqrtPriceX96 := new(big.Int)
	if poolData.SqrtPriceX96 != nil {
		sqrtPriceX96.Set(poolData.SqrtPriceX96.ToBig())
	}

	// Calculate approximate price from sqrtPriceX96
	price := big.NewFloat(0)
	if sqrtPriceX96.Sign() > 0 {
		// Price = (sqrtPriceX96 / 2^96)^2
		// Convert to big.Float for precision
		sqrtPriceFloat := new(big.Float).SetInt(sqrtPriceX96)
		q96 := new(big.Float).SetInt(new(big.Int).Exp(big.NewInt(2), big.NewInt(96), nil))
		ratio := new(big.Float).Quo(sqrtPriceFloat, q96)
		price.Mul(ratio, ratio)
	}

	// Create market with converted data
	marketObj := marketmanager.NewMarket(
		common.HexToAddress("0x1F98431c8aD98523631AE4a59f267346ea31F984"), // Uniswap V3 Factory
		poolData.Address,
		poolData.Token0,
		poolData.Token1,
		uint32(poolData.Fee),
		ticker,
		rawTicker,
		protocol,
	)

	// Update price and liquidity data
	marketObj.UpdatePriceData(
		price,
		liquidity,
		sqrtPriceX96,
		int32(poolData.Tick),
	)

	// Update metadata
	marketObj.UpdateMetadata(
		time.Now().Unix(),
		0,             // Block number would need to be fetched
		common.Hash{}, // TxHash would need to be fetched
		marketmanager.StatusConfirmed,
	)

	return marketObj
}

// convertMarketToPoolData converts marketmanager.Market to PoolData
func (sas *ArbitrageService) convertMarketToPoolData(marketObj *marketmanager.Market) *market.PoolData {
	// Convert big.Int to uint256.Int
	liquidity := uint256.NewInt(0)
	if marketObj.Liquidity != nil {
		liquidity.SetFromBig(marketObj.Liquidity)
	}

	sqrtPriceX96 := uint256.NewInt(0)
	if marketObj.SqrtPriceX96 != nil {
		sqrtPriceX96.SetFromBig(marketObj.SqrtPriceX96)
	}

	// Create PoolData with converted values
	return &market.PoolData{
		Address:      marketObj.PoolAddress,
		Token0:       marketObj.Token0,
		Token1:       marketObj.Token1,
		Fee:          int64(marketObj.Fee),
		Liquidity:    liquidity,
		SqrtPriceX96: sqrtPriceX96,
		Tick:         int(marketObj.Tick),
		TickSpacing:  60, // Default for 0.3% fee tier
		LastUpdated:  time.Now(),
	}
}

// syncMarketData synchronizes market data between the two market managers
// marketDataSyncer periodically syncs market data between managers
func (sas *ArbitrageService) marketDataSyncer() {
	sas.logger.Info("Starting market data syncer...")

	ticker := time.NewTicker(10 * time.Second) // Sync every 10 seconds
	defer ticker.Stop()

	for {
		select {
		case <-sas.ctx.Done():
			sas.logger.Info("Market data syncer stopped")
			return
		case <-ticker.C:
			sas.syncMarketData()

			// Example of how to use the new market manager for arbitrage detection
			// This would be integrated with the existing arbitrage detection logic
			sas.performAdvancedArbitrageDetection()
		}
	}
}

// performAdvancedArbitrageDetection uses the new market manager for enhanced arbitrage detection
func (sas *ArbitrageService) performAdvancedArbitrageDetection() {
	// This would use the marketmanager's arbitrage detection capabilities
	// For example:
	// 1. Get markets from the new manager
	// 2. Use the marketmanager's arbitrage detector
	// 3. Convert results to the existing format

	// Example placeholder:
	sas.logger.Debug("Performing advanced arbitrage detection with new market manager")

	// In a real implementation, you would:
	// 1. Get relevant markets from marketDataManager
	// 2. Use marketmanager.NewArbitrageDetector() to create detector
	// 3. Call detector.DetectArbitrageOpportunities() with markets
	// 4. Convert opportunities to the existing format
	// 5. Process them with the existing execution logic
}

// Start begins the simplified arbitrage service
func (sas *ArbitrageService) Start() error {
	sas.runMutex.Lock()
	defer sas.runMutex.Unlock()

	if sas.isRunning {
		return fmt.Errorf("arbitrage service is already running")
	}

	sas.logger.Info("Starting simplified arbitrage service...")

	// Start worker goroutines
	go sas.statsUpdater()
	go sas.blockchainMonitor()
	go sas.marketDataSyncer() // Start market data synchronization

	sas.isRunning = true
	sas.logger.Info("Simplified arbitrage service started successfully")

	return nil
}

// Stop stops the arbitrage service
func (sas *ArbitrageService) Stop() error {
	sas.runMutex.Lock()
	defer sas.runMutex.Unlock()

	if !sas.isRunning {
		return nil
	}

	sas.logger.Info("Stopping simplified arbitrage service...")

	// Cancel context to stop all workers
	sas.cancel()

	sas.isRunning = false
	sas.logger.Info("Simplified arbitrage service stopped")

	return nil
}

// ProcessSwapEvent processes a swap event for arbitrage opportunities
func (sas *ArbitrageService) ProcessSwapEvent(event *SimpleSwapEvent) error {
	sas.logger.Debug(fmt.Sprintf("Processing swap event: token0=%s, token1=%s, amount0=%s, amount1=%s",
		event.Token0.Hex(), event.Token1.Hex(), event.Amount0.String(), event.Amount1.String()))

	// Check if this swap is large enough to potentially move prices
	if !sas.isSignificantSwap(event) {
		return nil
	}

	// Scan for arbitrage opportunities
	return sas.detectArbitrageOpportunities(event)
}

// isSignificantSwap checks if a swap is large enough to create arbitrage opportunities
func (sas *ArbitrageService) isSignificantSwap(event *SimpleSwapEvent) bool {
	// Convert amounts to absolute values for comparison
	amount0Abs := new(big.Int).Abs(event.Amount0)
	amount1Abs := new(big.Int).Abs(event.Amount1)

	// Check if either amount is above our threshold
	minSwapSize := big.NewInt(sas.config.MinSignificantSwapSize)

	return amount0Abs.Cmp(minSwapSize) > 0 || amount1Abs.Cmp(minSwapSize) > 0
}

// detectArbitrageOpportunities scans for arbitrage opportunities triggered by an event
func (sas *ArbitrageService) detectArbitrageOpportunities(event *SimpleSwapEvent) error {
	start := time.Now()

	// Determine the tokens involved in potential arbitrage
	tokens := []common.Address{event.Token0, event.Token1}

	var allOpportunities []*ArbitrageOpportunity

	// Scan for opportunities starting with each token
	for _, token := range tokens {
		// Determine appropriate amount to use for scanning
		scanAmount := sas.calculateScanAmount(event, token)

		// Use multi-hop scanner to find arbitrage paths
		paths, err := sas.multiHopScanner.ScanForArbitrage(sas.ctx, token, scanAmount)
		if err != nil {
			sas.logger.Debug(fmt.Sprintf("Arbitrage scan failed for token %s: %v", token.Hex(), err))
			continue
		}

		// Convert paths to opportunities
		for _, path := range paths {
			if sas.isValidOpportunity(path) {
				opportunity := &ArbitrageOpportunity{
					ID:              sas.generateOpportunityID(path, event),
					Path:            path,
					DetectedAt:      time.Now(),
					EstimatedProfit: path.NetProfit,
					RequiredAmount:  scanAmount,
					Urgency:         sas.calculateUrgency(path),
					ExpiresAt:       time.Now().Add(sas.config.OpportunityTTL),
				}
				allOpportunities = append(allOpportunities, opportunity)
			}
		}
	}

	// Sort opportunities by urgency and profit
	sas.rankOpportunities(allOpportunities)

	// Process top opportunities
	maxOpportunities := sas.config.MaxOpportunitiesPerEvent
	for i, opportunity := range allOpportunities {
		if i >= maxOpportunities {
			break
		}

		// Update stats
		sas.statsMutex.Lock()
		sas.stats.TotalOpportunitiesDetected++
		sas.statsMutex.Unlock()

		// Save to database
		if err := sas.database.SaveOpportunity(sas.ctx, opportunity); err != nil {
			sas.logger.Warn(fmt.Sprintf("Failed to save opportunity to database: %v", err))
		}

		// Execute if execution is enabled
		if sas.config.MaxConcurrentExecutions > 0 {
			go sas.executeOpportunity(opportunity)
		}
	}

	elapsed := time.Since(start)
	sas.logger.Debug(fmt.Sprintf("Arbitrage detection completed in %v: found %d opportunities",
		elapsed, len(allOpportunities)))

	return nil
}

// executeOpportunity executes a single arbitrage opportunity
func (sas *ArbitrageService) executeOpportunity(opportunity *ArbitrageOpportunity) {
	// Check if opportunity is still valid
	if time.Now().After(opportunity.ExpiresAt) {
		sas.logger.Debug(fmt.Sprintf("Opportunity %s expired", opportunity.ID))
		return
	}

	// Update stats
	sas.statsMutex.Lock()
	sas.stats.TotalOpportunitiesExecuted++
	sas.statsMutex.Unlock()

	// Prepare execution parameters
	params := &ArbitrageParams{
		Path:            opportunity.Path,
		InputAmount:     opportunity.RequiredAmount,
		MinOutputAmount: sas.calculateMinOutput(opportunity),
		Deadline:        big.NewInt(time.Now().Add(5 * time.Minute).Unix()),
		FlashSwapData:   []byte{}, // Additional data if needed
	}

	sas.logger.Info(fmt.Sprintf("Executing arbitrage opportunity %s with estimated profit %s ETH",
		opportunity.ID, formatEther(opportunity.EstimatedProfit)))

	// Execute the arbitrage
	result, err := sas.executor.ExecuteArbitrage(sas.ctx, params)
	if err != nil {
		sas.logger.Error(fmt.Sprintf("Arbitrage execution failed for opportunity %s: %v",
			opportunity.ID, err))
		return
	}

	// Process execution results
	sas.processExecutionResult(result)
}

// Helper methods from the original service
func (sas *ArbitrageService) isValidOpportunity(path *ArbitragePath) bool {
	minProfit := big.NewInt(sas.config.MinProfitWei)
	if path.NetProfit.Cmp(minProfit) < 0 {
		return false
	}

	if path.ROI < sas.config.MinROIPercent {
		return false
	}

	if time.Since(path.LastUpdated) > sas.config.MaxPathAge {
		return false
	}

	currentGasPrice, err := sas.client.SuggestGasPrice(sas.ctx)
	if err != nil {
		currentGasPrice = big.NewInt(sas.config.MaxGasPriceWei)
	}

	return sas.executor.IsProfitableAfterGas(path, currentGasPrice)
}

func (sas *ArbitrageService) calculateScanAmount(event *SimpleSwapEvent, token common.Address) *big.Int {
	var swapAmount *big.Int

	if token == event.Token0 {
		swapAmount = new(big.Int).Abs(event.Amount0)
	} else {
		swapAmount = new(big.Int).Abs(event.Amount1)
	}

	scanAmount := new(big.Int).Div(swapAmount, big.NewInt(10))

	minAmount := big.NewInt(sas.config.MinScanAmountWei)
	if scanAmount.Cmp(minAmount) < 0 {
		scanAmount = minAmount
	}

	maxAmount := big.NewInt(sas.config.MaxScanAmountWei)
	if scanAmount.Cmp(maxAmount) > 0 {
		scanAmount = maxAmount
	}

	return scanAmount
}

func (sas *ArbitrageService) calculateUrgency(path *ArbitragePath) int {
	urgency := int(path.ROI / 2)

	profitETH := new(big.Float).SetInt(path.NetProfit)
	profitETH.Quo(profitETH, big.NewFloat(1e18))
	profitFloat, _ := profitETH.Float64()

	if profitFloat > 1.0 {
		urgency += 5
	} else if profitFloat > 0.1 {
		urgency += 2
	}

	if urgency < 1 {
		urgency = 1
	}
	if urgency > 10 {
		urgency = 10
	}

	return urgency
}

func (sas *ArbitrageService) rankOpportunities(opportunities []*ArbitrageOpportunity) {
	for i := 0; i < len(opportunities); i++ {
		for j := i + 1; j < len(opportunities); j++ {
			iOpp := opportunities[i]
			jOpp := opportunities[j]

			if jOpp.Urgency > iOpp.Urgency {
				opportunities[i], opportunities[j] = opportunities[j], opportunities[i]
			} else if jOpp.Urgency == iOpp.Urgency {
				if jOpp.EstimatedProfit.Cmp(iOpp.EstimatedProfit) > 0 {
					opportunities[i], opportunities[j] = opportunities[j], opportunities[i]
				}
			}
		}
	}
}

func (sas *ArbitrageService) calculateMinOutput(opportunity *ArbitrageOpportunity) *big.Int {
	expectedOutput := new(big.Int).Add(opportunity.RequiredAmount, opportunity.EstimatedProfit)

	slippageTolerance := sas.config.SlippageTolerance
	slippageMultiplier := big.NewFloat(1.0 - slippageTolerance)

	expectedFloat := new(big.Float).SetInt(expectedOutput)
	minOutputFloat := new(big.Float).Mul(expectedFloat, slippageMultiplier)

	minOutput := new(big.Int)
	minOutputFloat.Int(minOutput)

	return minOutput
}

func (sas *ArbitrageService) processExecutionResult(result *ExecutionResult) {
	sas.statsMutex.Lock()
	if result.Success {
		sas.stats.TotalSuccessfulExecutions++
		sas.stats.TotalProfitRealized.Add(sas.stats.TotalProfitRealized, result.ProfitRealized)
	}

	gasCost := new(big.Int).Mul(result.GasPrice, big.NewInt(int64(result.GasUsed)))
	sas.stats.TotalGasSpent.Add(sas.stats.TotalGasSpent, gasCost)
	sas.stats.LastExecutionTime = time.Now()
	sas.statsMutex.Unlock()

	if err := sas.database.SaveExecution(sas.ctx, result); err != nil {
		sas.logger.Warn(fmt.Sprintf("Failed to save execution result to database: %v", err))
	}

	if result.Success {
		sas.logger.Info(fmt.Sprintf("Arbitrage execution successful: TX %s, Profit: %s ETH, Gas: %d",
			result.TransactionHash.Hex(), formatEther(result.ProfitRealized), result.GasUsed))
	} else {
		sas.logger.Error(fmt.Sprintf("Arbitrage execution failed: TX %s, Error: %v",
			result.TransactionHash.Hex(), result.Error))
	}
}

func (sas *ArbitrageService) statsUpdater() {
	defer sas.logger.Info("Stats updater stopped")

	ticker := time.NewTicker(sas.config.StatsUpdateInterval)
	defer ticker.Stop()

	for {
		select {
		case <-sas.ctx.Done():
			return
		case <-ticker.C:
			sas.logStats()
		}
	}
}

func (sas *ArbitrageService) logStats() {
	sas.statsMutex.RLock()
	stats := *sas.stats
	sas.statsMutex.RUnlock()

	successRate := 0.0
	if stats.TotalOpportunitiesExecuted > 0 {
		successRate = float64(stats.TotalSuccessfulExecutions) / float64(stats.TotalOpportunitiesExecuted) * 100
	}

	sas.logger.Info(fmt.Sprintf("Arbitrage Service Stats - Detected: %d, Executed: %d, Success Rate: %.2f%%, "+
		"Total Profit: %s ETH, Total Gas: %s ETH",
		stats.TotalOpportunitiesDetected,
		stats.TotalOpportunitiesExecuted,
		successRate,
		formatEther(stats.TotalProfitRealized),
		formatEther(stats.TotalGasSpent)))
}

func (sas *ArbitrageService) generateOpportunityID(path *ArbitragePath, event *SimpleSwapEvent) string {
	return fmt.Sprintf("%s_%s_%d", event.TxHash.Hex()[:10], path.Tokens[0].Hex()[:8], time.Now().UnixNano())
}

func (sas *ArbitrageService) GetStats() *ArbitrageStats {
	sas.statsMutex.RLock()
	defer sas.statsMutex.RUnlock()

	statsCopy := *sas.stats
	return &statsCopy
}

func (sas *ArbitrageService) IsRunning() bool {
	sas.runMutex.RLock()
	defer sas.runMutex.RUnlock()
	return sas.isRunning
}

// blockchainMonitor monitors the Arbitrum sequencer using the ORIGINAL ArbitrumMonitor with ArbitrumL2Parser
func (sas *ArbitrageService) blockchainMonitor() {
	defer sas.logger.Info("💀 ARBITRUM SEQUENCER MONITOR STOPPED - Full sequencer reading terminated")

	sas.logger.Info("🚀 STARTING ARBITRUM SEQUENCER MONITOR FOR MEV OPPORTUNITIES")
	sas.logger.Info("🔧 Initializing complete Arbitrum L2 parser for FULL transaction analysis")
	sas.logger.Info("🎯 This is the ORIGINAL sequencer reader architecture - NOT simplified!")
	sas.logger.Info("📊 Full DEX transaction parsing, arbitrage detection, and market analysis enabled")

	// Create the proper Arbitrum monitor with sequencer reader using ORIGINAL architecture
	monitor, err := sas.createArbitrumMonitor()
	if err != nil {
		sas.logger.Error(fmt.Sprintf("❌ CRITICAL: Failed to create Arbitrum monitor: %v", err))
		sas.logger.Error("❌ FALLBACK: Using basic block polling instead of proper sequencer reader")
		// Fallback to basic block monitoring
		sas.fallbackBlockPolling()
		return
	}

	sas.logger.Info("✅ ARBITRUM SEQUENCER MONITOR CREATED SUCCESSFULLY")
	sas.logger.Info("🔄 Starting to monitor Arbitrum sequencer feed for LIVE transactions...")
	sas.logger.Info("📡 Full L2 transaction parsing, DEX detection, and arbitrage scanning active")

	// Start the monitor with full logging
	if err := monitor.Start(sas.ctx); err != nil {
		sas.logger.Error(fmt.Sprintf("❌ CRITICAL: Failed to start Arbitrum monitor: %v", err))
		sas.logger.Error("❌ EMERGENCY FALLBACK: Switching to basic block polling")
		sas.fallbackBlockPolling()
		return
	}

	sas.logger.Info("🎉 ARBITRUM SEQUENCER MONITORING STARTED - PROCESSING LIVE TRANSACTIONS")
	sas.logger.Info("📈 Real-time DEX transaction detection, arbitrage opportunities, and profit analysis active")
	sas.logger.Info("⚡ Full market pipeline, scanner, and MEV coordinator operational")

	// Keep the monitor running with status logging
	ticker := time.NewTicker(30 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-sas.ctx.Done():
			sas.logger.Info("🛑 Context cancelled - stopping Arbitrum sequencer monitor...")
			return
		case <-ticker.C:
			sas.logger.Info("💓 Arbitrum sequencer monitor heartbeat - actively scanning for MEV opportunities")
			sas.logger.Info("📊 Monitor status: ACTIVE | Sequencer: CONNECTED | Parser: OPERATIONAL")
		}
	}
}

// fallbackBlockPolling provides fallback block monitoring through polling with EXTENSIVE LOGGING
func (sas *ArbitrageService) fallbackBlockPolling() {
	sas.logger.Info("⚠️  USING FALLBACK BLOCK POLLING - This is NOT the proper sequencer reader!")
	sas.logger.Info("⚠️  This fallback method has limited transaction analysis capabilities")
	sas.logger.Info("⚠️  For full MEV detection, the proper ArbitrumMonitor with L2Parser should be used")

	ticker := time.NewTicker(3 * time.Second) // Poll every 3 seconds
	defer ticker.Stop()

	var lastBlock uint64
	processedBlocks := 0
	foundSwaps := 0

	for {
		select {
		case <-sas.ctx.Done():
			sas.logger.Info(fmt.Sprintf("🛑 Fallback block polling stopped. Processed %d blocks, found %d swaps", processedBlocks, foundSwaps))
			return
		case <-ticker.C:
			header, err := sas.client.HeaderByNumber(sas.ctx, nil)
			if err != nil {
				sas.logger.Error(fmt.Sprintf("❌ Failed to get latest block: %v", err))
				continue
			}

			if header.Number.Uint64() > lastBlock {
				lastBlock = header.Number.Uint64()
				processedBlocks++
				sas.logger.Info(fmt.Sprintf("📦 Processing block %d (fallback mode) - total processed: %d", lastBlock, processedBlocks))
				swapsFound := sas.processNewBlock(header)
				if swapsFound > 0 {
					foundSwaps += swapsFound
					sas.logger.Info(fmt.Sprintf("💰 Found %d swaps in block %d - total swaps found: %d", swapsFound, lastBlock, foundSwaps))
				}
			}
		}
	}
}

// processNewBlock processes a new block looking for swap events with EXTENSIVE LOGGING
func (sas *ArbitrageService) processNewBlock(header *types.Header) int {
	blockNumber := header.Number.Uint64()

	// Skip processing if block has no transactions
	if header.TxHash == (common.Hash{}) {
		sas.logger.Info(fmt.Sprintf("📦 Block %d: EMPTY BLOCK - no transactions to process", blockNumber))
		return 0
	}

	sas.logger.Info(fmt.Sprintf("🔍 PROCESSING BLOCK %d FOR UNISWAP V3 SWAP EVENTS", blockNumber))
	sas.logger.Info(fmt.Sprintf("📊 Block %d: Hash=%s, Timestamp=%d", blockNumber, header.Hash().Hex(), header.Time))

	// Instead of getting full block (which fails with unsupported tx types),
	// we'll scan the block's logs directly for Uniswap V3 Swap events
	swapEvents := sas.getSwapEventsFromBlock(blockNumber)

	if len(swapEvents) > 0 {
		sas.logger.Info(fmt.Sprintf("💰 FOUND %d SWAP EVENTS IN BLOCK %d - PROCESSING FOR ARBITRAGE", len(swapEvents), blockNumber))

		// Process each swap event with detailed logging
		for i, event := range swapEvents {
			sas.logger.Info(fmt.Sprintf("🔄 Processing swap event %d/%d from block %d", i+1, len(swapEvents), blockNumber))
			sas.logger.Info(fmt.Sprintf("💱 Swap details: Pool=%s, Amount0=%s, Amount1=%s",
				event.PoolAddress.Hex(), event.Amount0.String(), event.Amount1.String()))

			go func(e *SimpleSwapEvent, index int) {
				sas.logger.Info(fmt.Sprintf("⚡ Starting arbitrage analysis for swap %d from block %d", index+1, blockNumber))
				if err := sas.ProcessSwapEvent(e); err != nil {
					sas.logger.Error(fmt.Sprintf("❌ Failed to process swap event %d: %v", index+1, err))
				} else {
					sas.logger.Info(fmt.Sprintf("✅ Successfully processed swap event %d for arbitrage opportunities", index+1))
				}
			}(event, i)
		}
	} else {
		sas.logger.Info(fmt.Sprintf("📦 Block %d: NO SWAP EVENTS FOUND - continuing to monitor", blockNumber))
	}

	return len(swapEvents)
}

// processTransaction analyzes a transaction for swap events
func (sas *ArbitrageService) processTransaction(tx *types.Transaction, blockNumber uint64) bool {
	// Get transaction receipt to access logs
	receipt, err := sas.client.TransactionReceipt(sas.ctx, tx.Hash())
	if err != nil {
		return false // Skip if we can't get receipt
	}

	swapFound := false
	// Look for Uniswap V3 Swap events
	for _, log := range receipt.Logs {
		event := sas.parseSwapLog(log, tx, blockNumber)
		if event != nil {
			swapFound = true
			sas.logger.Info(fmt.Sprintf("Found swap event: %s/%s, amounts: %s/%s",
				event.Token0.Hex()[:10], event.Token1.Hex()[:10],
				event.Amount0.String(), event.Amount1.String()))

			// Process the swap event asynchronously to avoid blocking
			go func(e *SimpleSwapEvent) {
				if err := sas.ProcessSwapEvent(e); err != nil {
					sas.logger.Debug(fmt.Sprintf("Failed to process swap event: %v", err))
				}
			}(event)
		}
	}
	return swapFound
}

// parseSwapLog attempts to parse a log as a Uniswap V3 Swap event
func (sas *ArbitrageService) parseSwapLog(log *types.Log, tx *types.Transaction, blockNumber uint64) *SimpleSwapEvent {
	// Uniswap V3 Pool Swap event signature
	// Swap(indexed address sender, indexed address recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick)
	swapEventSig := common.HexToHash("0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67")

	if len(log.Topics) == 0 || log.Topics[0] != swapEventSig {
		return nil
	}

	// Parse the event data
	if len(log.Topics) < 3 || len(log.Data) < 192 { // 6 * 32 bytes
		return nil
	}

	// Extract indexed parameters (sender, recipient)
	// sender := common.BytesToAddress(log.Topics[1].Bytes())
	// recipient := common.BytesToAddress(log.Topics[2].Bytes())

	// Extract non-indexed parameters from data
	amount0 := new(big.Int).SetBytes(log.Data[0:32])
	amount1 := new(big.Int).SetBytes(log.Data[32:64])
	sqrtPriceX96 := new(big.Int).SetBytes(log.Data[64:96])
	liquidity := new(big.Int).SetBytes(log.Data[96:128])

	// Extract tick (int24, but stored as int256)
	tickBytes := log.Data[128:160]
	tick := new(big.Int).SetBytes(tickBytes)
	if tick.Bit(255) == 1 { // Check if negative (two's complement)
		tick.Sub(tick, new(big.Int).Lsh(big.NewInt(1), 256))
	}

	// Get pool tokens by querying the actual pool contract
	token0, token1, err := sas.getPoolTokens(log.Address)
	if err != nil {
		return nil // Skip if we can't get pool tokens
	}

	return &SimpleSwapEvent{
		TxHash:       tx.Hash(),
		PoolAddress:  log.Address,
		Token0:       token0,
		Token1:       token1,
		Amount0:      amount0,
		Amount1:      amount1,
		SqrtPriceX96: sqrtPriceX96,
		Liquidity:    liquidity,
		Tick:         int32(tick.Int64()),
		BlockNumber:  blockNumber,
		LogIndex:     log.Index,
		Timestamp:    time.Now(),
	}
}

// getPoolTokens retrieves token addresses for a Uniswap V3 pool with caching
func (sas *ArbitrageService) getPoolTokens(poolAddress common.Address) (token0, token1 common.Address, err error) {
	// Check cache first
	sas.tokenCacheMutex.RLock()
	if cached, exists := sas.tokenCache[poolAddress]; exists {
		sas.tokenCacheMutex.RUnlock()
		return cached.Token0, cached.Token1, nil
	}
	sas.tokenCacheMutex.RUnlock()

	// Create timeout context for contract calls
	ctx, cancel := context.WithTimeout(sas.ctx, 5*time.Second)
	defer cancel()

	// Pre-computed function selectors for token0() and token1()
	token0Selector := []byte{0x0d, 0xfe, 0x16, 0x81} // token0()
	token1Selector := []byte{0xd2, 0x1c, 0xec, 0xd4} // token1()

	// Call token0() function
	token0Data, err := sas.client.CallContract(ctx, ethereum.CallMsg{
		To:   &poolAddress,
		Data: token0Selector,
	}, nil)
	if err != nil {
		return common.Address{}, common.Address{}, fmt.Errorf("failed to call token0(): %w", err)
	}

	// Call token1() function
	token1Data, err := sas.client.CallContract(ctx, ethereum.CallMsg{
		To:   &poolAddress,
		Data: token1Selector,
	}, nil)
	if err != nil {
		return common.Address{}, common.Address{}, fmt.Errorf("failed to call token1(): %w", err)
	}

	// Parse the results
	if len(token0Data) < 32 || len(token1Data) < 32 {
		return common.Address{}, common.Address{}, fmt.Errorf("invalid token data length")
	}

	token0 = common.BytesToAddress(token0Data[12:32])
	token1 = common.BytesToAddress(token1Data[12:32])

	// Cache the result
	sas.tokenCacheMutex.Lock()
	sas.tokenCache[poolAddress] = TokenPair{Token0: token0, Token1: token1}
	sas.tokenCacheMutex.Unlock()

	return token0, token1, nil
}

// getSwapEventsFromBlock retrieves Uniswap V3 swap events from a specific block using log filtering
func (sas *ArbitrageService) getSwapEventsFromBlock(blockNumber uint64) []*SimpleSwapEvent {
	// Uniswap V3 Pool Swap event signature
	swapEventSig := common.HexToHash("0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67")

	// Create filter query for this specific block
	query := ethereum.FilterQuery{
		FromBlock: big.NewInt(int64(blockNumber)),
		ToBlock:   big.NewInt(int64(blockNumber)),
		Topics:    [][]common.Hash{{swapEventSig}},
	}

	// Get logs for this block
	logs, err := sas.client.FilterLogs(sas.ctx, query)
	if err != nil {
		sas.logger.Debug(fmt.Sprintf("Failed to get logs for block %d: %v", blockNumber, err))
		return nil
	}

	// Debug: Log how many logs we found for this block
	if len(logs) > 0 {
		sas.logger.Info(fmt.Sprintf("Found %d potential swap logs in block %d", len(logs), blockNumber))
	}

	var swapEvents []*SimpleSwapEvent

	// Parse each log into a swap event
	for _, log := range logs {
		event := sas.parseSwapEvent(log, blockNumber)
		if event != nil {
			swapEvents = append(swapEvents, event)
			sas.logger.Info(fmt.Sprintf("Successfully parsed swap event: pool=%s, amount0=%s, amount1=%s",
				event.PoolAddress.Hex(), event.Amount0.String(), event.Amount1.String()))
		} else {
			sas.logger.Debug(fmt.Sprintf("Failed to parse swap log from pool %s", log.Address.Hex()))
		}
	}

	return swapEvents
}

// parseSwapEvent parses a log entry into a SimpleSwapEvent
// createArbitrumMonitor creates the ORIGINAL ArbitrumMonitor with full sequencer reading capabilities
func (sas *ArbitrageService) createArbitrumMonitor() (*monitor.ArbitrumMonitor, error) {
	sas.logger.Info("🏗️  CREATING ORIGINAL ARBITRUM MONITOR WITH FULL SEQUENCER READER")
	sas.logger.Info("🔧 This will use ArbitrumL2Parser for proper transaction analysis")
	sas.logger.Info("📡 Full MEV detection, market analysis, and arbitrage scanning enabled")

	// Get RPC endpoints from environment variables
	rpcEndpoint := os.Getenv("ARBITRUM_RPC_ENDPOINT")
	if rpcEndpoint == "" {
		return nil, fmt.Errorf("ARBITRUM_RPC_ENDPOINT environment variable is required")
	}

	wsEndpoint := os.Getenv("ARBITRUM_WS_ENDPOINT")
	if wsEndpoint == "" {
		wsEndpoint = rpcEndpoint // Fallback to RPC endpoint
	}

	// Create Arbitrum configuration from environment
	arbConfig := &config.ArbitrumConfig{
		RPCEndpoint: rpcEndpoint,
		WSEndpoint:  wsEndpoint,
		ChainID:     42161,
		RateLimit: config.RateLimitConfig{
			RequestsPerSecond: 100,
			Burst:             200,
		},
	}

	// Create bot configuration
	botConfig := &config.BotConfig{
		PollingInterval:    1, // 1 second polling
		MaxWorkers:         10,
		ChannelBufferSize:  100,
		RPCTimeout:         30,
		MinProfitThreshold: 0.01, // 1% minimum profit
		GasPriceMultiplier: 1.2,  // 20% gas price premium
		Enabled:            true,
	}

	sas.logger.Info(fmt.Sprintf("📊 Arbitrum config: RPC=%s, ChainID=%d",
		arbConfig.RPCEndpoint, arbConfig.ChainID))

	// Create rate limiter manager
	rateLimiter := ratelimit.NewLimiterManager(arbConfig)
	sas.logger.Info("⚡ Rate limiter manager created for RPC throttling")

	// Price oracle will be added later when needed
	sas.logger.Info("💰 Price oracle support ready")

	// Create market manager for pool management
	uniswapConfig := &config.UniswapConfig{
		FactoryAddress:         "0x1F98431c8aD98523631AE4a59f267346ea31F984", // Uniswap V3 Factory
		PositionManagerAddress: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88", // Uniswap V3 Position Manager
		FeeTiers:               []int64{100, 500, 3000, 10000},               // 0.01%, 0.05%, 0.3%, 1%
		Cache: config.CacheConfig{
			Enabled:    true,
			Expiration: 300, // 5 minutes
			MaxSize:    1000,
		},
	}
	marketManager := market.NewMarketManager(uniswapConfig, sas.logger)
	sas.logger.Info("🏪 Market manager created for pool data management")

	// Create a proper config.Config for ContractExecutor
	cfg := &config.Config{
		Arbitrum: *arbConfig,
		Contracts: config.ContractsConfig{
			ArbitrageExecutor: sas.config.ArbitrageContractAddress,
			FlashSwapper:      sas.config.FlashSwapContractAddress,
		},
	}

	// Create ContractExecutor
	contractExecutor, err := contracts.NewContractExecutor(cfg, sas.logger, sas.keyManager)
	if err != nil {
		return nil, fmt.Errorf("failed to create contract executor: %w", err)
	}

	// Create market scanner for arbitrage detection
	marketScanner := scanner.NewMarketScanner(botConfig, sas.logger, contractExecutor, nil)
	sas.logger.Info("🔍 Market scanner created for arbitrage opportunity detection")

	// Create the ORIGINAL ArbitrumMonitor
	sas.logger.Info("🚀 Creating ArbitrumMonitor with full sequencer reading capabilities...")
	monitor, err := monitor.NewArbitrumMonitor(
		arbConfig,
		botConfig,
		sas.logger,
		rateLimiter,
		marketManager,
		marketScanner,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to create ArbitrumMonitor: %w", err)
	}

	sas.logger.Info("✅ ORIGINAL ARBITRUM MONITOR CREATED SUCCESSFULLY")
	sas.logger.Info("🎯 Full sequencer reader with ArbitrumL2Parser operational")
	sas.logger.Info("💡 DEX transaction parsing, MEV coordinator, and market pipeline active")
	sas.logger.Info("📈 Real-time arbitrage detection and profit analysis enabled")

	return monitor, nil
}

func (sas *ArbitrageService) parseSwapEvent(log types.Log, blockNumber uint64) *SimpleSwapEvent {
	// Validate log structure
	if len(log.Topics) < 3 || len(log.Data) < 192 { // 6 * 32 bytes
		sas.logger.Debug(fmt.Sprintf("Invalid log structure: topics=%d, data_len=%d", len(log.Topics), len(log.Data)))
		return nil
	}

	// Extract non-indexed parameters from data
	amount0 := new(big.Int).SetBytes(log.Data[0:32])
	amount1 := new(big.Int).SetBytes(log.Data[32:64])
	sqrtPriceX96 := new(big.Int).SetBytes(log.Data[64:96])
	liquidity := new(big.Int).SetBytes(log.Data[96:128])

	// Extract tick (int24, but stored as int256)
	tickBytes := log.Data[128:160]
	tick := new(big.Int).SetBytes(tickBytes)
	if tick.Bit(255) == 1 { // Check if negative (two's complement)
		tick.Sub(tick, new(big.Int).Lsh(big.NewInt(1), 256))
	}

	// Get pool tokens by querying the actual pool contract
	token0, token1, err := sas.getPoolTokens(log.Address)
	if err != nil {
		sas.logger.Error(fmt.Sprintf("Failed to get tokens for pool %s: %v", log.Address.Hex(), err))
		return nil // Skip if we can't get pool tokens
	}

	sas.logger.Debug(fmt.Sprintf("Successfully got pool tokens: %s/%s for pool %s",
		token0.Hex(), token1.Hex(), log.Address.Hex()))

	return &SimpleSwapEvent{
		TxHash:       log.TxHash,
		PoolAddress:  log.Address,
		Token0:       token0,
		Token1:       token1,
		Amount0:      amount0,
		Amount1:      amount1,
		SqrtPriceX96: sqrtPriceX96,
		Liquidity:    liquidity,
		Tick:         int32(tick.Int64()),
		BlockNumber:  blockNumber,
		LogIndex:     log.Index,
		Timestamp:    time.Now(),
	}
}

// syncMarketData synchronizes market data between the two market managers
func (sas *ArbitrageService) syncMarketData() {
	sas.logger.Debug("Syncing market data between managers")

	// Example of how to synchronize market data
	// In a real implementation, you would iterate through pools from the existing manager
	// and convert/add them to the new manager

	// This is a placeholder showing the pattern:
	// 1. Get pool data from existing manager
	// 2. Convert to marketmanager format
	// 3. Add to new manager

	// Example:
	// poolAddress := common.HexToAddress("0x...") // Some pool address
	// poolData, err := sas.marketManager.GetPool(sas.ctx, poolAddress)
	// if err == nil {
	//     marketObj := sas.convertPoolDataToMarket(poolData, "UniswapV3")
	//     if err := sas.marketDataManager.AddMarket(marketObj); err != nil {
	//         sas.logger.Warn("Failed to add market to manager: ", err)
	//     }
	// }

	sas.logger.Debug("Market data sync completed")
}