# Strategy Development Guide

Trading strategies in Dexorder define entry/exit rules and position management logic.

## Strategy Structure

```python
class Strategy:
    def __init__(self, **params):
        """Initialize strategy with parameters"""
        self.params = params

    def generate_signals(self, df):
        """
        Generate trading signals

        Args:
            df: DataFrame with OHLCV + indicator columns

        Returns:
            DataFrame with 'signal' column:
                1 = long entry
               -1 = short entry
                0 = no action
        """
        pass

    def calculate_position_size(self, capital, price, risk_pct):
        """Calculate position size based on risk"""
        pass

    def get_stop_loss(self, entry_price, direction):
        """Calculate stop loss level"""
        pass

    def get_take_profit(self, entry_price, direction):
        """Calculate take profit level"""
        pass
```

## Example: Simple Moving Average Crossover

```python
class SMACrossoverStrategy:
    def __init__(self, fast_period=20, slow_period=50, risk_pct=0.02):
        self.fast_period = fast_period
        self.slow_period = slow_period
        self.risk_pct = risk_pct

    def generate_signals(self, df):
        # Calculate moving averages
        df['sma_fast'] = df['close'].rolling(self.fast_period).mean()
        df['sma_slow'] = df['close'].rolling(self.slow_period).mean()

        # Generate signals
        df['signal'] = 0

        # Long when fast crosses above slow
        df.loc[
            (df['sma_fast'] > df['sma_slow']) &
            (df['sma_fast'].shift(1) <= df['sma_slow'].shift(1)),
            'signal'
        ] = 1

        # Short when fast crosses below slow
        df.loc[
            (df['sma_fast'] < df['sma_slow']) &
            (df['sma_fast'].shift(1) >= df['sma_slow'].shift(1)),
            'signal'
        ] = -1

        return df

    def calculate_position_size(self, capital, price, atr):
        # Risk-based position sizing
        risk_amount = capital * self.risk_pct
        stop_distance = 2 * atr
        position_size = risk_amount / stop_distance
        return position_size

    def get_stop_loss(self, entry_price, direction, atr):
        if direction == 1:  # Long
            return entry_price - (2 * atr)
        else:  # Short
            return entry_price + (2 * atr)

    def get_take_profit(self, entry_price, direction, atr):
        if direction == 1:  # Long
            return entry_price + (4 * atr)  # 2:1 risk/reward
        else:  # Short
            return entry_price - (4 * atr)
```

## Strategy Components

### Signal Generation
Entry conditions based on:
- Indicator crossovers
- Price patterns
- Volume confirmation
- Multiple timeframe confluence

### Risk Management
Essential elements:
- **Position Sizing**: Based on account risk percentage
- **Stop Losses**: ATR-based or support/resistance
- **Take Profits**: Multiple targets or trailing stops
- **Max Positions**: Limit concurrent trades

### Filters
Reduce false signals:
- **Trend Filter**: Only trade with the trend
- **Volatility Filter**: Avoid low volatility periods
- **Time Filter**: Specific trading hours
- **Volume Filter**: Minimum volume requirements

### Exit Rules
Multiple exit types:
- **Stop Loss**: Protect capital
- **Take Profit**: Lock in gains
- **Trailing Stop**: Follow profitable moves
- **Time Exit**: Close at end of period
- **Signal Exit**: Opposite signal

## Backtesting Considerations

### Data Quality
- Use clean, validated data
- Handle missing data appropriately
- Account for survivorship bias
- Include realistic spreads and slippage

### Performance Metrics
Track key metrics:
- **Total Return**: Cumulative profit/loss
- **Sharpe Ratio**: Risk-adjusted returns
- **Max Drawdown**: Largest peak-to-trough decline
- **Win Rate**: Percentage of profitable trades
- **Profit Factor**: Gross profit / gross loss
- **Expectancy**: Average $ per trade

### Validation
Prevent overfitting:
- **Train/Test Split**: 70/30 or 60/40
- **Walk-Forward**: Rolling windows
- **Out-of-Sample**: Test on recent unseen data
- **Monte Carlo**: Randomize trade order
- **Paper Trading**: Live validation

## Common Strategy Types

### Trend Following
Follow sustained price movements:
- Moving average crossovers
- Breakout strategies
- Trend channels
- Works best in trending markets

### Mean Reversion
Profit from price returning to average:
- Bollinger Band reversals
- RSI extremes
- Statistical arbitrage
- Works best in ranging markets

### Momentum
Trade in direction of strong moves:
- Relative strength
- Price acceleration
- Volume surges
- Breakout confirmation

### Arbitrage
Exploit price discrepancies:
- Cross-exchange spreads
- Funding rate arbitrage
- Statistical pairs trading
- Requires low latency

## Integration with Platform

Store strategies in your git repository under `strategies/` directory.

Test using the backtesting tools provided by the platform.

Deploy live strategies through the execution engine with proper risk controls.

Monitor performance and adjust parameters as market conditions change.
