package arbitrage

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

	"github.com/ethereum/go-ethereum/common"

	"coppertone.tech/fraktal/mev-bot/pkg/cache"
	"coppertone.tech/fraktal/mev-bot/pkg/observability"
	"coppertone.tech/fraktal/mev-bot/pkg/types"
)

// SimpleDetector implements basic 2-hop arbitrage detection for MVP
// It focuses on finding simple circular arbitrage opportunities:
// Token A -> Token B -> Token A across two different pools
type SimpleDetector struct {
	poolCache cache.PoolCache
	logger    observability.Logger

	// Configuration
	minProfitBPS     *big.Int // Minimum profit in basis points (1 BPS = 0.01%)
	maxGasCostWei    *big.Int // Maximum acceptable gas cost in wei
	slippageBPS      *big.Int // Slippage tolerance in basis points
	minLiquidityUSD  *big.Int // Minimum pool liquidity in USD

	// State
	mu                 sync.RWMutex
	opportunitiesFound uint64
	lastScanBlock      uint64
}

// Opportunity represents a 2-hop arbitrage opportunity
type Opportunity struct {
	// Path information
	InputToken  common.Address
	BridgeToken common.Address
	OutputToken common.Address

	// Pool information
	FirstPool  *types.PoolInfo
	SecondPool *types.PoolInfo

	// Trade parameters
	InputAmount  *big.Int
	BridgeAmount *big.Int
	OutputAmount *big.Int
	ProfitAmount *big.Int

	// Profitability metrics
	ProfitBPS  *big.Int // Profit in basis points
	GasCostWei *big.Int // Estimated gas cost

	// Metadata
	BlockNumber uint64
	Timestamp   int64
}

// Config holds configuration for the simple detector
type Config struct {
	MinProfitBPS    int64  // Minimum profit in basis points (e.g., 10 = 0.1%)
	MaxGasCostWei   int64  // Maximum acceptable gas cost in wei
	SlippageBPS     int64  // Slippage tolerance in basis points (e.g., 50 = 0.5%)
	MinLiquidityUSD int64  // Minimum pool liquidity in USD
}

// DefaultConfig returns sensible defaults for Fast MVP
func DefaultConfig() Config {
	return Config{
		MinProfitBPS:    10,   // 0.1% minimum profit
		MaxGasCostWei:   1e16, // 0.01 ETH max gas cost
		SlippageBPS:     50,   // 0.5% slippage tolerance
		MinLiquidityUSD: 10000, // $10k minimum liquidity
	}
}

// NewSimpleDetector creates a new simple arbitrage detector
func NewSimpleDetector(poolCache cache.PoolCache, logger observability.Logger, cfg Config) (*SimpleDetector, error) {
	if poolCache == nil {
		return nil, fmt.Errorf("pool cache cannot be nil")
	}
	if logger == nil {
		return nil, fmt.Errorf("logger cannot be nil")
	}

	return &SimpleDetector{
		poolCache:        poolCache,
		logger:           logger,
		minProfitBPS:     big.NewInt(cfg.MinProfitBPS),
		maxGasCostWei:    big.NewInt(cfg.MaxGasCostWei),
		slippageBPS:      big.NewInt(cfg.SlippageBPS),
		minLiquidityUSD:  big.NewInt(cfg.MinLiquidityUSD),
		opportunitiesFound: 0,
		lastScanBlock:      0,
	}, nil
}

// ScanForOpportunities scans for arbitrage opportunities across all cached pools
// This is the main entry point for the detection engine
func (d *SimpleDetector) ScanForOpportunities(ctx context.Context, blockNumber uint64) ([]*Opportunity, error) {
	d.logger.Info("scanning for arbitrage opportunities", "block", blockNumber)

	// Get all pools from cache (use GetByLiquidity with minLiquidity=0 and high limit)
	pools, err := d.poolCache.GetByLiquidity(ctx, big.NewInt(0), 10000)
	if err != nil {
		return nil, fmt.Errorf("failed to get pools from cache: %w", err)
	}
	if len(pools) == 0 {
		d.logger.Warn("no pools in cache, skipping scan")
		return nil, nil
	}

	d.logger.Debug("scanning pools", "count", len(pools))

	// For MVP, we'll focus on simple 2-hop cycles:
	// Find pairs of pools that share a common token (bridge token)
	// Then check if we can profit by trading through both pools

	var opportunities []*Opportunity
	var mu sync.Mutex
	var wg sync.WaitGroup

	// Use a simple concurrent scan approach
	// For each pool, check if it can form a 2-hop cycle with any other pool
	for i := 0; i < len(pools); i++ {
		wg.Add(1)
		go func(pool1Index int) {
			defer wg.Done()

			pool1 := pools[pool1Index]
			localOpps := d.findTwoHopCycles(ctx, pool1, pools)

			if len(localOpps) > 0 {
				mu.Lock()
				opportunities = append(opportunities, localOpps...)
				mu.Unlock()
			}
		}(i)
	}

	wg.Wait()

	// Filter opportunities by profitability
	profitableOpps := d.filterProfitable(opportunities)

	d.mu.Lock()
	d.opportunitiesFound += uint64(len(profitableOpps))
	d.lastScanBlock = blockNumber
	d.mu.Unlock()

	d.logger.Info("scan complete",
		"totalPools", len(pools),
		"opportunities", len(profitableOpps),
		"block", blockNumber,
	)

	return profitableOpps, nil
}

// findTwoHopCycles finds 2-hop arbitrage cycles starting from a given pool
// A 2-hop cycle is: TokenA -> TokenB (via pool1) -> TokenA (via pool2)
func (d *SimpleDetector) findTwoHopCycles(ctx context.Context, pool1 *types.PoolInfo, allPools []*types.PoolInfo) []*Opportunity {
	var opportunities []*Opportunity

	// Check both directions for pool1
	// Direction 1: Token0 -> Token1 -> Token0
	// Direction 2: Token1 -> Token0 -> Token1

	// Direction 1: Swap Token0 for Token1 in pool1
	bridgeToken := pool1.Token1
	startToken := pool1.Token0

	// Find pools that can swap bridgeToken back to startToken
	for _, pool2 := range allPools {
		if pool2.Address == pool1.Address {
			continue // Skip same pool
		}

		// Check if pool2 can convert bridgeToken -> startToken
		if (pool2.Token0 == bridgeToken && pool2.Token1 == startToken) ||
			(pool2.Token1 == bridgeToken && pool2.Token0 == startToken) {

			// Found a potential cycle!
			// Now calculate if it's profitable
			opp := d.calculateOpportunity(ctx, pool1, pool2, startToken, bridgeToken)
			if opp != nil {
				opportunities = append(opportunities, opp)
			}
		}
	}

	// Direction 2: Swap Token1 for Token0 in pool1
	bridgeToken = pool1.Token0
	startToken = pool1.Token1

	// Find pools that can swap bridgeToken back to startToken
	for _, pool2 := range allPools {
		if pool2.Address == pool1.Address {
			continue // Skip same pool
		}

		// Check if pool2 can convert bridgeToken -> startToken
		if (pool2.Token0 == bridgeToken && pool2.Token1 == startToken) ||
			(pool2.Token1 == bridgeToken && pool2.Token0 == startToken) {

			// Found a potential cycle!
			opp := d.calculateOpportunity(ctx, pool1, pool2, startToken, bridgeToken)
			if opp != nil {
				opportunities = append(opportunities, opp)
			}
		}
	}

	return opportunities
}

// calculateOpportunity calculates the profitability of a 2-hop arbitrage
// For MVP, we use a simple constant product formula (UniswapV2 style)
func (d *SimpleDetector) calculateOpportunity(
	ctx context.Context,
	pool1, pool2 *types.PoolInfo,
	inputToken, bridgeToken common.Address,
) *Opportunity {
	// For MVP, use a fixed input amount based on pool liquidity
	// In production, we'd optimize the input amount for maximum profit
	inputAmount := d.estimateOptimalInputAmount(pool1)

	// Step 1: Calculate output from first swap (inputToken -> bridgeToken via pool1)
	bridgeAmount := d.calculateSwapOutput(pool1, inputToken, bridgeToken, inputAmount)
	if bridgeAmount == nil || bridgeAmount.Cmp(big.NewInt(0)) <= 0 {
		return nil
	}

	// Step 2: Calculate output from second swap (bridgeToken -> inputToken via pool2)
	outputAmount := d.calculateSwapOutput(pool2, bridgeToken, inputToken, bridgeAmount)
	if outputAmount == nil || outputAmount.Cmp(big.NewInt(0)) <= 0 {
		return nil
	}

	// Calculate profit (outputAmount - inputAmount)
	profitAmount := new(big.Int).Sub(outputAmount, inputAmount)
	if profitAmount.Cmp(big.NewInt(0)) <= 0 {
		return nil // No profit
	}

	// Calculate profit in basis points: (profit / input) * 10000
	profitBPS := new(big.Int).Mul(profitAmount, big.NewInt(10000))
	profitBPS.Div(profitBPS, inputAmount)

	return &Opportunity{
		InputToken:   inputToken,
		BridgeToken:  bridgeToken,
		OutputToken:  inputToken, // Circle back to input token
		FirstPool:    pool1,
		SecondPool:   pool2,
		InputAmount:  inputAmount,
		BridgeAmount: bridgeAmount,
		OutputAmount: outputAmount,
		ProfitAmount: profitAmount,
		ProfitBPS:    profitBPS,
		GasCostWei:   big.NewInt(1e15), // Placeholder: 0.001 ETH gas estimate
	}
}

// calculateSwapOutput calculates the output amount for a swap using constant product formula
// This is a simplified version for MVP - production would use protocol-specific math
func (d *SimpleDetector) calculateSwapOutput(
	pool *types.PoolInfo,
	tokenIn, tokenOut common.Address,
	amountIn *big.Int,
) *big.Int {
	// Determine reserves based on token direction
	var reserveIn, reserveOut *big.Int

	if pool.Token0 == tokenIn && pool.Token1 == tokenOut {
		reserveIn = pool.Reserve0
		reserveOut = pool.Reserve1
	} else if pool.Token1 == tokenIn && pool.Token0 == tokenOut {
		reserveIn = pool.Reserve1
		reserveOut = pool.Reserve0
	} else {
		d.logger.Warn("token mismatch in pool", "pool", pool.Address.Hex())
		return nil
	}

	// Check reserves are valid
	if reserveIn == nil || reserveOut == nil ||
		reserveIn.Cmp(big.NewInt(0)) <= 0 ||
		reserveOut.Cmp(big.NewInt(0)) <= 0 {
		d.logger.Warn("invalid reserves", "pool", pool.Address.Hex())
		return nil
	}

	// Constant product formula: (amountIn * 997 * reserveOut) / (reserveIn * 1000 + amountIn * 997)
	// The 997/1000 factor accounts for the 0.3% UniswapV2 fee

	amountInWithFee := new(big.Int).Mul(amountIn, big.NewInt(997))
	numerator := new(big.Int).Mul(amountInWithFee, reserveOut)
	denominator := new(big.Int).Mul(reserveIn, big.NewInt(1000))
	denominator.Add(denominator, amountInWithFee)

	amountOut := new(big.Int).Div(numerator, denominator)

	return amountOut
}

// estimateOptimalInputAmount estimates a reasonable input amount for testing
// For MVP, we use 1% of the pool's reserve as a simple heuristic
func (d *SimpleDetector) estimateOptimalInputAmount(pool *types.PoolInfo) *big.Int {
	// Use 1% of the smaller reserve as input amount
	reserve0 := pool.Reserve0
	reserve1 := pool.Reserve1

	if reserve0 == nil || reserve1 == nil {
		return big.NewInt(1e18) // Default to 1 token (18 decimals)
	}

	smallerReserve := reserve0
	if reserve1.Cmp(reserve0) < 0 {
		smallerReserve = reserve1
	}

	// 1% of smaller reserve
	inputAmount := new(big.Int).Div(smallerReserve, big.NewInt(100))

	// Ensure minimum of 0.01 tokens (for 18 decimal tokens)
	minAmount := big.NewInt(1e16)
	if inputAmount.Cmp(minAmount) < 0 {
		inputAmount = minAmount
	}

	return inputAmount
}

// filterProfitable filters opportunities to only include those meeting profitability criteria
func (d *SimpleDetector) filterProfitable(opportunities []*Opportunity) []*Opportunity {
	var profitable []*Opportunity

	for _, opp := range opportunities {
		// Check if profit meets minimum threshold
		if opp.ProfitBPS.Cmp(d.minProfitBPS) < 0 {
			continue
		}

		// Check if gas cost is acceptable
		if opp.GasCostWei.Cmp(d.maxGasCostWei) > 0 {
			continue
		}

		// Check if profit exceeds gas cost
		// TODO: Need to convert gas cost to token terms for proper comparison
		// For now, just check profit is positive (already done in calculateOpportunity)

		profitable = append(profitable, opp)
	}

	return profitable
}

// GetStats returns statistics about the detector's operation
func (d *SimpleDetector) GetStats() (opportunitiesFound uint64, lastScanBlock uint64) {
	d.mu.RLock()
	defer d.mu.RUnlock()
	return d.opportunitiesFound, d.lastScanBlock
}