// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © MUQWISHI

//@version=5
indicator("Wide Range Bar", overlay = true, max_lines_count = 500, max_boxes_count = 500, max_labels_count = 500)

// |++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|
// |                                   INPUT                                    |
// |++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|
// ++++++++++++++++++++++ {WRB Criteria}
var G0   = "Wide Range Bar Criteria"

wrb_clos = input.float(75, "WRB Closes Above its Range by (%)              ", 0, 
             inline = "1", group = G0, display = display.none)/100

wrb_minC = input.bool(true, "Min  (%) | WRB Wider Than Barback",
             inline = "2", group = G0, display = display.none)
wrb_minV = input.float(35, "",                                   
             inline = "2", group = G0, display = display.none)/100

wrb_maxC = input.bool(true, "Max (%) | WRB Wider Than Barback",  
             inline = "3", group = G0, display = display.none)
wrb_maxV = input.float(175, "",                                  
             inline = "3", group = G0, display = display.none)/100

cal_mode = input.string("Wide Range", "Calculation Mode           ", ["ATR", "Wide Range"], 
             inline = "4", group = G0, display = display.none)
num_bars = input.int(3, "", 1,                                   
             inline = "4", group = G0, display = display.none)

atr_len  = input.int(14, "   ➤ ATR Length           ", 1, 
             inline = "5", group = G0, display = display.none,
             tooltip = "Applicable with {Calculation Mode = ATR}")


// User input for WRB Colors
wrb_cBul = input.color(#55aef7, "         WRB Color    |    Bullish & Bearish            ", 
             inline = "6-G0", display = display.none)
wrb_cBer = input.color(#ff944d, "",                                                         
             inline = "6-G0", display = display.none)

wrb_fltC = input.bool(true, "Oversized WRB(%)",  inline = "7-G0", display = display.none)
wrb_fltV = input.float(100, "",                  inline = "7-G0", display = display.none)/100
wrb_fBul = input.color(#0a6fc2, "",            inline = "7-G0", display = display.none)
wrb_fBer = input.color(#b34700, "",            inline = "7-G0", display = display.none)


// ++++++++++++++++++++++ {Strategy Settings}
var G1  = "Strategy Settings"
lng_chk = input.bool(true, "Enable Long Trades",  group = G1)
shr_chk = input.bool(true, "Enable Short Trades", group = G1)
fde_chk = input.bool(false, "Fade The WRB",       group = G1)

// Prymiding 
max_trd = input.int(3, "Maximum Simultaneous Open Trades", 1, inline = "G1-1", group = G1, display = display.none)

// Session
timzon  = input.string("America/Los_Angeles", "Timezone",                         display = display.none)
ses_chk = input.bool(false, "Specify Intraday Trading Session",  inline = "G1-2", display = display.none)
ses_ent = input.session("0700-1145", "   Entry       ",          inline = "G1-3", display = display.none)
ses_ext = input.session("1250-1300", "   Exit          ",        inline = "G1-4", display = display.none)


// Period
prd_chk = input.bool(false, "Specify a Trading Window",
             tooltip = "Note: If the datetime of the first candle on the chart is after the entered 'From' datetime, " 
                   + "the calculation will start from the first candle on the chart.")
sTime   = input.time(timestamp("02 JAN 2020"), "   From", display = display.none)
eTime   = input.time(timestamp("01 DEC 2050"), "   To  ", display = display.none)


// ++++++++++++++++++++++ {Entry Settings}
var G2   = "Entry Trade Settings"
ent_shrO = input.string("Dollar Risk", "Position Sizer        ", ["Dollar Risk", "Dollar Size"],
             inline = "1", group = G2, display = display.none)
ent_shrV = input.float(10000, "", 0, 
             inline = "1", group = G2, display = display.none,
 tooltip = "Dollar Risk: The amount of money is willing to lose if the trade does not go as planned." + 
           "\n\nDollar Size: The total monetary value willing to apply in a single trade.")

ent_ordr = input.float(75, "Place a Limit Order at WRB (%)          ", 
             inline = "2", group = G2, display= display.none, 
             tooltip = "For Long Direction:\n   0% → Low of WRB | 100% → High of WRB\n\n" + 
                       "For Short Direction:\n   0% → High of WRB | 100% → Low of WRB")/100

ent_can1 = input.bool(true, "Entry Within Bars                            ", 
             inline = "4", group = G2, display = display.none)
ent_bar  = input.int(4, "", 1,                                        
             inline = "4", group = G2, display = display.none)

ent_can2 = input.bool(true, "All Bars Must Close Inside WRB",                   
             group = G2, display = display.none)



// ++++++++++++++++++++++ {Exit Settings}
var G3   = "Exit Trade Settings"
stp_ordr = input.float(25, "Place a Stop-Loss at WRB (%)               ", 
             inline = "1", group = G3, display = display.none,
             tooltip = "For Long Direction:\n   0% → Low of WRB | 100% → High of WRB\n\n" + 
                       "For Short Direction:\n   0% → High of WRB | 100% → Low of WRB")/100

tgt_chk  = input.bool(true, "Target (R)                                             ", 
             inline = "2", group = G3, display = display.none)

tgt_ordr = input.float(05, "", 0,                                                      
             inline = "2", group = G3, display = display.none)

trl_chk  = input.bool(true, "Trailing starts at                               ",              
             inline = "3", group = G3, display = display.none)
typ_trl  = input.string("Touch", "", ["Touch", "Close Over"],                                 
             inline = "3", group = G3, display = display.none)   
srt_trl  = input.int(3, "          ... of (R) Level                                     ", 0, 
             inline = "4", group = G3, display = display.none)
dis_trl  = input.float(2, "          ... with a Distance of (R)              ", 0,            
             inline = "5", group = G3, display = display.none)

brk_chk  = input.bool(true, "Enable Breakeven Stop at (R)", 
             inline = "6", group = G3, display = display.none)
brk_R    = input.float(1.5, "  ", 0,                        
             inline = "6", group = G3, display = display.none)

ext_tim  = input.bool(true, "Close All Open Trades at End of Session",
             tooltip = "It must the 'Specify a Trading Session' be enabled.")


// ++++++++++++++++++++++ {Styling Settings}
var G4  = "Styling Drawings"

ent_sty = input.string("________", "Entry             ", ["________", "-----------", "..........."], 
             group = G4, inline = "1", display = display.none)
ent_siz = input.int(2, "", 1,                         
             group = G4, inline = "1", display = display.none)
ent_col = input.color(color.blue, "",               
             group = G4, inline = "1")

stp_sty = input.string("________", "StopLoss      ", ["________", "-----------", "..........."], 
             group = G4, inline = "2", display = display.none)
stp_siz = input.int(2, "", 1,                         
             group = G4, inline = "2", display = display.none)
stp_col = input.color(color.red, "",                
             group = G4, inline = "2")

tgt_sty = input.string("________", "Target           ", ["________", "-----------", "..........."], 
             group = G4, inline = "3", display = display.none)
tgt_siz = input.int(1, "", 1,                         
             group = G4, inline = "3", display = display.none)
tgt_col = input.color(color.green, "",              
             group = G4, inline = "3")

trl_sty = input.string("⦵⦵⦵⦵", "Trailing        ", ["________", "〇〇〇〇", "⦵⦵⦵⦵"],        
             group = G4, inline = "4", display = display.none)
trl_siz = input.int(3, "", 1,                         group = G4, inline = "4", display = display.none)
trl_col = input.color(color.fuchsia, "",            group = G4, inline = "4")


lab_typ = input.string("Level & Tooltipped Price", "Labels           ", 
             ["Level Ø Price", "Price", "Level", "Level & Tooltipped Price"],                  
             inline = "G4-5", display = display.none)
lab_siz = input.string("Normal", "", ["Auto", "Huge", "Large", "Normal", "Small", "Tiny"],  
             inline = "G4-5", display = display.none)

brk_lin = input.bool(true, "Show Breakeven R Level",                inline = "G4-6")
brk_col = input.color(#ff9800, "",                                inline = "G4-6")

trd_chr = input.bool(true, "Show ▲▼ Indicating Signal Trading",     inline = "G4-7")
lgt_chr = input.color(#5e5e5e, "",                                inline = "G4-7")
sht_chr = input.color(#5e5e5e, "",                                inline = "G4-7")

shr_chr = input.bool(true, "Show Number of Shares Tooltipped in ♦", inline = "G4-8")
shr_col = input.color(color.fuchsia, "         ",                 inline = "G4-8")

cnl_chr = input.bool(true, "Show ❌ When Entry Order is Canceled")

ovr_trd = input.bool(true, "Shadow Open Trades ",      inline = "G4-9")
col_ovr = input.color(color.new(color.gray, 75), "", inline = "G4-9")


// |++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|
// |                                CALCULATION                                 |
// |++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|
// ++++++++++++ Trading Period 
trade_window()   => prd_chk ? sTime <= time and time <= eTime : true

// ++++++++++++ Trading Session
entry_session() => ses_chk ? not na(time("", ses_ent, timzon)) : true
exit_session()  => ses_chk ? not na(time("", ses_ext, timzon)) : false

// ++++++++++++ Calculate ATR and Wide Range 
atr  = ta.rma(ta.tr, atr_len)
wide = high - low 

// ++++++++++++ ATR or WRB (previous bars)
bar_range = cal_mode == "ATR" ? atr : wide

// ++++++++++++  Detect WRB 
wrb_signal = int(na)
wrb_ovrSiz = int(na)
if   ((close > open and close > low  + (high-low) * wrb_clos) or 
      (close < open and close < high - (high-low) * wrb_clos))

    max_prev_range = float(na)
    for i = 1 to num_bars
        max_prev_range := na(max_prev_range) ? bar_range[1] : math.max(max_prev_range, bar_range[i])
    
    if (wrb_minC ? max_prev_range + max_prev_range * wrb_minV <= bar_range : true) and 
       (wrb_maxC ? max_prev_range + max_prev_range * wrb_maxV >= bar_range : true)
        wrb_signal := close > open ?  1 : -1

    if wrb_fltC and max_prev_range + max_prev_range * wrb_fltV <= bar_range
        wrb_ovrSiz := close > open ? 2 : -2

// Color Bars
signal = (fde_chk ? -1 : 1) * (not na(wrb_ovrSiz) ? wrb_ovrSiz : not na(wrb_signal) ? wrb_signal : na)
barCol = signal == 2 ? wrb_fBul : signal == -2 ? wrb_fBer : signal == 1 ? wrb_cBul : signal == -1 ? wrb_cBer : na
barcolor(barCol)


// |++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|
// |                        MATRICES & DRAWING FUNCTIONS                        |
// |++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|
// +++++++++++ Calculate Amount of Shares 
qtyShares(e, s) =>
    out = float(na)
    if ent_shrO == "Dollar Risk"
        out := switch syminfo.type
            "forex"   => ent_shrV * e / (math.abs(e-s))
            => ent_shrV / (math.abs(e-s) * syminfo.pointvalue)

    else if ent_shrO == "Dollar Size"
        out := switch syminfo.type
            "forex"   => ent_shrV * e
            => ent_shrV / e

    str.tostring(out > 1 ? math.round(out, 3) : out, "0.00######")


// ++++++++++++ Craete Matrices
// {Side-OrderType-OrderBarIndex-EntryLimit-Stoploss-Target-High (Low -> Short)-OpenEntry-OpenBarIndex-Shares}
var trade_mtx = matrix.new<float>(na, 9, na)
var level_mtx = matrix.new<line> (na, int((brk_lin and brk_chk ? 1 : 0) + math.ceil(2 + tgt_ordr)), na)
var label_mtx = matrix.new<label>(na, int((brk_lin and brk_chk ? 1 : 0) + math.ceil(2 + tgt_ordr)), na)

// ++++++++++++ Rounding Function to mintick
m(x) =>
    math.round_to_mintick(x)

// ++++++++++++ Line Style Function 
styLine(s) =>
    switch s
        "..........."  => line.style_dotted   
        "-----------"  => line.style_dashed   
        "________"     => line.style_solid

// ++++++++++++ Line Extention
labText(p, l) =>
    q1 = "", q2 = "" 
    if lab_typ != "Level & Tooltipped Price"
        q1 := str.contains(lab_typ, "Level") ? l : ""
        q2 := str.contains(lab_typ, "Price") ? str.tostring(p, "0.00##########") : ""
    else 
        q1 := l

    q1 + (q1 != "" and q2 != "" ? " Ø " : "") + q2

// ++++++++++++ Line Function
lin(x, y, col, sty, siz) =>
    line.new(x, y, x + 1, y, xloc.bar_index, extend.none, col, sty, siz)

// ++++++++++++ Label Function 
lab(x, y, txt, col) =>
    label.new(x, y, labText(y, txt), xloc.bar_index, yloc.price, color(na), 
     label.style_label_left, col, str.lower(lab_siz), text.align_left, 
     lab_typ == "Level & Tooltipped Price" ? str.tostring(y, "0.00##########") : "")

// ++++++++++++ Trade Direction Label Function
dir(y, dir) =>
    if trd_chr 
        label.new(bar_index, y, "", xloc.bar_index, yloc.price, dir == 1 ? lgt_chr : sht_chr, 
         dir == 1 ? label.style_triangleup : label.style_triangledown, color(na), size.auto)

// ++++++++++++ Shares Label Function
dot(y, txt) =>
    if shr_chr
        label.new(bar_index, y, "", xloc.bar_index, yloc.price, shr_col, label.style_diamond, color(na), 
         size.auto, tooltip = "Shares: " + txt)


// ++++++++++++ Function to Draw Line at New Signal
newDraw(entry, stoploss) =>
    lines  = array.new<line>(na)
    labels = array.new<label>(na)
    lines.push (lin(bar_index, stoploss,       stp_col, styLine(stp_sty), stp_siz))
    lines.push (lin(bar_index,    entry,       ent_col, styLine(ent_sty), ent_siz))
    labels.push(lab(bar_index, stoploss, "SL", stp_col))
    labels.push(lab(bar_index,    entry, "EN", ent_col))

    for i = lines.size() to level_mtx.columns()-1 
        lines.push (lin(int(na), float(na),     tgt_col, styLine(tgt_sty), tgt_siz))
        labels.push(lab(int(na), float(na), "", tgt_col))

    level_mtx.add_row(level_mtx.rows(),  lines)
    label_mtx.add_row(label_mtx.rows(), labels)

    // Color Overlab Trades
    if ovr_trd and level_mtx.rows() > 0
        idnx = level_mtx.rows() - 1
        linefill.new(level_mtx.get(idnx, 0), level_mtx.get(idnx, level_mtx.columns()-1), col_ovr)

// ++++++++++++ Function to Update Existing Drawings 
updateDraw(s, r) =>
    numRows = level_mtx.rows()
    numCols = level_mtx.columns()

    // if not na(breakevenR)
    //     lines.push (lin(bar_index, breakevenR,       brk_col, styLine("..........."), 2))
    //     labels.push(lab(bar_index, breakevenR, "BK", brk_col))


    if numRows > 0
        for i = 0 to numRows - 1
            k = 1,
            entry         = trade_mtx.get(i, 3)
            stoploss      = trade_mtx.get(i, 4)
            OrderBarIndex = int(trade_mtx.get(i, 2))

            if brk_lin and brk_chk and na(level_mtx.get(i, 2).get_x1())
                breakevenR = s > 0 ? entry + brk_R * math.abs(entry - stoploss) :
                                     entry - brk_R * math.abs(entry - stoploss)

                level_mtx.set(i, 2, lin(OrderBarIndex, breakevenR, brk_col, styLine("..........."), 2))
                label_mtx.set(i, 2, lab(OrderBarIndex, breakevenR, "BK", brk_col))


            for j = 0 to numCols - 1
                level_id = level_mtx.get(i, j)
                label_id = label_mtx.get(i, j)

                if math.abs(trade_mtx.get(i, 0)) == r and na(level_id.get_x1())

                    y  = s > 0 ?  entry + math.abs(entry - stoploss) * k : 
                                  entry - math.abs(entry - stoploss) * k
                    y := m(y)

                    level_id.set_xy1 (OrderBarIndex, y)
                    level_id.set_xy2 (bar_index,     y)
                    label_id.set_xy  (bar_index,     y)

                    label_id.set_text(labText(y, "R" + str.tostring(k)))
                    if lab_typ == "Level & Tooltipped Price"
                        label_id.set_tooltip(str.tostring(y, "0.00##########"))

                    k += 1

                level_id.set_x2(bar_index)
                label_id.set_x (bar_index)

// ++++++++++++ Function to Remove Drawings
removeDraw(i, s) =>
    numCols = level_mtx.columns()
    for j = 0 to numCols - 1
        label_id = label_mtx.get(i, j)
        txt = (s < 0 ? "\n" : "") + label_id.get_text() + (s > 0 ? "\n" : "")
        label_id.set_style(label.style_label_center)
        label_id.set_text(txt)
       

    trade_mtx.remove_row(i)
    level_mtx.remove_row(i)
    label_mtx.remove_row(i)


// |++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|
// |                                  STRATEGY                                  |
// |++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|
// ++++++++++ Signals 
upWRB_signal = wrb_signal > 0
dnWRB_signal = wrb_signal < 0


// ++++++++++ Manage Trades
var size     = 0
cancel_char = int(na)


// [2] Update Trading Status
if trade_mtx.rows() > 0
    i = 0
    while i <= trade_mtx.rows() - 1
        side = trade_mtx.get(i, 0)
        updateDraw(side, 2)

        // Find an Entry for Ordered Trade
        if math.abs(side) == 1
            order_type    = trade_mtx.get(i, 1)
            entry         = trade_mtx.get(i, 3)
            max_bar_price = trade_mtx.get(i, 6)

            // Cancel Order
            if (ent_can1 ? bar_index - trade_mtx.get(i, 2) >= ent_bar : false) or 
                 (ent_can2 and not na(max_bar_price) ? 
                 (side > 0 and close > max_bar_price and  low  > entry) or       
                 (side < 0 and close < max_bar_price and  high < entry) : false)
                
                cancel_char := side > 0 ? 1 : -1
                removeDraw(i, side) 

            else 
                // Long Order Execution 
                if size >= 0 and side == 1 and (order_type == 1 ? low <= entry : high >= entry)
                    updateDraw(side, 1)
                    size +=  1, side :=  2

                    entry := order_type == 1 ? (open <= entry ? open : entry) : (open >= entry ? open : entry)
                    dir(entry,  1)

                    trade_mtx.set(i, 0,      side)
                    trade_mtx.set(i, 8, bar_index)


                // Short Order Execution 
                else if size <= 0 and side == -1 and (order_type == 1 ? high >= entry : low <= entry)
                    updateDraw(side, 1)
                    size += -1, side := -2

                    entry := order_type == 1 ? (open >= entry ? open : entry) : (open <= entry ? open : entry)
                    dir(entry, -1)    

                    trade_mtx.set(i, 0,      side)
                    trade_mtx.set(i, 8, bar_index)


        // Manage Open Trade
        if math.abs(side) == 2
            entry    = trade_mtx.get(i, 3)
            stoploss = trade_mtx.get(i, 4)
            target   = trade_mtx.get(i, 5)

            enBarInx = trade_mtx.get(i, 8)

            // Long Trade   
            if side == 2 

                // Set Up Breakeven Stop 
                if bar_index - enBarInx > 0 
                    if brk_chk 
                        if na(trade_mtx.get(i, 7)) ? stoploss < entry : trade_mtx.get(i, 7) < entry 
                            r = (high - entry)/math.abs(entry - stoploss)
                            if brk_R <= r and low > entry 
                                trade_mtx.set(i, 7, entry)

                    if trl_chk
                        src = (typ_trl == "Close Over" ? close : high)
                        r   = int((src - entry)/math.abs(entry - stoploss))
                        if srt_trl <= r
                            nTrail = m(entry + math.abs(entry - stoploss) * (r - dis_trl))
                            trail  = na(trade_mtx.get(i, 7)) ? nTrail : math.max(trade_mtx.get(i, 7), nTrail)
                            trade_mtx.set(i, 7, trail)

                // Exit Trade
                stoploss := array.from(trade_mtx.get(i, 7), trade_mtx.get(i, 4)).max()
                if (ext_tim ? exit_session() : false) or 
                     ((high >= target or low <= stoploss) and (bar_index - enBarInx == 0 ? close < open : true))
                    size += -1
                    removeDraw(i, side)

                    exit = open >= target or open <= stoploss ? open : high >= target ? target : stoploss
                    dir(exit, -1)


            // Short Trade
            else if side == -2

                // Set Up Breakeven Stop
                if bar_index - enBarInx > 0
                    if brk_chk 
                        if na(trade_mtx.get(i, 7)) ? stoploss > entry : trade_mtx.get(i, 7) > entry
                            r = (entry - low)/math.abs(entry - stoploss)
                            if brk_R <= r and high < entry 
                                trade_mtx.set(i, 7, entry)

                    if trl_chk
                        src = (typ_trl == "Close Over" ? close : low)
                        r   = int((entry - src)/math.abs(entry - stoploss))
                        if srt_trl <= r
                            nTrail = m(entry - math.abs(entry - stoploss) * (r - dis_trl))
                            trail  = na(trade_mtx.get(i, 7)) ? nTrail : math.min(trade_mtx.get(i, 7), nTrail)
                            trade_mtx.set(i, 7, trail)

        
                // Exit Trade
                stoploss := array.from(trade_mtx.get(i, 7), trade_mtx.get(i, 4)).min()
                if (ext_tim ? exit_session() : false) or 
                   ((high >= stoploss or low <= target) and (bar_index - enBarInx == 0 ? close > open : true))

                    size += 1
                    removeDraw(i, side)

                    exit = open <= target or open >= stoploss ? open : high >= stoploss ? stoploss : target
                    dir(exit,  1) 
            i += 1

        else 
            i += 1


// Ploting Cancelation Char 
plotchar(cnl_chr and cancel_char ==  1 ? high : na, "X Char", "❌", location.abovebar, editable = false, 
         display = display.pane, size = size.auto)
plotchar(cnl_chr and cancel_char == -1 ?  low : na, "X Char", "❌", location.belowbar, editable = false, 
         display = display.pane, size = size.auto)


// Breakeven Plots
var line_style = trl_sty == "________" ? 1 : trl_sty == "〇〇〇〇" ? 2 : 3
plot(not(line_style == 2) and trade_mtx.rows() > 0 ? trade_mtx.get(0, 7) : na, "Trailing#1", trl_col, trl_siz, 
     plot.style_steplinebr, editable = false, display = display.pane)
plot(not(line_style == 2) and trade_mtx.rows() > 1 ? trade_mtx.get(1, 7) : na, "Trailing#2", trl_col, trl_siz, 
     plot.style_steplinebr, editable = false, display = display.pane)
plot(not(line_style == 2) and trade_mtx.rows() > 2 ? trade_mtx.get(2, 7) : na, "Trailing#3", trl_col, trl_siz, 
     plot.style_steplinebr, editable = false, display = display.pane)
plot(not(line_style == 2) and trade_mtx.rows() > 3 ? trade_mtx.get(3, 7) : na, "Trailing#4", trl_col, trl_siz, 
     plot.style_steplinebr, editable = false, display = display.pane)
plot(not(line_style == 2) and trade_mtx.rows() > 4 ? trade_mtx.get(4, 7) : na, "Trailing#5", trl_col, trl_siz, 
     plot.style_steplinebr, editable = false, display = display.pane)

plot(not(line_style == 1) and trade_mtx.rows() > 0 ? trade_mtx.get(0, 7) : na, "Trailing#1", trl_col, trl_siz, 
     plot.style_circles, editable = false, display = display.pane)
plot(not(line_style == 1) and trade_mtx.rows() > 1 ? trade_mtx.get(1, 7) : na, "Trailing#2", trl_col, trl_siz, 
     plot.style_circles, editable = false, display = display.pane)
plot(not(line_style == 1) and trade_mtx.rows() > 2 ? trade_mtx.get(2, 7) : na, "Trailing#3", trl_col, trl_siz, 
     plot.style_circles, editable = false, display = display.pane)
plot(not(line_style == 1) and trade_mtx.rows() > 3 ? trade_mtx.get(3, 7) : na, "Trailing#4", trl_col, trl_siz, 
     plot.style_circles, editable = false, display = display.pane)
plot(not(line_style == 1) and trade_mtx.rows() > 4 ? trade_mtx.get(4, 7) : na, "Trailing#5", trl_col, trl_siz, 
     plot.style_circles, editable = false, display = display.pane)


// [1] Send New Trade
if trade_window() and entry_session() and math.abs(size) < max_trd and (upWRB_signal or dnWRB_signal) 
    indx = trade_mtx.rows()

    // Place a LONG order 
    if lng_chk and size >= 0 
        entry      = m(low + (high-low) * ent_ordr)
        stoploss   = m(low + (high-low) * stp_ordr)
        target     = tgt_chk ? m(entry + math.abs(entry - stoploss) * tgt_ordr) : float(na)
        
        // NO FADE
        if upWRB_signal and not(fde_chk)
            trade_mtx.add_row(indx,
             array.from(1, 1, bar_index, entry, stoploss, target, m(high), float(na), int(na)))  
      
            dot(low, qtyShares(entry, stoploss)) 
            newDraw(entry, stoploss)

        // FADE is Enabled     
        else if dnWRB_signal and fde_chk
            orderType   = entry < close ? 1 : 2     //(1) Buy Stop Order. (2) Limit Order 
            trade_mtx.add_row(indx, 
             array.from(1, orderType, bar_index, entry, stoploss, target, float(na), float(na), int(na)))
        
            dot(low, qtyShares(entry, stoploss)) 
            newDraw(entry, stoploss)


    // Place a SHORT order
    if shr_chk and size <= 0
        entry      = m(high - (high-low) * ent_ordr), 
        stoploss   = m(high - (high-low) * stp_ordr)
        target     = tgt_chk ? m(entry - math.abs(entry - stoploss) * tgt_ordr) : float(na)

        // NO FADE
        if dnWRB_signal and not(fde_chk)
            trade_mtx.add_row(indx, 
             array.from(-1, 1, bar_index, entry, stoploss, target, m(low), float(na), int(na)))
      
            dot(high, qtyShares(entry, stoploss)) 
            newDraw(entry, stoploss)

        // FADE is Enabled
        else if upWRB_signal and fde_chk
            orderType   = entry > close ? 1 : 2     //(1) Buy Stop Order. (2) Limit Order 
            trade_mtx.add_row(indx, 
             array.from(-1, orderType, bar_index, entry, stoploss, target, float(na), float(na), int(na)))  

            dot(high, qtyShares(entry, stoploss)) 
            newDraw(entry, stoploss)