ایلیٹ ویو فریکٹل سسٹم

/*backtest
start: 2025-08-01 00:00:00
end: 2025-12-02 08:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © mbedaiwi2  
//@version=6  
strategy("Elliott Wave Full Fractal System Clean", overlay=true, max_labels_count=500, max_lines_count=500, max_boxes_count=500, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=5, commission_type=strategy.commission.percent, commission_value=0.1, slippage=2)

//══════════════════════════════════════════════════════════════════════════════
// 1. SETTINGS
//══════════════════════════════════════════════════════════════════════════════

grpCycle    = "1. Primary Degree (Macro Trend)"
showPrimary = input.bool(true, "Show Primary Waves (1, 2...)", group=grpCycle)
lenPriL     = input.int(21, "Primary Lookback Left", group=grpCycle)
lenPriR     = input.int(21, "Primary Lookback Right", group=grpCycle)

grpInter    = "2. Intermediate Degree (Trading Degree)"
showInter   = input.bool(true, "Show Intermediate Waves ( (1), (2)... )", group=grpInter)
lenIntL     = input.int(8,  "Intermediate Lookback Left", group=grpInter)
lenIntR     = input.int(8,  "Intermediate Lookback Right", group=grpInter)

grpMinor    = "3. Minor Degree (Micro Structure)"
showMinor   = input.bool(true, "Show Minor Waves ( i, ii... )", group=grpMinor)
lenMinL     = input.int(3,  "Minor Lookback Left", group=grpMinor)
lenMinR     = input.int(3,  "Minor Lookback Right", group=grpMinor)

grpRules    = "Theory Rules"
rule_Strict = input.bool(true, "Strict Rules (No Overlap, W3 Not Shortest)", group=grpRules)
showABC     = input.bool(true, "Show ABC Corrections", group=grpRules)

grpTrade    = "STRATEGY SETTINGS"
trade_on    = input.bool(true, "Active Trading Signals", group=grpTrade)
fib_entry   = input.float(0.5, "W4 Entry Fib (0.5 = 50% Pullback)", minval=0.3, maxval=0.7, step=0.05, group=grpTrade)
fib_target  = input.float(1.618, "W5 Target Extension", group=grpTrade)

//══════════════════════════════════════════════════════════════════════════════
// 2. HELPER FUNCTIONS
//══════════════════════════════════════════════════════════════════════════════

// Visual Styles
f_get_style(_degree) =>
    if _degree == "Primary"
        [color.new(#2962FF, 0), "Circle", 3] // Blue
    else if _degree == "Intermediate"
        [color.new(#00E676, 0), "Paren", 2]  // Green
    else
        [color.new(#FF5252, 0), "Roman", 1]  // Red

// Label Drawer
f_draw_wave(int _idx, float _price, int _count, bool _isBull, string _degree) =>
    [cWave, fmt, wid] = f_get_style(_degree)
    string txt = ""
    
    // Formatting logic
    if fmt == "Circle"
        txt := _count==1?"①":_count==2?"②":_count==3?"③":_count==4?"④":_count==5?"⑤":_count==11?"Ⓐ":_count==12?"Ⓑ":_count==13?"Ⓒ":"?"
    else if fmt == "Paren"
        txt := _count==1?"(1)":_count==2?"(2)":_count==3?"(3)":_count==4?"(4)":_count==5?"(5)":_count==11?"(A)":_count==12?"(B)":_count==13?"(C)":"?"
    else 
        txt := _count==1?"i":_count==2?"ii":_count==3?"iii":_count==4?"iv":_count==5?"v":_count==11?"a":_count==12?"b":_count==13?"c":"?"

    label.new(_idx, na, txt, xloc.bar_index, 
              _isBull ? yloc.abovebar : yloc.belowbar, 
              cWave, 
              _isBull ? label.style_label_down : label.style_label_up, 
              color.white, _degree == "Primary" ? size.normal : size.small)

// Pivot Finder
f_find_pivots(_L, _R) =>
    float _ph = ta.pivothigh(high, _L, _R)
    float _pl = ta.pivotlow(low, _L, _R)
    var array<int>   _idx = array.new_int()
    var array<float> _prc = array.new_float()
    var array<int>   _typ = array.new_int()
    if not na(_ph)
        array.push(_idx, bar_index[_R])
        array.push(_prc, _ph)
        array.push(_typ, 1)
    if not na(_pl)
        array.push(_idx, bar_index[_R])
        array.push(_prc, _pl)
        array.push(_typ, -1)
    [_idx, _prc, _typ]

//══════════════════════════════════════════════════════════════════════════════
// 3. VISUALIZATION ENGINE
//══════════════════════════════════════════════════════════════════════════════

f_process_degree(string _degName, int _lenL, int _lenR, bool _show) =>
    [idx, prc, typ] = f_find_pivots(_lenL, _lenR)
    var int lastIdx = 0
    var int lastW5Idx = 0
    var bool lastWasBull = false
    
    if _show and array.size(idx) >= 6
        int sz = array.size(idx)
        int   i0=array.get(idx,sz-6), i1=array.get(idx,sz-5), i2=array.get(idx,sz-4), i3=array.get(idx,sz-3), i4=array.get(idx,sz-2), i5=array.get(idx,sz-1)
        float p0=array.get(prc,sz-6), p1=array.get(prc,sz-5), p2=array.get(prc,sz-4), p3=array.get(prc,sz-3), p4=array.get(prc,sz-2), p5=array.get(prc,sz-1)
        int   t0=array.get(typ,sz-6)

        // --- IMPULSE WAVE DETECTION ---
        if i0 > lastIdx
            // Bullish 5-Wave
            if t0 == -1 and p1>p0 and p3>p1 and p5>p3 and p2>p0 and p4>p2
                bool r3 = rule_Strict ? (math.abs(p3-p2) > math.abs(p1-p0)) : true // W3 > W1
                bool r4 = rule_Strict ? (p4 > p1) : true // No Overlap
                
                if r3 and r4
                    lastIdx := i5
                    lastW5Idx := i5
                    lastWasBull := true
                    // Draw Labels
                    f_draw_wave(i1, p1, 1, true, _degName)
                    f_draw_wave(i2, p2, 2, true, _degName)
                    f_draw_wave(i3, p3, 3, true, _degName)
                    f_draw_wave(i4, p4, 4, true, _degName)
                    f_draw_wave(i5, p5, 5, true, _degName)
                    // Connect Lines
                    [c, f, w] = f_get_style(_degName)


            // Bearish 5-Wave
            else if t0 == 1 and p1<p0 and p3<p1 and p5<p3 and p2<p0 and p4<p2
                bool r3b = rule_Strict ? (math.abs(p3-p2) > math.abs(p1-p0)) : true
                bool r4b = rule_Strict ? (p4 < p1) : true
                
                if r3b and r4b
                    lastIdx := i5
                    lastW5Idx := i5
                    lastWasBull := false
                    f_draw_wave(i1, p1, 1, false, _degName)
                    f_draw_wave(i2, p2, 2, false, _degName)
                    f_draw_wave(i3, p3, 3, false, _degName)
                    f_draw_wave(i4, p4, 4, false, _degName)
                    f_draw_wave(i5, p5, 5, false, _degName)
                    [c, f, w] = f_get_style(_degName)


        // --- ABC CORRECTION DETECTION ---
        if showABC and lastW5Idx > 0 and i3 >= lastW5Idx
            // Looking for 3 moves (A-B-C) after W5
            int   ia=i3, ib=i4, ic=i5
            float pa=p3, pb=p4, pc=p5
            
            // If previous was Bullish, we look for Down-Up-Down
            if lastWasBull and p3 < p2 // First move down
                if pc < pa and pb < array.get(prc, sz-4) // C lower than A, B lower than Start
                    lastIdx := ic // Update so we don't draw over it
                    f_draw_wave(ia, pa, 11, false, _degName) // A
                    f_draw_wave(ib, pb, 12, true, _degName)  // B
                    f_draw_wave(ic, pc, 13, false, _degName) // C
                    [c, f, w] = f_get_style(_degName)


            // If previous was Bearish, we look for Up-Down-Up
            if not lastWasBull and p3 > p2
                if pc > pa and pb > array.get(prc, sz-4)
                    lastIdx := ic
                    f_draw_wave(ia, pa, 11, true, _degName) // A
                    f_draw_wave(ib, pb, 12, false, _degName) // B
                    f_draw_wave(ic, pc, 13, true, _degName) // C
                    [c, f, w] = f_get_style(_degName)



f_process_degree("Primary", lenPriL, lenPriR, showPrimary)
f_process_degree("Intermediate", lenIntL, lenIntR, showInter)
f_process_degree("Minor", lenMinL, lenMinR, showMinor)

//══════════════════════════════════════════════════════════════════════════════
// 4. TRADING ENGINE (Intermediate Degree)
//══════════════════════════════════════════════════════════════════════════════

[t_idx, t_prc, t_typ] = f_find_pivots(lenIntL, lenIntR)

var int   trade_lastW3 = 0
var int   trade_dir    = 0 // 1=Long, -1=Short
var float trade_entry  = na
var float trade_stop   = na
var float trade_tp     = na

if trade_on and array.size(t_idx) >= 4
    int sz = array.size(t_idx)
    int   i0=array.get(t_idx,sz-4), i1=array.get(t_idx,sz-3), i2=array.get(t_idx,sz-2), i3=array.get(t_idx,sz-1)
    float p0=array.get(t_prc,sz-4), p1=array.get(t_prc,sz-3), p2=array.get(t_prc,sz-2), p3=array.get(t_prc,sz-1)
    int   t0=array.get(t_typ,sz-4)
    
    // Check for NEW WAVE 3
    if i3 > trade_lastW3 
        
        // --- LONG SETUP ---
        if t0 == -1 
            bool isBull = (p1 > p0) and (p2 > p0) and (p3 > p1) and (p2 < p1)
            bool rule3  = rule_Strict ? (p3 - p2) > (p1 - p0) : true 
            
            if isBull and rule3
                trade_lastW3 := i3
                float w3_height = p3 - p2
                trade_entry := p3 - (w3_height * fib_entry)
                trade_stop  := p1 
                trade_tp    := p3 + (w3_height * fib_target)
                
                if trade_entry > trade_stop
                    trade_dir := 1

        // --- SHORT SETUP ---
        else if t0 == 1
            bool isBear = (p1 < p0) and (p2 < p0) and (p3 < p1) and (p2 > p1)
            bool rule3b = rule_Strict ? (p2 - p3) > (p0 - p1) : true
            
            if isBear and rule3b
                trade_lastW3 := i3
                float w3_height = p2 - p3
                trade_entry := p3 + (w3_height * fib_entry)
                trade_stop  := p1
                trade_tp    := p3 - (w3_height * fib_target)
                
                if trade_entry < trade_stop
                    trade_dir := -1

// EXECUTE TRADE
if trade_dir == 1 
    if low <= trade_entry
        strategy.entry("Sniper Long", strategy.long)
        strategy.exit("TP/SL", "Sniper Long", limit=trade_tp, stop=trade_stop)
        label.new(bar_index, na, "Long Exec", style=label.style_label_up, yloc=yloc.belowbar, color=color.blue, textcolor=color.white, size=size.small)
        trade_dir := 0 

    if close < trade_stop 
        trade_dir := 0
    if high > array.get(t_prc, array.size(t_prc)-1) 
        trade_dir := 0

if trade_dir == -1 
    if high >= trade_entry
        strategy.entry("Sniper Short", strategy.short)
        strategy.exit("TP/SL", "Sniper Short", limit=trade_tp, stop=trade_stop)
        label.new(bar_index, na, "Short Exec", style=label.style_label_down, yloc=yloc.abovebar, color=color.orange, textcolor=color.white, size=size.small)
        trade_dir := 0

    if close > trade_stop
        trade_dir := 0
    if low < array.get(t_prc, array.size(t_prc)-1) 
        trade_dir := 0