package math

import (
	"math/big"
	"testing"

	"github.com/holiman/uint256"
)

// Benchmark original vs cached SqrtPriceX96ToPrice conversion
func BenchmarkSqrtPriceX96ToPriceOriginal(b *testing.B) {
	// Use a typical sqrtPriceX96 value (represents price of ~2000 USDC/ETH)
	sqrtPriceX96 := new(big.Int).SetBytes([]byte{0x06, 0x40, 0x84, 0x4A, 0x0E, 0x81, 0x4F, 0x96, 0x19, 0xC1, 0x9C, 0x08})

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		// Original calculation: price = sqrtPriceX96^2 / 2^192
		sqrtPriceFloat := new(big.Float).SetInt(sqrtPriceX96)
		price := new(big.Float).Mul(sqrtPriceFloat, sqrtPriceFloat)

		// Calculate 2^192
		q192 := new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
		q192Float := new(big.Float).SetInt(q192)

		// Divide by 2^192
		price.Quo(price, q192Float)
	}
}

func BenchmarkSqrtPriceX96ToPriceCached(b *testing.B) {
	// Use a typical sqrtPriceX96 value (represents price of ~2000 USDC/ETH)
	sqrtPriceX96 := new(big.Int).SetBytes([]byte{0x06, 0x40, 0x84, 0x4A, 0x0E, 0x81, 0x4F, 0x96, 0x19, 0xC1, 0x9C, 0x08})

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		// Cached calculation using precomputed constants
		SqrtPriceX96ToPriceCached(sqrtPriceX96)
	}
}

// Benchmark original vs cached PriceToSqrtPriceX96 conversion
func BenchmarkPriceToSqrtPriceX96Original(b *testing.B) {
	// Use a typical price value (represents price of ~2000 USDC/ETH)
	price := new(big.Float).SetFloat64(2000.0)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		// Original calculation: sqrtPriceX96 = sqrt(price * 2^192)

		// Calculate 2^192
		q192 := new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
		q192Float := new(big.Float).SetInt(q192)

		// Multiply price by 2^192
		result := new(big.Float).Mul(price, q192Float)

		// Calculate square root
		result.Sqrt(result)

		// Convert to big.Int
		sqrtPriceX96 := new(big.Int)
		result.Int(sqrtPriceX96)
	}
}

func BenchmarkPriceToSqrtPriceX96Cached(b *testing.B) {
	// Use a typical price value (represents price of ~2000 USDC/ETH)
	price := new(big.Float).SetFloat64(2000.0)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		// Cached calculation using precomputed constants
		PriceToSqrtPriceX96Cached(price)
	}
}

// Benchmark optimized versions with uint256
func BenchmarkSqrtPriceX96ToPriceOptimized(b *testing.B) {
	// Use a typical sqrtPriceX96 value
	sqrtPriceX96 := uint256.NewInt(0).SetBytes([]byte{0x06, 0x40, 0x84, 0x4A, 0x0E, 0x81, 0x4F, 0x96, 0x19, 0xC1, 0x9C, 0x08})

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		SqrtPriceX96ToPriceOptimized(sqrtPriceX96)
	}
}

func BenchmarkPriceToSqrtPriceX96Optimized(b *testing.B) {
	// Use a typical price value
	price := new(big.Float).SetFloat64(2000.0)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		PriceToSqrtPriceX96Optimized(price)
	}
}