package pools

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

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/ethclient"

	"github.com/your-org/mev-bot/pkg/cache"
	mevtypes "github.com/your-org/mev-bot/pkg/types"
)

// Known factory addresses on Arbitrum
var (
	UniswapV2FactoryAddress = common.HexToAddress("0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9") // SushiSwap
	UniswapV3FactoryAddress = common.HexToAddress("0x1F98431c8aD98523631AE4a59f267346ea31F984") // Uniswap V3
	CamelotFactoryAddress   = common.HexToAddress("0x6EcCab422D763aC031210895C81787E87B43A652") // Camelot
	CurveRegistryAddress    = common.HexToAddress("0x445FE580eF8d70FF569aB36e80c647af338db351") // Curve (mainnet, example)
)

// Top traded tokens on Arbitrum
var TopTokens = []common.Address{
	common.HexToAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"), // WETH
	common.HexToAddress("0xFF970a61A04b1cA14834A43f5dE4533eBDDB5CC8"), // USDC
	common.HexToAddress("0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"), // USDT
	common.HexToAddress("0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f"), // WBTC
	common.HexToAddress("0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"), // DAI
	common.HexToAddress("0xf97f4df75117a78c1A5a0DBb814Af92458539FB4"), // LINK
	common.HexToAddress("0xFA7F8980b0f1E64A2062791cc3b0871572f1F7f0"), // UNI
}

// DiscoveryConfig contains configuration for pool discovery
type DiscoveryConfig struct {
	// Connection
	RPCURL string

	// Discovery parameters
	StartBlock        uint64
	MaxPools          int
	MinLiquidity      *big.Int
	BatchSize         int
	ConcurrentFetches int

	// Token pairs to discover
	TokenPairs []TokenPair
}

// TokenPair represents a pair of tokens
type TokenPair struct {
	Token0 common.Address
	Token1 common.Address
}

// DefaultDiscoveryConfig returns default configuration
func DefaultDiscoveryConfig() *DiscoveryConfig {
	// Generate pairs from top tokens
	pairs := make([]TokenPair, 0)
	for i := 0; i < len(TopTokens); i++ {
		for j := i + 1; j < len(TopTokens); j++ {
			pairs = append(pairs, TokenPair{
				Token0: TopTokens[i],
				Token1: TopTokens[j],
			})
		}
	}

	return &DiscoveryConfig{
		RPCURL:            "https://arb1.arbitrum.io/rpc",
		StartBlock:        0,
		MaxPools:          1000,
		MinLiquidity:      big.NewInt(1e18), // 1 ETH minimum
		BatchSize:         100,
		ConcurrentFetches: 10,
		TokenPairs:        pairs,
	}
}

// Discovery discovers pools on Arbitrum
type Discovery struct {
	config *DiscoveryConfig
	client *ethclient.Client
	cache  *cache.PoolCache
	logger *slog.Logger

	mu            sync.Mutex
	poolsDiscovered int
}

// NewDiscovery creates a new pool discovery service
func NewDiscovery(config *DiscoveryConfig, cache *cache.PoolCache, logger *slog.Logger) (*Discovery, error) {
	if config == nil {
		config = DefaultDiscoveryConfig()
	}

	client, err := ethclient.Dial(config.RPCURL)
	if err != nil {
		return nil, fmt.Errorf("failed to connect to RPC: %w", err)
	}

	return &Discovery{
		config: config,
		client: client,
		cache:  cache,
		logger: logger.With("component", "pool_discovery"),
	}, nil
}

// DiscoverAll discovers all pools from known DEXes
func (d *Discovery) DiscoverAll(ctx context.Context) error {
	d.logger.Info("starting pool discovery")

	// Discover UniswapV2-style pools (SushiSwap, Camelot, etc.)
	if err := d.discoverUniswapV2Pools(ctx); err != nil {
		d.logger.Error("uniswap v2 discovery failed", "error", err)
	}

	// Discover UniswapV3 pools
	if err := d.discoverUniswapV3Pools(ctx); err != nil {
		d.logger.Error("uniswap v3 discovery failed", "error", err)
	}

	d.logger.Info("pool discovery complete", "pools_discovered", d.poolsDiscovered, "total_cached", d.cache.Count())
	return nil
}

// discoverUniswapV2Pools discovers UniswapV2-style pools
func (d *Discovery) discoverUniswapV2Pools(ctx context.Context) error {
	d.logger.Info("discovering UniswapV2-style pools")

	factories := []struct {
		address  common.Address
		protocol string
	}{
		{UniswapV2FactoryAddress, mevtypes.ProtocolUniswapV2},
		{CamelotFactoryAddress, mevtypes.ProtocolCamelot},
	}

	for _, factory := range factories {
		d.logger.Info("querying factory", "protocol", factory.protocol, "address", factory.address.Hex())

		// Query each token pair
		for _, pair := range d.config.TokenPairs {
			select {
			case <-ctx.Done():
				return ctx.Err()
			default:
			}

			poolAddr, err := d.getUniswapV2Pool(ctx, factory.address, pair.Token0, pair.Token1)
			if err != nil {
				continue
			}

			if poolAddr == (common.Address{}) {
				continue // Pool doesn't exist
			}

			// Fetch pool info
			poolInfo, err := d.fetchUniswapV2PoolInfo(ctx, poolAddr, pair.Token0, pair.Token1, factory.protocol)
			if err != nil {
				d.logger.Debug("failed to fetch pool info", "pool", poolAddr.Hex(), "error", err)
				continue
			}

			// Check minimum liquidity
			if poolInfo.LiquidityUSD.Cmp(d.config.MinLiquidity) < 0 {
				continue
			}

			// Add to cache
			if err := d.cache.Add(poolInfo); err != nil {
				d.logger.Warn("failed to add pool to cache", "pool", poolAddr.Hex(), "error", err)
				continue
			}

			d.mu.Lock()
			d.poolsDiscovered++
			d.mu.Unlock()

			d.logger.Debug("discovered pool",
				"protocol", factory.protocol,
				"pool", poolAddr.Hex(),
				"token0", pair.Token0.Hex(),
				"token1", pair.Token1.Hex(),
				"liquidity", poolInfo.LiquidityUSD.String(),
			)
		}
	}

	return nil
}

// getUniswapV2Pool gets a UniswapV2 pool address for a token pair
func (d *Discovery) getUniswapV2Pool(ctx context.Context, factory common.Address, token0, token1 common.Address) (common.Address, error) {
	// getPair(address,address) returns (address)
	// This is a simplified version - in production, use generated bindings
	calldata := append([]byte{0xe6, 0xa4, 0x39, 0x05}, // getPair selector
		append(padLeft(token0.Bytes(), 32), padLeft(token1.Bytes(), 32)...)...)

	result, err := d.client.CallContract(ctx, map[string]interface{}{
		"to":   factory,
		"data": common.Bytes2Hex(calldata),
	}, nil)
	if err != nil {
		return common.Address{}, err
	}

	if len(result) == 0 {
		return common.Address{}, nil
	}

	return common.BytesToAddress(result[12:]), nil
}

// fetchUniswapV2PoolInfo fetches pool information
func (d *Discovery) fetchUniswapV2PoolInfo(ctx context.Context, poolAddr, token0, token1 common.Address, protocol string) (*mevtypes.PoolInfo, error) {
	// getReserves() returns (uint112,uint112,uint32)
	// Simplified - in production use generated bindings
	calldata := []byte{0x09, 0x02, 0xf1, 0xac} // getReserves selector

	result, err := d.client.CallContract(ctx, map[string]interface{}{
		"to":   poolAddr,
		"data": common.Bytes2Hex(calldata),
	}, nil)
	if err != nil {
		return nil, err
	}

	if len(result) < 64 {
		return nil, fmt.Errorf("invalid reserves response")
	}

	reserve0 := new(big.Int).SetBytes(result[0:32])
	reserve1 := new(big.Int).SetBytes(result[32:64])

	// Estimate liquidity in USD (simplified - in production, use price oracle)
	liquidityUSD := new(big.Int).Add(reserve0, reserve1)

	return &mevtypes.PoolInfo{
		Address:      poolAddr,
		Protocol:     protocol,
		Token0:       token0,
		Token1:       token1,
		Reserve0:     reserve0,
		Reserve1:     reserve1,
		Fee:          300, // 0.3% for UniswapV2
		LiquidityUSD: liquidityUSD,
	}, nil
}

// discoverUniswapV3Pools discovers UniswapV3 pools
func (d *Discovery) discoverUniswapV3Pools(ctx context.Context) error {
	d.logger.Info("discovering UniswapV3 pools")

	// UniswapV3 has multiple fee tiers
	feeTiers := []uint32{100, 500, 3000, 10000}

	for _, pair := range d.config.TokenPairs {
		for _, fee := range feeTiers {
			select {
			case <-ctx.Done():
				return ctx.Err()
			default:
			}

			poolAddr, err := d.getUniswapV3Pool(ctx, pair.Token0, pair.Token1, fee)
			if err != nil {
				continue
			}

			if poolAddr == (common.Address{}) {
				continue // Pool doesn't exist
			}

			// Fetch pool info
			poolInfo, err := d.fetchUniswapV3PoolInfo(ctx, poolAddr, pair.Token0, pair.Token1, fee)
			if err != nil {
				d.logger.Debug("failed to fetch pool info", "pool", poolAddr.Hex(), "error", err)
				continue
			}

			// Check minimum liquidity
			if poolInfo.LiquidityUSD.Cmp(d.config.MinLiquidity) < 0 {
				continue
			}

			// Add to cache
			if err := d.cache.Add(poolInfo); err != nil {
				d.logger.Warn("failed to add pool to cache", "pool", poolAddr.Hex(), "error", err)
				continue
			}

			d.mu.Lock()
			d.poolsDiscovered++
			d.mu.Unlock()

			d.logger.Debug("discovered pool",
				"protocol", mevtypes.ProtocolUniswapV3,
				"pool", poolAddr.Hex(),
				"token0", pair.Token0.Hex(),
				"token1", pair.Token1.Hex(),
				"fee", fee,
				"liquidity", poolInfo.LiquidityUSD.String(),
			)

			// Check if we've reached max pools
			if d.poolsDiscovered >= d.config.MaxPools {
				return nil
			}
		}
	}

	return nil
}

// getUniswapV3Pool gets a UniswapV3 pool address
func (d *Discovery) getUniswapV3Pool(ctx context.Context, token0, token1 common.Address, fee uint32) (common.Address, error) {
	// getPool(address,address,uint24) returns (address)
	// Simplified - in production use generated bindings
	feeBytes := make([]byte, 32)
	copy(feeBytes[29:], big.NewInt(int64(fee)).Bytes())

	calldata := append([]byte{0x17, 0x79, 0x05, 0x7a}, // getPool selector
		append(append(padLeft(token0.Bytes(), 32), padLeft(token1.Bytes(), 32)...), feeBytes...)...)

	result, err := d.client.CallContract(ctx, map[string]interface{}{
		"to":   UniswapV3FactoryAddress,
		"data": common.Bytes2Hex(calldata),
	}, nil)
	if err != nil {
		return common.Address{}, err
	}

	if len(result) == 0 {
		return common.Address{}, nil
	}

	return common.BytesToAddress(result[12:]), nil
}

// fetchUniswapV3PoolInfo fetches UniswapV3 pool information
func (d *Discovery) fetchUniswapV3PoolInfo(ctx context.Context, poolAddr, token0, token1 common.Address, fee uint32) (*mevtypes.PoolInfo, error) {
	// liquidity() returns (uint128)
	// Simplified - in production use generated bindings
	calldata := []byte{0x1a, 0x68, 0x65, 0x02} // liquidity selector

	result, err := d.client.CallContract(ctx, map[string]interface{}{
		"to":   poolAddr,
		"data": common.Bytes2Hex(calldata),
	}, nil)
	if err != nil {
		return nil, err
	}

	if len(result) < 16 {
		return nil, fmt.Errorf("invalid liquidity response")
	}

	liquidity := new(big.Int).SetBytes(result[16:32])

	return &mevtypes.PoolInfo{
		Address:      poolAddr,
		Protocol:     mevtypes.ProtocolUniswapV3,
		Token0:       token0,
		Token1:       token1,
		Reserve0:     liquidity, // Simplified
		Reserve1:     liquidity,
		Fee:          fee,
		LiquidityUSD: liquidity,
	}, nil
}

// padLeft pads bytes to the left with zeros
func padLeft(data []byte, length int) []byte {
	if len(data) >= length {
		return data
	}
	padded := make([]byte, length)
	copy(padded[length-len(data):], data)
	return padded
}

// GetStats returns discovery statistics
func (d *Discovery) GetStats() map[string]interface{} {
	d.mu.Lock()
	defer d.mu.Unlock()

	return map[string]interface{}{
		"pools_discovered": d.poolsDiscovered,
		"pools_cached":     d.cache.Count(),
	}
}