package arbitrum

import (
	"encoding/binary"
	"math/big"
	"testing"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/fraktal/mev-beta/internal/logger"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// createValidRLPTransaction creates a valid RLP-encoded transaction for testing
func createValidRLPTransaction() []byte {
	tx := types.NewTransaction(
		0,                                 // nonce
		common.HexToAddress("0x742d35Cc"), // to
		big.NewInt(1000),                  // value
		21000,                             // gas
		big.NewInt(1000000000),            // gas price
		[]byte{},                          // data
	)

	rlpData, _ := tx.MarshalBinary()
	return rlpData
}

// createValidSwapCalldata creates valid swap function calldata
func createValidSwapCalldata() []byte {
	// Create properly formatted ABI-encoded calldata for swapExactTokensForTokens
	data := make([]byte, 256) // More space for proper ABI encoding

	// amountIn (1000 tokens) - right-aligned in 32 bytes
	amountIn := big.NewInt(1000000000000000000)
	amountInBytes := amountIn.Bytes()
	copy(data[32-len(amountInBytes):32], amountInBytes)

	// amountOutMin (900 tokens) - right-aligned in 32 bytes
	amountOutMin := big.NewInt(900000000000000000)
	amountOutMinBytes := amountOutMin.Bytes()
	copy(data[64-len(amountOutMinBytes):64], amountOutMinBytes)

	// path offset (0xa0 = 160 decimal, pointer to array) - right-aligned
	pathOffset := big.NewInt(160)
	pathOffsetBytes := pathOffset.Bytes()
	copy(data[96-len(pathOffsetBytes):96], pathOffsetBytes)

	// recipient address - right-aligned in 32 bytes
	recipient := common.HexToAddress("0x742d35Cc6635C0532925a3b8D9C12CF345eEE40F")
	copy(data[96+12:128], recipient.Bytes())

	// deadline - right-aligned in 32 bytes
	deadline := big.NewInt(1234567890)
	deadlineBytes := deadline.Bytes()
	copy(data[160-len(deadlineBytes):160], deadlineBytes)

	// Add array length and tokens for path (simplified)
	// Array length = 2
	arrayLen := big.NewInt(2)
	arrayLenBytes := arrayLen.Bytes()
	copy(data[192-len(arrayLenBytes):192], arrayLenBytes)

	// Token addresses would go here, but we'll keep it simple

	return data
}

// createValidExactInputSingleData creates valid exactInputSingle calldata
func createValidExactInputSingleData() []byte {
	// Create properly formatted ABI-encoded calldata for exactInputSingle
	data := make([]byte, 256) // More space for proper ABI encoding

	// tokenIn at position 0-31 (address in last 20 bytes)
	copy(data[12:32], common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").Bytes()) // USDC

	// tokenOut at position 32-63 (address in last 20 bytes)
	copy(data[44:64], common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").Bytes()) // WETH

	// recipient at position 96-127 (address in last 20 bytes)
	copy(data[108:128], common.HexToAddress("0x742d35Cc6635C0532925a3b8D9C12CF345eEE40F").Bytes())

	// deadline at position 128-159 (uint64 in last 8 bytes)
	binary.BigEndian.PutUint64(data[152:160], 1234567890)

	// amountIn at position 160-191
	amountIn := big.NewInt(1000000000) // 1000 USDC (6 decimals)
	amountInBytes := amountIn.Bytes()
	copy(data[192-len(amountInBytes):192], amountInBytes)

	return data
}

func TestL2MessageParser_ParseL2Message(t *testing.T) {
	logger := logger.New("info", "text", "")
	parser := NewL2MessageParser(logger)

	tests := []struct {
		name          string
		messageData   []byte
		messageNumber *big.Int
		timestamp     uint64
		expectError   bool
		expectedType  L2MessageType
	}{
		{
			name:          "Empty message",
			messageData:   []byte{},
			messageNumber: big.NewInt(1),
			timestamp:     1234567890,
			expectError:   true,
		},
		{
			name:          "Short message",
			messageData:   []byte{0x00, 0x00, 0x00},
			messageNumber: big.NewInt(2),
			timestamp:     1234567890,
			expectError:   true,
		},
		{
			name:          "L2 Transaction message",
			messageData:   append([]byte{0x00, 0x00, 0x00, 0x03}, createValidRLPTransaction()...),
			messageNumber: big.NewInt(3),
			timestamp:     1234567890,
			expectError:   false,
			expectedType:  L2Transaction,
		},
		{
			name:          "L2 Batch message",
			messageData:   append([]byte{0x00, 0x00, 0x00, 0x07}, make([]byte, 64)...),
			messageNumber: big.NewInt(4),
			timestamp:     1234567890,
			expectError:   false,
			expectedType:  L2BatchSubmission,
		},
		{
			name:          "Unknown message type",
			messageData:   append([]byte{0x00, 0x00, 0x00, 0xFF}, make([]byte, 32)...),
			messageNumber: big.NewInt(5),
			timestamp:     1234567890,
			expectError:   false,
			expectedType:  L2Unknown,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := parser.ParseL2Message(tt.messageData, tt.messageNumber, tt.timestamp)

			if tt.expectError {
				assert.Error(t, err)
				return
			}

			require.NoError(t, err)
			assert.NotNil(t, result)
			assert.Equal(t, tt.expectedType, result.Type)
			assert.Equal(t, tt.messageNumber, result.MessageNumber)
			assert.Equal(t, tt.timestamp, result.Timestamp)
		})
	}
}

func TestL2MessageParser_ParseDEXInteraction(t *testing.T) {
	logger := logger.New("info", "text", "")
	parser := NewL2MessageParser(logger)

	// Create a mock transaction for testing
	createMockTx := func(to common.Address, data []byte) *types.Transaction {
		return types.NewTransaction(
			0,
			to,
			big.NewInt(0),
			21000,
			big.NewInt(1000000000),
			data,
		)
	}

	tests := []struct {
		name        string
		tx          *types.Transaction
		expectError bool
		expectSwap  bool
	}{
		{
			name:        "Contract creation transaction",
			tx:          types.NewContractCreation(0, big.NewInt(0), 21000, big.NewInt(1000000000), []byte{}),
			expectError: true,
		},
		{
			name:        "Unknown router address",
			tx:          createMockTx(common.HexToAddress("0x1234567890123456789012345678901234567890"), []byte{0x38, 0xed, 0x17, 0x39}),
			expectError: true,
		},
		{
			name: "Uniswap V3 router with exactInputSingle",
			tx: createMockTx(
				common.HexToAddress("0xE592427A0AEce92De3Edee1F18E0157C05861564"),            // Uniswap V3 Router
				append([]byte{0x41, 0x4b, 0xf3, 0x89}, createValidExactInputSingleData()...), // exactInputSingle with proper data
			),
			expectError: false,
			expectSwap:  true,
		},
		{
			name: "SushiSwap router - expect error due to complex ABI",
			tx: createMockTx(
				common.HexToAddress("0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506"), // SushiSwap Router
				[]byte{0x38, 0xed, 0x17, 0x39},                                    // swapExactTokensForTokens selector only
			),
			expectError: true, // Expected to fail due to insufficient ABI data
			expectSwap:  false,
		},
		{
			name: "Unknown function selector",
			tx: createMockTx(
				common.HexToAddress("0xE592427A0AEce92De3Edee1F18E0157C05861564"), // Uniswap V3 Router
				[]byte{0xFF, 0xFF, 0xFF, 0xFF},                                    // Unknown selector
			),
			expectError: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := parser.ParseDEXInteraction(tt.tx)

			if tt.expectError {
				assert.Error(t, err)
				return
			}

			require.NoError(t, err)
			assert.NotNil(t, result)

			if tt.expectSwap {
				assert.NotEmpty(t, result.Protocol)
				assert.Equal(t, *tt.tx.To(), result.Router)
			}
		})
	}
}

func TestL2MessageParser_IsSignificantSwap(t *testing.T) {
	logger := logger.New("info", "text", "")
	parser := NewL2MessageParser(logger)

	tests := []struct {
		name              string
		interaction       *DEXInteraction
		minAmountUSD      float64
		expectSignificant bool
	}{
		{
			name: "Small swap - not significant",
			interaction: &DEXInteraction{
				AmountIn: big.NewInt(100000000000000000), // 0.1 ETH
			},
			minAmountUSD:      10.0,
			expectSignificant: false,
		},
		{
			name: "Large swap - significant",
			interaction: &DEXInteraction{
				AmountIn: big.NewInt(2000000000000000000), // 2 ETH
			},
			minAmountUSD:      10.0,
			expectSignificant: true,
		},
		{
			name: "Nil amount - not significant",
			interaction: &DEXInteraction{
				AmountIn: nil,
			},
			minAmountUSD:      10.0,
			expectSignificant: false,
		},
		{
			name: "Zero amount - not significant",
			interaction: &DEXInteraction{
				AmountIn: big.NewInt(0),
			},
			minAmountUSD:      10.0,
			expectSignificant: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := parser.IsSignificantSwap(tt.interaction, tt.minAmountUSD)
			assert.Equal(t, tt.expectSignificant, result)
		})
	}
}

func TestL2MessageParser_ParseExactInputSingle(t *testing.T) {
	logger := logger.New("info", "text", "")
	parser := NewL2MessageParser(logger)

	// Create test data for exactInputSingle call
	// This is a simplified version - real data would be properly ABI encoded
	data := make([]byte, 256)

	// tokenIn at position 0-31 (address in last 20 bytes)
	copy(data[12:32], common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").Bytes()) // USDC

	// tokenOut at position 32-63 (address in last 20 bytes)
	copy(data[44:64], common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").Bytes()) // WETH

	// recipient at position 96-127 (address in last 20 bytes)
	copy(data[108:128], common.HexToAddress("0x742d35Cc6635C0532925a3b8D9C12CF345eEE40F").Bytes())

	// deadline at position 128-159 (uint64 in last 8 bytes)
	binary.BigEndian.PutUint64(data[152:160], 1234567890)

	// amountIn at position 160-191
	amountIn := big.NewInt(1000000000) // 1000 USDC (6 decimals)
	amountInBytes := amountIn.Bytes()
	copy(data[192-len(amountInBytes):192], amountInBytes)

	interaction := &DEXInteraction{}
	result, err := parser.parseExactInputSingle(interaction, data)

	require.NoError(t, err)
	assert.Equal(t, common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"), result.TokenIn)
	assert.Equal(t, common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"), result.TokenOut)
	assert.Equal(t, common.HexToAddress("0x742d35Cc6635C0532925a3b8D9C12CF345eEE40F"), result.Recipient)
	assert.Equal(t, uint64(1234567890), result.Deadline)
	// Note: AmountIn comparison might need adjustment based on how the data is packed
}

func TestL2MessageParser_InitialSetup(t *testing.T) {
	logger := logger.New("info", "text", "")
	parser := NewL2MessageParser(logger)

	// Test that we can add and identify known pools
	// This test verifies the internal pool tracking functionality

	// The parser should have some pre-configured pools
	assert.NotNil(t, parser)

	// Verify parser was created with proper initialization
	assert.NotNil(t, parser.logger)
}

func BenchmarkL2MessageParser_ParseL2Message(b *testing.B) {
	logger := logger.New("info", "text", "")
	parser := NewL2MessageParser(logger)

	// Create test message data
	messageData := append([]byte{0x00, 0x00, 0x00, 0x03}, make([]byte, 100)...)
	messageNumber := big.NewInt(1)
	timestamp := uint64(1234567890)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := parser.ParseL2Message(messageData, messageNumber, timestamp)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkL2MessageParser_ParseDEXInteraction(b *testing.B) {
	logger := logger.New("info", "text", "")
	parser := NewL2MessageParser(logger)

	// Create mock transaction
	tx := types.NewTransaction(
		0,
		common.HexToAddress("0xE592427A0AEce92De3Edee1F18E0157C05861564"), // Uniswap V3 Router
		big.NewInt(0),
		21000,
		big.NewInt(1000000000),
		[]byte{0x41, 0x4b, 0xf3, 0x89}, // exactInputSingle selector
	)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := parser.ParseDEXInteraction(tx)
		if err != nil && err.Error() != "insufficient data for exactInputSingle" {
			b.Fatal(err)
		}
	}
}