Stratégie de trading de signaux de tendance à latence nulle sur plusieurs périodes : système d'entrée et de sortie dynamique basé sur ZLEMA

//@version=6
// Quant Trading Pro www.quanttradingpro.com
// #1 Strategy Optimizer on the chrome extension store Quant Trading Strategy Optimizer


strategy(title="Quant Trading Zero Lag Trend Signals (MTF) Strategy", shorttitle="QT0️⃣Zero Lag Signals Strategy", overlay=true, 
     commission_type=strategy.commission.percent, 
     commission_value=0.1, 
     slippage=3, 
     default_qty_type=strategy.percent_of_equity, 
     default_qty_value=100, 
     initial_capital=1000, 
     margin_long=0, 
     margin_short=0)

// === INPUT PARAMETERS ===

// 📌 1️⃣ Main Calculations
length = input.int(70, title="Length", minval=70, maxval=7000)
mult   = input.float(1.2, "Band Multiplier", group="Main Calculations")

// === 📊 Trade Data Toggles ===
showFloatingTable = input.bool(true, "Show Floating Stats Table?", group="Trade Data")
showTradeLog      = input.bool(false, "Show Trade Log Labels on Chart?", group="Trade Data")
enableCSVExport = input.bool(false, "Enable CSV Export", group="Trade Data")

// 📌 ZLEMA Trend Confirmation for Entries
useZlemaTrendConfirm = input.bool(false, "Use ZLEMA Trend Confirmation for entry?", group="Entry Conditions")
reEnterOnLongTrend = input.bool(false, "Re-Enter on Long Trend continuation", group="Entry Conditions")

// 📌 2️⃣ Short Trades
allowShortTrades = input.bool(false, "Allow Short Trades?", group="Short Trades")

// 📌 Performance Settings
useProfitTarget  = input.bool(false, "Use Profit Target?", group="Performance Settings")
profitTargetRR   = input.float(2.0, "Profit Target (Risk-Reward Ratio)", group="Performance Settings")


// 📌 4️⃣ Dynamic TP/SL (Each Setting with Its Parameters Directly Below)
useATRStopTP    = input.bool(false, "Use ATR-Based Stop-Loss & Take-Profit?", group="Dynamic TP/SL")
atrLength       = input.int(14, "ATR Length", group="Dynamic TP/SL")
atrMultiplier   = input.float(1.5, "Stop-Loss ATR Multiplier", group="Dynamic TP/SL")
profitATRMultiplier = input.float(2.5, "Profit Target ATR Multiplier", group="Dynamic TP/SL")

useTrailingStop = input.bool(false, "Use ATR Trailing Stop?", group="Dynamic TP/SL")
trailStopMultiplier = input.float(1.5, "Trailing Stop ATR Multiplier", group="Dynamic TP/SL")

useBreakEven    = input.bool(false, "Use Break-Even Stop-Loss?", group="Dynamic TP/SL")
breakEvenRR     = input.float(1.5, "Move SL to Break-Even After RR", group="Dynamic TP/SL")

useTrendExit    = input.bool(false, "Use Trend-Based Take Profit (EMA Exit)?", group="Dynamic TP/SL")
emaExitLength   = input.int(9, "EMA Exit Length", group="Dynamic TP/SL")

// 📌 Debug Options
showZlemaDebug = input.bool(false, "Show ZLEMA Trend Debug?", group="Debug")




// ============================================================
// === 1️⃣ CALCULATIONS (Indicators, Trend, ATR, Stop/TP) ===
// ============================================================
src        = close
lag        = math.floor((length - 1) / 2)
zlema      = ta.ema(src + (src - src[lag]), length)
volatility = ta.highest(ta.atr(length), length * 3) * mult

var trend  = 0
if ta.crossover(close, zlema + volatility)
    trend := 1
if ta.crossunder(close, zlema - volatility)
    trend := -1

atrValue = ta.atr(atrLength)
emaExit  = ta.ema(close, emaExitLength)

var float stopLossLongLevel = na
var float profitTargetLongLevel = na
var float stopLossShortLevel = na
var float profitTargetShortLevel = na

var int lastEntryBarIndex = na
var float lastEntryPrice = na

// ✅ Corrected ZLEMA DownTrend Logic: Ensure ZLEMA has decreased for 5 consecutive bars
// ✅ ZLEMA Increasing for 5 Bars → Bullish Trend (Green Triangle Up at the Bottom)
zlemaUpTrend = zlema > zlema[1] and zlema[1] > zlema[2] and zlema[2] > zlema[3] and zlema[3] > zlema[4]

// ✅ ZLEMA Decreasing for 5 Bars → Bearish Trend (Red Triangle Down at the Top)
zlemaDownTrend = zlema < zlema[1] and zlema[1] < zlema[2] and zlema[2] < zlema[3] and zlema[3] < zlema[4]

if ta.crossover(trend, 0) // Long Entry
    stopLossLongLevel := useATRStopTP ? close - (atrValue * atrMultiplier) : zlema - volatility
    profitTargetLongLevel := useProfitTarget ? (close + ((close - stopLossLongLevel) * profitTargetRR)) : na

if ta.crossunder(trend, 0) // Short Entry
    stopLossShortLevel := useATRStopTP ? close + (atrValue * atrMultiplier) : zlema + volatility
    profitTargetShortLevel := useProfitTarget ? (close - ((stopLossShortLevel - close) * profitTargetRR)) : na

// ATR-Based Stop-Loss Levels for Trade Exits
var float atrStopLossLong = na
var float atrStopLossShort = na

if useATRStopTP
    if strategy.position_size > 0  // Long Position
        atrStopLossLong := na(atrStopLossLong) or strategy.position_size[1] == 0 ? close - (atrValue * atrMultiplier) : math.max(nz(atrStopLossLong[1]), close - (atrValue * atrMultiplier))  // Prevents SL from decreasing

    if strategy.position_size < 0  // Short Position
        atrStopLossShort := na(atrStopLossShort) or strategy.position_size[1] == 0 ? close + (atrValue * atrMultiplier) : math.min(nz(atrStopLossShort[1]), close + (atrValue * atrMultiplier))  // Prevents SL from increasing

// ATR-Based Take-Profit Levels
var float atrTakeProfitLong = na
var float atrTakeProfitShort = na

if useATRStopTP
    if strategy.position_size > 0  // Long Position
        atrTakeProfitLong := strategy.position_avg_price + (atrValue * profitATRMultiplier)  // Dynamic TP Based on ATR

    if strategy.position_size < 0  // Short Position
        atrTakeProfitShort := strategy.position_avg_price - (atrValue * profitATRMultiplier)  // Dynamic TP Based on ATR


// ATR Trailing Stop Levels for Trade Exits and Visualization
var float trailStopLongLine = na
var float trailStopShortLine = na

if useTrailingStop
    if strategy.position_size > 0  // Long Position
        trailStopLongLine := na(trailStopLongLine) or strategy.position_size[1] == 0 ? close - (atrValue * trailStopMultiplier) : 
                               math.max(nz(trailStopLongLine[1]), close - (atrValue * trailStopMultiplier))

    if strategy.position_size < 0  // Short Position
        trailStopShortLine := na(trailStopShortLine) or strategy.position_size[1] == 0 ? close + (atrValue * trailStopMultiplier) : 
                               math.min(nz(trailStopShortLine[1]), close + (atrValue * trailStopMultiplier))

// ============================================================
// === 2️⃣ ENTRY & EXIT LOGIC (Conditions for Trading) ===
// ============================================================


// ✅ Entry Conditions for Long Trades
longCondition = ta.crossover(trend, 0) and close > zlema + volatility 
canEnterLong = strategy.position_size == 0 or strategy.position_size[1] < 0  // Allows long entry right after short exit

if useZlemaTrendConfirm
    longCondition := longCondition and zlemaUpTrend  // Ensure ZLEMA Uptrend is true for long entries

// 🔥 Enforce that `longCondition` CANNOT be true if `zlemaUpTrend` is false
if useZlemaTrendConfirm and not zlemaUpTrend
    longCondition := false

// ✅ Entry Conditions for Short Trades
shortCondition = allowShortTrades and ta.crossunder(trend, 0) and close < zlema - volatility
canEnterShort = strategy.position_size == 0 or strategy.position_size[1] > 0  // Allows short entry right after long exit

if useZlemaTrendConfirm
    shortCondition := shortCondition and zlemaDownTrend  // Ensure ZLEMA Downtrend is true for short entries

// ✅ Long Re-Entry Condition: ZLEMA is green, position is flat, price closed below and now above ZLEMA
reEntryLongCondition = reEnterOnLongTrend and
     trend == 1 and
     trend[1] == 1 and  // ✅ Previous bar must also be in bullish trend (prevents triggering on trend change)
     strategy.position_size == 0 and
     close[1] < zlema[1] and
     close > zlema 


// ✅ Debugging: Display `longCondition` and `zlemaUpTrend` values only if the checkbox is checked
if showZlemaDebug and ta.crossover(trend, 0)
    label.new(x=bar_index, y=low, 
              text="LongCondition: " + str.tostring(longCondition) + 
                   "\nZLEMA UpTrend: " + str.tostring(zlemaUpTrend),
              color=color.white, textcolor=color.black, size=size.small, style=label.style_label_down)



// ============================================================
// === 3️⃣ TRADE EXECUTIONS (Entries, ATR SL/TP, Trailing Stop, Trend Exit) ===
// ============================================================

// 📌 Entry Conditions
if (canEnterLong and longCondition) or reEntryLongCondition
    lastEntryBarIndex := bar_index
    lastEntryPrice := close
    
    // 🛠️ Reset all SL/TP levels on Long Entry or Re-Entry
    if reEntryLongCondition
        // Trend-Based SL/TP
        stopLossLongLevel := useATRStopTP ? na : zlema - volatility
        profitTargetLongLevel := useProfitTarget and not useATRStopTP ? (close + ((close - stopLossLongLevel) * profitTargetRR)) : na

        // ATR-Based SL/TP
        atrStopLossLong := useATRStopTP ? close - (atrValue * atrMultiplier) : na
        atrTakeProfitLong := useATRStopTP ? close + (atrValue * profitATRMultiplier) : na

        // Trailing Stop
        trailStopLongLine := useTrailingStop ? close - (atrValue * trailStopMultiplier) : na

    strategy.entry(id="Long", direction=strategy.long, comment=reEntryLongCondition ? "Re-Entry Long" : "Bullish Trend Change")


if canEnterShort and shortCondition
    lastEntryBarIndex := bar_index
    lastEntryPrice := close
    strategy.entry(id="Short", direction=strategy.short, comment="Bearish Trend Change")


// 📌 ATR-Based Stop-Loss Exits (Ensures SL Always Triggers Correctly)
if useATRStopTP and strategy.position_size > 0
    if low <= atrStopLossLong
        strategy.close("Long", comment="ATR SL Hit - Long")

if useATRStopTP and strategy.position_size < 0
    if high >= atrStopLossShort
        strategy.close("Short", comment="ATR SL Hit - Short")

// 📌 ATR-Based Stop-Loss & Take-Profit Exits (Ensures TP Always Executes)
if useATRStopTP and strategy.position_size > 0 and high >= atrTakeProfitLong
    strategy.close("Long", comment="ATR TP Hit - Long")

if useATRStopTP and strategy.position_size < 0 and low <= atrTakeProfitShort
    strategy.close("Short", comment="ATR TP Hit - Short")


// 📌 Profit Target Exits (Ensures TP Always Executes Independently)
if useProfitTarget and strategy.position_size > 0 and high >= profitTargetLongLevel
    strategy.close("Long", comment="Profit Target Hit - Long")

if useProfitTarget and strategy.position_size < 0 and low <= profitTargetShortLevel
    strategy.close("Short", comment="Profit Target Hit - Short")

// 📌 Stop-Loss for Profit Target Trades (Ensures Stop-Loss Works with TP)
if useProfitTarget and strategy.position_size > 0 and low <= stopLossLongLevel
    strategy.close("Long", comment="Stop-Loss Hit - Long")

if useProfitTarget and strategy.position_size < 0 and high >= stopLossShortLevel
    strategy.close("Short", comment="Stop-Loss Hit - Short")

// 📌 ATR Trailing Stop Loss (Ensures It Works Alongside Other Exits)
if useTrailingStop and strategy.position_size > 0 and low <= trailStopLongLine
    strategy.close("Long", comment="Trailing Stop Hit - Long")

if useTrailingStop and strategy.position_size < 0 and high >= trailStopShortLine
    strategy.close("Short", comment="Trailing Stop Hit - Short")

// 📌 Trend-Based Exit (Closes Position When Trend Reverses)
if strategy.position_size > 0 and ta.crossunder(trend, 0)
    strategy.close("Long", comment="Trend Change to Bearish")

if strategy.position_size < 0 and ta.crossover(trend, 0)
    strategy.close("Short", comment="Trend Change to Bullish")

// 📌 Break-Even Stop-Loss (Adjusts Stop to Entry Price at Set Risk-Reward Ratio)
if useBreakEven and strategy.position_size > 0 and high >= strategy.position_avg_price + (strategy.position_avg_price - atrStopLossLong) * breakEvenRR
    atrStopLossLong := strategy.position_avg_price

if useBreakEven and strategy.position_size < 0 and low <= strategy.position_avg_price - (atrStopLossShort - strategy.position_avg_price) * breakEvenRR
    atrStopLossShort := strategy.position_avg_price

// 📌 EMA Exit (Closes Position if Price Crosses EMA)
if useTrendExit and strategy.position_size > 0 and low < emaExit
    strategy.close("Long", comment="Exit on EMA")

if useTrendExit and strategy.position_size < 0 and high > emaExit
    strategy.close("Short", comment="Exit on EMA")



// ============================================================
// === 4️⃣ VISUALIZATIONS (Trend Shading, Stop-Loss, TP, ATR TS) ===
// ============================================================

// 🟢🔴 Restore Bullish/Bearish Trend Shading
zlemaColor = trend == 1 ? color.new(#00ffbb, 70) : color.new(#ff1100, 70)
m = plot(series=zlema, title="Zero Lag Basis", linewidth=2, color=zlemaColor)

upper = plot(zlema + volatility, style=plot.style_linebr, color=color.new(#ff1100, 90), title="Upper Deviation Band")
lower = plot(zlema - volatility, style=plot.style_linebr, color=color.new(#00ffbb, 90), title="Lower Deviation Band")

fill(plot1=m, plot2=upper, color=(trend == -1 ? color.new(#ff1100, 80) : na), title="Bearish Fill")
fill(plot1=m, plot2=lower, color=(trend == 1 ? color.new(#00ffbb, 80) : na), title="Bullish Fill")

// ✅ Plot a lime green TriangleUp at the bottom when ZLEMA has been going UP for 5 bars
plotshape(series=zlemaUpTrend ? low - ta.atr(5) * 0.5 : na, 
          location=location.bottom, style=shape.triangleup, 
          color=color.lime, title="ZLEMA Uptrend Detected")

// ✅ Plot a red TriangleDown at the top when ZLEMA has been going DOWN for 5 bars
plotshape(series=zlemaDownTrend ? high + ta.atr(5) * 0.5 : na, 
          location=location.top, style=shape.triangledown, 
          color=color.red, title="ZLEMA Downtrend Detected")

// 🔴 Default Stop-Loss Lines (Red) - Only Show If ATR SL/TP Is Not Used
plot(series=(not useATRStopTP and strategy.position_size > 0) ? stopLossLongLevel : na, 
     style=plot.style_linebr, color=color.red, linewidth=2, title="Trend Stop-Loss - Long")

plot(series=(not useATRStopTP and strategy.position_size < 0) ? stopLossShortLevel : na, 
     style=plot.style_linebr, color=color.red, linewidth=2, title="Trend Stop-Loss - Short")

// 🟠 ATR Trailing Stop Loss Line (Thin Orange Line) - Only Draw When Checkbox is Checked
plot(series=(useTrailingStop and strategy.position_size > 0) ? trailStopLongLine : na, 
     style=plot.style_linebr, color=color.new(color.orange, 70), linewidth=1, title="ATR Trailing Stop - Long")

plot(series=(useTrailingStop and strategy.position_size < 0) ? trailStopShortLine : na, 
     style=plot.style_linebr, color=color.new(color.orange, 70), linewidth=1, title="ATR Trailing Stop - Short")

// ✅ ATR-Based Stop-Loss Visualization (Ensures Line Stays Until Trade Closes)
plot(series=(useATRStopTP and strategy.position_size > 0) ? atrStopLossLong : na, 
     style=plot.style_linebr, color=color.new(color.red, 50), linewidth=2, title="ATR-Based Stop-Loss - Long")

plot(series=(useATRStopTP and strategy.position_size < 0) ? atrStopLossShort : na, 
     style=plot.style_linebr, color=color.new(color.red, 50), linewidth=2, title="ATR-Based Stop-Loss - Short")

// ✅ ATR-Based Take-Profit Visualization (Ensures Line Stays Until Trade Closes)
plot(series=(useATRStopTP and strategy.position_size > 0) ? atrTakeProfitLong : na, 
     style=plot.style_linebr, color=color.new(color.green, 50), linewidth=2, title="ATR-Based Take-Profit - Long")

plot(series=(useATRStopTP and strategy.position_size < 0) ? atrTakeProfitShort : na, 
     style=plot.style_linebr, color=color.new(color.green, 50), linewidth=2, title="ATR-Based Take-Profit - Short")

// ✅ Standard Profit Target Visualization (Only Active if ATR SL/TP is NOT Used)
plot(series=(useProfitTarget and not useATRStopTP and strategy.position_size > 0) ? profitTargetLongLevel : na, 
     style=plot.style_linebr, color=color.green, linewidth=2, title="Profit Target - Long")

plot(series=(useProfitTarget and not useATRStopTP and strategy.position_size < 0) ? profitTargetShortLevel : na, 
     style=plot.style_linebr, color=color.green, linewidth=2, title="Profit Target - Short")

// === 📋 FLOATING TABLE: STRATEGY PERFORMANCE & SETTINGS ===

// === Track first and last trade times ===
var int firstTradeTime = na
var int lastTradeTime = na

if strategy.opentrades > 0 and na(firstTradeTime)
    firstTradeTime := time

if strategy.closedtrades > 0
    lastTradeTime := time

// === Format trade date strings safely ===
firstDateStr = "N/A"
lastDateStr  = "N/A"

if not na(firstTradeTime)
    firstDateStr := str.tostring(month(firstTradeTime)) + "/" + str.tostring(dayofmonth(firstTradeTime)) + "/" + str.tostring(year(firstTradeTime) % 100)

if not na(lastTradeTime)
    lastDateStr := str.tostring(month(lastTradeTime)) + "/" + str.tostring(dayofmonth(lastTradeTime)) + "/" + str.tostring(year(lastTradeTime) % 100)