// Deployment configuration for the MEV Bot
package exchanges

import (
	"time"
)

// DeploymentConfig holds configuration for different deployment environments
type DeploymentConfig struct {
	Environment  string           // "development", "staging", "production"
	EthereumNode string           // URL of the Ethereum node to connect to
	PolygonNode  string           // URL of the Polygon node to connect to
	ArbitrumNode string           // URL of the Arbitrum node to connect to
	GasLimit     uint64           // Maximum gas to use for transactions
	GasPrice     uint64           // Gas price to use for transactions (in gwei)
	PrivateKey   string           // Private key for transaction signing
	Monitoring   MonitoringConfig // Monitoring and alerting configuration
	Arbitrage    ArbitrageConfig  // Arbitrage-specific configuration
	MaxSlippage  float64          // Maximum acceptable slippage percentage
	MinProfit    float64          // Minimum profit threshold (in ETH) before executing arbitrage
	Redsync      RedsyncConfig    // Redis synchronization configuration
}

// MonitoringConfig holds monitoring-related configuration
type MonitoringConfig struct {
	Enabled         bool          // Whether monitoring is enabled
	PrometheusAddr  string        // Address to bind Prometheus metrics server
	GrafanaAddr     string        // Grafana server address
	AlertManagerUrl string        // AlertManager URL for alerts
	LogLevel        string        // Log level for the application (e.g., "debug", "info", "warn", "error")
	LogFormat       string        // Log format ("json", "text")
	HealthCheckPath string        // Path for health checks
	MetricsInterval time.Duration // How often to collect metrics
}

// ArbitrageConfig holds arbitrage-specific configuration settings
type ArbitrageConfig struct {
	MaxOpportunities         int           // Maximum number of arbitrage opportunities to track
	OpportunityTimeout       time.Duration // How long to consider an opportunity valid
	MinSpreadPercentage      float64       // Minimum spread percentage to consider an opportunity
	MaxTradeSize             float64       // Maximum trade size in ETH
	ValidationInterval       time.Duration // How often to validate opportunities
	OpportunityCheckInterval time.Duration // How often to check for new opportunities
	ExecutionDelay           time.Duration // Delay before executing opportunities (to account for validation)
}

// RedsyncConfig holds configuration for distributed locking
type RedsyncConfig struct {
	Enabled   bool     // Whether distributed locking is enabled
	Addresses []string // Redis addresses for distributed locking
	Database  int      // Redis database number
	Password  string   // Redis password (if any)
}

// DefaultDevelopmentConfig returns a default configuration for development
func DefaultDevelopmentConfig() *DeploymentConfig {
	return &DeploymentConfig{
		Environment:  "development",
		EthereumNode: "ws://localhost:8545",
		PolygonNode:  "ws://localhost:8546", // If using local Polygon node
		ArbitrumNode: "ws://localhost:8547", // If using local Arbitrum node
		GasLimit:     500000,
		GasPrice:     20,
		PrivateKey:   "",    // This should be loaded from environment or secure storage
		MaxSlippage:  0.5,   // 0.5%
		MinProfit:    0.001, // 0.001 ETH
		Monitoring: MonitoringConfig{
			Enabled:         true,
			PrometheusAddr:  ":9090",
			GrafanaAddr:     "http://localhost:3000",
			AlertManagerUrl: "http://localhost:9093",
			LogLevel:        "debug",
			LogFormat:       "text",
			HealthCheckPath: "/health",
			MetricsInterval: 5 * time.Second,
		},
		Arbitrage: ArbitrageConfig{
			MaxOpportunities:         100,
			OpportunityTimeout:       100 * time.Millisecond,
			MinSpreadPercentage:      0.3,  // 0.3%
			MaxTradeSize:             10.0, // 10 ETH max
			ValidationInterval:       50 * time.Millisecond,
			OpportunityCheckInterval: 100 * time.Millisecond,
			ExecutionDelay:           10 * time.Millisecond,
		},
		Redsync: RedsyncConfig{
			Enabled:   false, // Disable for development
			Addresses: []string{"localhost:6379"},
			Database:  0,
			Password:  "",
		},
	}
}

// DefaultProductionConfig returns a default configuration for production
func DefaultProductionConfig() *DeploymentConfig {
	return &DeploymentConfig{
		Environment:  "production",
		EthereumNode: "wss://mainnet.infura.io/ws/v3/YOUR_PROJECT_ID", // Use your actual Infura endpoint
		PolygonNode:  "wss://polygon-mainnet.infura.io/ws/v3/YOUR_PROJECT_ID",
		ArbitrumNode: "wss://arbitrum-mainnet.infura.io/ws/v3/YOUR_PROJECT_ID",
		GasLimit:     1000000,
		GasPrice:     50,
		PrivateKey:   "",   // Load securely from environment or key management system
		MaxSlippage:  0.1,  // 0.1% - more conservative in production
		MinProfit:    0.01, // 0.01 ETH - higher threshold in production
		Monitoring: MonitoringConfig{
			Enabled:         true,
			PrometheusAddr:  ":9090",
			GrafanaAddr:     "", // Your Grafana instance
			AlertManagerUrl: "", // Your AlertManager instance
			LogLevel:        "info",
			LogFormat:       "json",
			HealthCheckPath: "/health",
			MetricsInterval: 1 * time.Second,
		},
		Arbitrage: ArbitrageConfig{
			MaxOpportunities:         50,
			OpportunityTimeout:       50 * time.Millisecond,
			MinSpreadPercentage:      0.5,   // 0.5% - higher threshold in production
			MaxTradeSize:             100.0, // 100 ETH max
			ValidationInterval:       20 * time.Millisecond,
			OpportunityCheckInterval: 50 * time.Millisecond,
			ExecutionDelay:           5 * time.Millisecond,
		},
		Redsync: RedsyncConfig{
			Enabled:   true, // Enable for production
			Addresses: []string{"redis-primary:6379", "redis-replica:6379"},
			Database:  0,
			Password:  "", // Set if using password authentication
		},
	}
}

// Validate checks if the deployment configuration is valid
func (dc *DeploymentConfig) Validate() error {
	if dc.PrivateKey == "" {
		return nil // Validation would check if this is loaded properly
	}

	if dc.GasLimit == 0 {
		return nil // Should be greater than 0
	}

	if dc.GasPrice == 0 {
		return nil // Should be greater than 0
	}

	if dc.MaxSlippage <= 0 || dc.MaxSlippage > 5 { // 5% max slippage
		return nil // Should be within reasonable bounds
	}

	return nil
}

// GetConfigByEnvironment returns appropriate config based on environment
func GetConfigByEnvironment(env string) *DeploymentConfig {
	switch env {
	case "production":
		return DefaultProductionConfig()
	case "staging":
		// Staging config would be similar to production but with testnet endpoints
		config := DefaultProductionConfig()
		config.Environment = "staging"
		config.EthereumNode = "wss://sepolia.infura.io/ws/v3/YOUR_PROJECT_ID"
		config.PolygonNode = "wss://polygon-mumbai.infura.io/ws/v3/YOUR_PROJECT_ID"
		config.ArbitrumNode = "wss://arbitrum-sepolia.infura.io/ws/v3/YOUR_PROJECT_ID"
		return config
	default: // development
		return DefaultDevelopmentConfig()
	}
}