package dex

import (
	"fmt"
	"time"
)

// Config represents DEX configuration
type Config struct {
	// Feature flags
	Enabled          bool     `yaml:"enabled" json:"enabled"`
	EnabledProtocols []string `yaml:"enabled_protocols" json:"enabled_protocols"`

	// Profitability thresholds
	MinProfitETH     float64 `yaml:"min_profit_eth" json:"min_profit_eth"`         // Minimum profit in ETH
	MinProfitUSD     float64 `yaml:"min_profit_usd" json:"min_profit_usd"`         // Minimum profit in USD
	MaxPriceImpact   float64 `yaml:"max_price_impact" json:"max_price_impact"`     // Maximum acceptable price impact (0-1)
	MinConfidence    float64 `yaml:"min_confidence" json:"min_confidence"`         // Minimum confidence score (0-1)

	// Multi-hop configuration
	MaxHops          int     `yaml:"max_hops" json:"max_hops"`                     // Maximum number of hops (2-4)
	EnableMultiHop   bool    `yaml:"enable_multi_hop" json:"enable_multi_hop"`     // Enable multi-hop arbitrage

	// Performance settings
	ParallelQueries  bool          `yaml:"parallel_queries" json:"parallel_queries"` // Query DEXes in parallel
	TimeoutSeconds   int           `yaml:"timeout_seconds" json:"timeout_seconds"`   // Query timeout
	CacheTTLSeconds  int           `yaml:"cache_ttl_seconds" json:"cache_ttl_seconds"` // Pool cache TTL
	MaxConcurrent    int           `yaml:"max_concurrent" json:"max_concurrent"`     // Max concurrent queries

	// Gas settings
	MaxGasPrice      uint64  `yaml:"max_gas_price" json:"max_gas_price"`           // Maximum gas price in gwei
	GasBuffer        float64 `yaml:"gas_buffer" json:"gas_buffer"`                 // Gas estimate buffer multiplier

	// Monitoring
	EnableMetrics    bool   `yaml:"enable_metrics" json:"enable_metrics"`
	MetricsInterval  int    `yaml:"metrics_interval" json:"metrics_interval"`
}

// DefaultConfig returns default DEX configuration
func DefaultConfig() *Config {
	return &Config{
		Enabled:          true,
		EnabledProtocols: []string{"uniswap_v3", "sushiswap", "curve", "balancer"},

		MinProfitETH:     0.0001,  // $0.25 @ $2500/ETH
		MinProfitUSD:     0.25,    // $0.25
		MaxPriceImpact:   0.05,    // 5%
		MinConfidence:    0.5,     // 50%

		MaxHops:          4,
		EnableMultiHop:   true,

		ParallelQueries:  true,
		TimeoutSeconds:   5,
		CacheTTLSeconds:  30,      // 30 second cache
		MaxConcurrent:    10,      // Max 10 concurrent queries

		MaxGasPrice:      100,     // 100 gwei max
		GasBuffer:        1.2,     // 20% gas buffer

		EnableMetrics:    true,
		MetricsInterval:  60,      // 60 seconds
	}
}

// ProductionConfig returns production-optimized configuration
func ProductionConfig() *Config {
	return &Config{
		Enabled:          true,
		EnabledProtocols: []string{"uniswap_v3", "sushiswap", "curve", "balancer"},

		MinProfitETH:     0.0002,  // $0.50 @ $2500/ETH - higher threshold for production
		MinProfitUSD:     0.50,
		MaxPriceImpact:   0.03,    // 3% - stricter for production
		MinConfidence:    0.7,     // 70% - higher confidence required

		MaxHops:          3,       // Limit to 3 hops for lower gas
		EnableMultiHop:   true,

		ParallelQueries:  true,
		TimeoutSeconds:   3,       // Faster timeout for production
		CacheTTLSeconds:  15,      // Shorter cache for fresher data
		MaxConcurrent:    20,      // More concurrent for speed

		MaxGasPrice:      50,      // 50 gwei max for production
		GasBuffer:        1.3,     // 30% gas buffer for safety

		EnableMetrics:    true,
		MetricsInterval:  30,      // More frequent metrics
	}
}

// Validate validates configuration
func (c *Config) Validate() error {
	if c.MinProfitETH < 0 {
		return fmt.Errorf("min_profit_eth must be >= 0")
	}
	if c.MaxPriceImpact < 0 || c.MaxPriceImpact > 1 {
		return fmt.Errorf("max_price_impact must be between 0 and 1")
	}
	if c.MinConfidence < 0 || c.MinConfidence > 1 {
		return fmt.Errorf("min_confidence must be between 0 and 1")
	}
	if c.MaxHops < 2 || c.MaxHops > 4 {
		return fmt.Errorf("max_hops must be between 2 and 4")
	}
	if c.TimeoutSeconds < 1 {
		return fmt.Errorf("timeout_seconds must be >= 1")
	}
	if c.CacheTTLSeconds < 0 {
		return fmt.Errorf("cache_ttl_seconds must be >= 0")
	}
	return nil
}

// GetTimeout returns timeout as duration
func (c *Config) GetTimeout() time.Duration {
	return time.Duration(c.TimeoutSeconds) * time.Second
}

// GetCacheTTL returns cache TTL as duration
func (c *Config) GetCacheTTL() time.Duration {
	return time.Duration(c.CacheTTLSeconds) * time.Second
}

// GetMetricsInterval returns metrics interval as duration
func (c *Config) GetMetricsInterval() time.Duration {
	return time.Duration(c.MetricsInterval) * time.Second
}

// IsProtocolEnabled checks if a protocol is enabled
func (c *Config) IsProtocolEnabled(protocol string) bool {
	for _, p := range c.EnabledProtocols {
		if p == protocol {
			return true
		}
	}
	return false
}