//@version=5

//Conbined by Hamza le 02-12-2024

indicator(title="Help4Help+",overlay=false)
n1 = input.int(10, "Channel Length")
n2 = input.int(21, "Average Length")
obLevel1 = input.int(60, "Over Bought Level 1")
obLevel2 = input.int(53, "Over Bought Level 2")
osLevel1 = input.int(-60, "Over Sold Level 1")
osLevel2 = input.int(-53, "Over Sold Level 2")

ap = hlc3
esa = ta.ema(ap, n1)
d = ta.ema(math.abs(ap - esa), n1)
ci = (ap - esa) / (0.015 * d)
tci = ta.ema(ci, n2)

wt1 = tci
wt2 = ta.sma(wt1,4)

plot(0, color=color.gray)
plot(obLevel1, color=color.red)
plot(osLevel1, color=color.green)
plot(obLevel2, color=color.red, style=plot.style_circles)
plot(osLevel2, color=color.green, style=plot.style_circles)

plot(wt1, color=color.green)
plot(wt2, color=color.red, style=plot.style_line)
plot(wt1-wt2, color=color.blue, style=plot.style_areabr)

///////////////////////////////////////////////////////////////////////////////////
/

var string calcGroup = 'Calculation'

length = input.int(title='ATR Period', defval=22, group=calcGroup)
mult = input.float(title='ATR Multiplier', step=0.1, defval=3.0, group=calcGroup)
useClose = input.bool(title='Use Close Price for Extremums', defval=true,
group=calcGroup)

var string visualGroup = 'Visuals'

showLabels = input.bool(title='Show Buy/Sell Labels', defval=false,
group=visualGroup)
highlightState = input.bool(title='Highlight State', defval=true,
group=visualGroup)

var string alertGroup = 'Alerts'

awaitBarConfirmation = input.bool(title="Await Bar Confirmation", defval=true,
group=alertGroup)

atr = mult * ta.atr(length)

longStop = (useClose ? ta.highest(close, length) : ta.highest(length)) - atr

longStopPrev = nz(longStop[1], longStop)
longStop := close[1] > longStopPrev ? math.max(longStop, longStopPrev) : longStop

shortStop = (useClose ? ta.lowest(close, length) : ta.lowest(length)) + atr

shortStopPrev = nz(shortStop[1], shortStop)
shortStop := close[1] < shortStopPrev ? math.min(shortStop, shortStopPrev) :
shortStop

var int dir = 1

dir := close > shortStopPrev ? 1 : close < longStopPrev ? -1 : dir

var color longColor = color.green

var color shortColor = color.red
var color longFillColor = color.new(color.green, 90)
var color shortFillColor = color.new(color.red, 90)
var color textColor = color.new(color.white, 0)

longStopPlot = plot(dir == 1 ? longStop : na, title='Long Stop',

style=plot.style_linebr, linewidth=1, color=color.new(longColor,
0),force_overlay=true)
buySignal = dir == 1 and dir[1] == -1
plotshape(buySignal ? longStop : na, title='Long Stop Start',
location=location.absolute, style=shape.circle, size=size.tiny,
color=color.new(longColor, 0),force_overlay=true)
plotshape(buySignal and showLabels ? longStop : na, title='Buy Label', text='Buy',
location=location.absolute, style=shape.labelup, size=size.tiny,
color=color.new(longColor, 0), textcolor=textColor,force_overlay=true)

shortStopPlot = plot(dir == 1 ? na : shortStop, title='Short Stop',

style=plot.style_linebr, linewidth=1, color=color.new(shortColor,
0),force_overlay=true)
sellSignal = dir == -1 and dir[1] == 1
plotshape(sellSignal ? shortStop : na, title='Short Stop Start',
location=location.absolute, style=shape.circle, size=size.tiny,
color=color.new(shortColor, 0),force_overlay=true)
plotshape(sellSignal and showLabels ? shortStop : na, title='Sell Label',
text='Sell', location=location.absolute, style=shape.labeldown, size=size.tiny,
color=color.new(shortColor, 0), textcolor=textColor,force_overlay=true)

midPricePlot = plot(ohlc4, title='', style=plot.style_circles, linewidth=1,

display=display.none, editable=false,force_overlay=true)

longStateFillColor = highlightState ? dir == 1 ? longFillColor : na : na

shortStateFillColor = highlightState ? dir == -1 ? shortFillColor : na : na
fill(midPricePlot, longStopPlot, title='Long State Filling',
color=longStateFillColor)
fill(midPricePlot, shortStopPlot, title='Short State Filling',
color=shortStateFillColor)

await = awaitBarConfirmation ? barstate.isconfirmed : true

alertcondition(dir != dir[1] and await, title='Alert: CE Direction Change',
message='Chandelier Exit has changed direction!')
alertcondition(buySignal and await, title='Alert: CE Buy', message='Chandelier Exit
Buy!')
alertcondition(sellSignal and await, title='Alert: CE Sell', message='Chandelier
Exit Sell!')

///////////////////////////////////////////////////////////////////////////////////
/////

//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
lengtht = input.int(14, 'Swing Detection Lookback')
multt = input.float(1., 'Slope', minval = 0, step = .1)
calcMethod = input.string('Atr', 'Slope Calculation Method', options =
['Atr','Stdev','Linreg'])
backpaint = input(true, tooltip = 'Backpainting offset displayed elements in the
past. Disable backpainting to see real time information returned by the
indicator.')

//Style
upCss = input.color(color.teal, 'Up Trendline Color', group = 'Style')
dnCss = input.color(color.red, 'Down Trendline Color', group = 'Style')
showExt = input(true, 'Show Extended Lines')

//-----------------------------------------------------------------------------}
//Calculations
//-----------------------------------------------------------------------------{
var upper = 0.
var lower = 0.
var slope_ph = 0.
var slope_pl = 0.

var offset = backpaint ? lengtht : 0

n = bar_index
src = close

ph = ta.pivothigh(lengtht, lengtht)
pl = ta.pivotlow(lengtht, lengtht)

//Slope Calculation Method

slope = switch calcMethod
'Atr' => ta.atr(lengtht) / lengtht * multt
'Stdev' => ta.stdev(src,lengtht) / lengtht * multt
'Linreg' => math.abs(ta.sma(src * n, lengtht) - ta.sma(src, lengtht) *
ta.sma(n, lengtht)) / ta.variance(n, lengtht) / 2 * multt

//Get slopes and calculate trendlines

slope_ph := ph ? slope : slope_ph
slope_pl := pl ? slope : slope_pl

upper := ph ? ph : upper - slope_ph

lower := pl ? pl : lower + slope_pl

var upos = 0
var dnos = 0
upos := ph ? 0 : close > upper - slope_ph * length ? 1 : upos
dnos := pl ? 0 : close < lower + slope_pl * length ? 1 : dnos

//-----------------------------------------------------------------------------}
//Extended Lines
//-----------------------------------------------------------------------------{
var uptl = line.new(na,na,na,na, color = upCss, style = line.style_dashed, extend
= extend.right,force_overlay=true)
var dntl = line.new(na,na,na,na, color = dnCss, style = line.style_dashed, extend
= extend.right,force_overlay=true)

if ph and showExt
uptl.set_xy1(n-offset, backpaint ? ph : upper - slope_ph * lengtht)
 uptl.set_xy2(n-offset+1, backpaint ? ph - slope : upper - slope_ph *
(lengtht+1))

if pl and showExt
dntl.set_xy1(n-offset, backpaint ? pl : lower + slope_pl * lengtht)
dntl.set_xy2(n-offset+1, backpaint ? pl + slope : lower + slope_pl *
(lengtht+1))

//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
plot(backpaint ? upper : upper - slope_ph * lengtht, 'Upper', color = ph ? na :
upCss, offset = -offset,force_overlay=true)
plot(backpaint ? lower : lower + slope_pl * lengtht, 'Lower', color = pl ? na :
dnCss, offset = -offset,force_overlay=true)

//Breakouts
plotshape(upos > upos[1] ? low : na, "Upper Break"
, shape.labelup
, location.absolute
, upCss
, text = "B"
, textcolor = color.white
, size = size.tiny,force_overlay=true)

plotshape(dnos > dnos[1] ? high : na, "Lower Break"

, shape.labeldown
, location.absolute
, dnCss
, text = "B"
, textcolor = color.white
, size = size.tiny,force_overlay=true)

//-----------------------------------------------------------------------------}
//Alerts
//-----------------------------------------------------------------------------{
alertcondition(upos > upos[1], 'Upward Breakout', 'Price broke the down-trendline
upward')
alertcondition(dnos > dnos[1], 'Downward Breakout', 'Price broke the up-trendline
downward')

//-----------------------------------------------------------------------------}
///////////////////////////////////////////////////////////////////////////////////
///////////////////

showRevBands = input.bool(true, "Show Reversal Bands", group="REVERSAL BANDS")

lenRevBands = input.int(30, "Length", group="REVERSAL BANDS")

// Functions
f_kc(src, len, sensitivity) =>
basis = ta.sma(src, len)
span = ta.atr(len)
[basis + span * sensitivity, basis - span * sensitivity]

[upperKC1, lowerKC1] = f_kc(close, lenRevBands, 3)

[upperKC2, lowerKC2] = f_kc(close, lenRevBands, 4)
[upperKC3, lowerKC3] = f_kc(close, lenRevBands, 5)
[upperKC4, lowerKC4] = f_kc(close, lenRevBands, 6)
cyan = #3179f5, cyan30 = color.new(cyan, 70)
pink = #f23645, pink30 =color.new(pink, 70)
red = #f23645, red30 = color.new(red , 70)
zoneupper1=plot(showRevBands ? upperKC1 : na, "Rev.Zone Upper 1",
red30,force_overlay=true)
zoneupper2=plot(showRevBands ? upperKC2 : na, "Rev.Zone Upper 2",
red30,force_overlay=true)
zonelower2=plot(showRevBands ? lowerKC2 : na, "Rev.Zone Lower 2",
cyan30,force_overlay=true)
zonelower1=plot(showRevBands ? lowerKC1 : na, "Rev.Zone Lower 1",
cyan30,force_overlay=true)
fill(zoneupper1, zoneupper2, color = red30)
fill(zonelower1, zonelower2, color = cyan30)

///////////////////////////////////////////////////////////////////////////////////
/////

// This work is licensed under Creative Commons Attribution-NonCommercial-

ShareAlike 4.0 International
// © BigBeluga

//@version=5
//indicator("Premium & Discount Delta Volume [BigBeluga]", overlay = true,
max_lines_count = 2, max_boxes_count = 3)

// INPUTS
-----------------------------------------------------------------------------------
---------------------------
// @variable: Toggle to show Support and Resistance levels
bool showSR = input.bool(true, "", inline = "0")
// @variable: Lookback period for calculating Support and Resistance
int srPeriod = input.int(50, "Premium & Discount Lookback Period", minval = 10,
step = 10, inline = "0",
tooltip = "Lookback period for Premium & Discount Levels
with Delta Volume")
// @variable: Toggle to show macro High and Low levels
bool showMacro = input.bool(true, "", inline = "1")
// @variable: Lookback period for calculating macro Highs and Lows
int macroPeriod = input.int(200, "Macro Lookback Period", minval = 10, step = 10,
inline = "1",
tooltip = "Lookback period for Macro Highs/Lows and
Delta Volume")
// Color variables for trends
color upColor = input.color(#79c1f1, "Discount", inline = "col", group =
"Color")
color downColor = input.color(#f19579, "Premium", inline = "col", group =
"Color")

// ARRAYS FOR STORING DATA

-----------------------------------------------------------------------------------
----------
// Arrays to store high/low data for S/R levels
var float[] srHighs = array.new_float(srPeriod, 0.)
var float[] srLows = array.new_float(srPeriod, 0.)
// Arrays to store high/low data for Macro levels
var float[] macroHighs = array.new_float(macroPeriod, 0.)
var float[] macroLows = array.new_float(macroPeriod, 0.)
// Arrays to store delta volume data
var float[] posVolSR = array.new_float(srPeriod, 0.)
var float[] negVolSR = array.new_float(srPeriod, 0.)
var float[] posVolMacro = array.new_float(macroPeriod, 0.)
var float[] negVolMacro = array.new_float(macroPeriod, 0.)

// VARIABLES FOR DELTA VOLUME CALCULATIONS

-----------------------------------------------------------------------------
// Variables to store delta volume percentages for S/R and Macro periods
var float deltaVolSR = na
var float deltaVolMacro = na

// VARIABLES FOR BOX DRAWING

-----------------------------------------------------------------------------------
---------
// Variables for box indices for both S/R and Macro periods
int srStartIdx = bar_index - srPeriod
int srEndIdx = bar_index + 50
int macroStartIdx = bar_index - macroPeriod
int macroEndIdx = bar_index + 70

// Variables for box drawing

var box srUpperBox = na
var box srLowerBox = na
var box macroUpperBox = na
var box macroLowerBox = na
var box midBox = na

// ATR for box scaling

float atrValue = ta.atr(200)*0.8

// VOLUME DELTA CALCULATIONS

-----------------------------------------------------------------------------------
--------
// @description: Calculate the delta volume for Macro period
if barstate.islast and showMacro
for int i = 0 to macroPeriod - 1
array.push(macroHighs, high[i])
array.push(macroLows, low[i])
// Store positive and negative volume based on candle direction
if close[i] > open[i]
posVolMacro.set(i, volume[i])
if close[i] < open[i]
negVolMacro.set(i, -volume[i])
// Calculate Macro Delta Volume
deltaVolMacro := (negVolMacro.avg() / posVolMacro.avg() + 1) * 100
deltaVolMacro := math.min(math.max(deltaVolMacro, -100), 100) // Cap delta
volume between -100 and 100

// Calculate the delta volume for S/R period

if barstate.islast and showSR
for int i = 0 to srPeriod - 1
array.push(srHighs, high[i])
array.push(srLows, low[i])
// Store positive and negative volume based on candle direction
if close[i] > open[i]
posVolSR.set(i, volume[i])
if close[i] < open[i]
negVolSR.set(i, -volume[i])
// Calculate S/R Delta Volume
deltaVolSR := (negVolSR.avg() / posVolSR.avg() + 1) * 100
 deltaVolSR := math.min(math.max(deltaVolSR, -100), 100) // Cap delta volume
between -100 and 100

// BOX HANDLING AND UPDATING

-----------------------------------------------------------------------------------
--------
// Update and manage boxes based on crossover conditions
if ta.crossover(low, srUpperBox.get_top()) or ta.crossunder(high,
srLowerBox.get_bottom()) or bar_index % 100 == 0
// Set new bounds for S/R and Macro boxes
srUpperBox.set_top(srHighs.max() + atrValue)
srUpperBox.set_bottom(srHighs.min())
srLowerBox.set_top(srLows.min())
srLowerBox.set_bottom(srLows.min() - atrValue)

macroUpperBox.set_top(macroHighs.max() + atrValue)
macroUpperBox.set_bottom(macroHighs.min())
macroLowerBox.set_top(macroLows.min())
macroLowerBox.set_bottom(macroLows.min() - atrValue)

// Delete previous boxes

box.delete(srUpperBox[1])
box.delete(srLowerBox[1])
box.delete(macroUpperBox[1])
box.delete(macroLowerBox[1])

// DRAW AND UPDATE BOXES

-----------------------------------------------------------------------------------
-------------
// Draw and update lower box if not initialized for S/R period
if na(srLowerBox) and barstate.islast and showSR
srLowerBox := box.new(srStartIdx, srLows.min(), srEndIdx, srLows.min() -
atrValue,
upColor, 1,
bgcolor = color.new(upColor, 100),
text = "DISCOUNT: " + str.tostring(posVolSR.sum(),
format.volume),
text_size = size.small,
text_color= chart.fg_color, force_overlay =
true,force_overlay=true)
else
srLowerBox.set_text("DISCOUNT: " + str.tostring(posVolSR.sum(), format.volume))
box.set_left(srLowerBox, srStartIdx)
box.set_right(srLowerBox, srEndIdx)
array.clear(srLows)

// Draw and update upper box if not initialized for S/R period
if na(srUpperBox) and barstate.islast and showSR
srUpperBox := box.new(srStartIdx, srHighs.max() + atrValue, srEndIdx,
srHighs.max(),
downColor, 1,
bgcolor = color.new(downColor, 100),
text = "PREMIUM: " + str.tostring(negVolSR.sum(),
format.volume),
text_size = size.small,
text_color= chart.fg_color, force_overlay =
true,force_overlay=true)
else
srUpperBox.set_text("PREMIUM: " + str.tostring(negVolSR.sum(), format.volume))
 box.set_left(srUpperBox, srStartIdx)
box.set_right(srUpperBox, srEndIdx)
array.clear(srHighs)

// DRAW BOXES FOR MACRO PERIOD

-----------------------------------------------------------------------------------
-------
// Draw and update upper box for Macro period
if na(macroUpperBox) and barstate.islast and showMacro
macroUpperBox := box.new(
macroStartIdx, macroHighs.max() + atrValue,
macroEndIdx, macroHighs.max(),
downColor, 0,
bgcolor = color.new(downColor, 60),
text = str.tostring(negVolMacro.sum(),
format.volume),
text_size = size.small,
text_color = chart.fg_color,
text_halign= showSR ? text.align_right :
text.align_center,force_overlay=true
)
else
macroUpperBox.set_text(str.tostring(negVolMacro.sum(), format.volume))
box.set_left(macroUpperBox, macroStartIdx)
box.set_right(macroUpperBox, macroEndIdx)
array.clear(macroHighs)

// Draw and update lower box for Macro period

if na(macroLowerBox) and barstate.islast and showMacro
macroLowerBox := box.new(
macroStartIdx, macroLows.min(), macroEndIdx,
macroLows.min() - atrValue,
upColor, 0,
bgcolor = color.new(upColor, 60),
text = str.tostring(posVolMacro.sum(),
format.volume),
text_size = size.small,
text_color = chart.fg_color,
text_halign= showSR ? text.align_right :
text.align_center,force_overlay=true
)
else
macroLowerBox.set_text(str.tostring(posVolMacro.sum(), format.volume))
box.set_left(macroLowerBox, macroStartIdx)
box.set_right(macroLowerBox, macroEndIdx)
array.clear(macroLows)

// ADDITIONAL PLOTTING
-----------------------------------------------------------------------------------
---------------
// Draw line for equilibrium and box for delta volume display
if barstate.islast and showSR
float mid = math.avg(srLowerBox.get_top(), srUpperBox.get_bottom())
line.delete(line.new(srStartIdx, mid, srEndIdx, mid, color=chart.fg_color,
style=line.style_dashed,force_overlay=true)[1])

midBox := box.new(srStartIdx, srUpperBox.get_bottom(), srEndIdx,

srLowerBox.get_top(),
na, 0,
 bgcolor = color.new(deltaVolSR > 0 ? upColor :
downColor, 93),
text = "Delta Volume\n" + str.tostring(deltaVolSR,
format.percent),
text_size = size.normal, text_color=deltaVolSR > 0 ?
upColor : downColor,
text_halign = text.align_right,
text_valign=text.align_bottom,force_overlay=true)

box.delete(midBox[1])

// If only macro levels are shown, handle box and line drawing
if not showSR and showMacro and barstate.islast
float midMacro = math.avg(macroLowerBox.get_top(), macroUpperBox.get_bottom())
line.delete(line.new(macroStartIdx, midMacro, macroEndIdx, midMacro,
color=chart.fg_color,
style=line.style_dashed,force_overlay=true)[1])

// Display Macro Delta Volume as a table

if showMacro and barstate.islast
var table deltaTable = table.new(position.top_right, 5, 5,force_overlay=true)
table.cell(deltaTable, 0, 0,
text = "Macro\n Delta Volume:\n" +
str.tostring(deltaVolMacro, format.percent),
text_color = deltaVolMacro > 0 ? upColor : downColor,
text_size = size.large)

///////////////////////////////////////////////////////////////////////////////////
/////////////////////////

// Input parameters

candle_stability_index_param = input.float(0.5, 'Candle Stability Index', 0, 1,

step=0.1, group='Technical', tooltip='Candle Stability Index measures the ratio
between the body and the wicks of a candle. Higher - more stable.')

rsi_index_param = input.int(50, 'RSI Index', 0, 100, group='Technical',

tooltip='RSI Index measures how overbought/oversold is the market. Higher - more
overbought/oversold.')

candle_delta_length_param = input.int(5, 'Candle Delta Length', 3,

group='Technical', tooltip='Candle Delta Length measures the period over how many
candles the price increased/decreased. Higher - longer period.')

disable_repeating_signals_param = input.bool(true, 'Disable Repeating Signals',

group='Technical', tooltip='Removes repeating signals. Useful for removing clusters
of signals and general clarity')

// ATR parameters

atr_length = input.int(14, 'ATR Length', group='Risk Management', tooltip='ATR

Length determines the number of periods for calculating ATR.')

atr_multiplier_tp = input.float(1.5, 'ATR Take-Profit Multiplier', 0.1, 10,

step=0.1, group='Risk Management')
atr_multiplier_sl = input.float(1.0, 'ATR Stop-Loss Multiplier', 0.1, 10, step=0.1,
group='Risk Management')

// Trailing Stop parameters

use_trailing_stop = input.bool(true, 'Enable Trailing Stop-Loss', group='Risk

Management', tooltip='Enable trailing stop-loss to lock in profits.')

trailing_stop_multiplier = input.float(1.0, 'Trailing Stop ATR Multiplier', 0.1,

10, step=0.1, group='Risk Management')

// Colors and styles

GREEN = color.rgb(29, 255, 40)

RED = color.rgb(255, 0, 0)

TRANSPARENT = color.rgb(0, 0, 0, 100)

label_size = input.string('normal', 'Label Size', options=['huge', 'large',

'normal', 'small', 'tiny'], group='Cosmetic')

label_style = input.string('text bubble', 'Label Style', ['text bubble',

'triangle', 'arrow'], group='Cosmetic')

buy_label_color = input(GREEN, 'BUY Label Color', inline='Highlight',

group='Cosmetic')

sell_label_color = input(RED, 'SELL Label Color', inline='Highlight',

group='Cosmetic')

label_text_color = input(color.white, 'Label Text Color', inline='Highlight',

group='Cosmetic')

// Calculations

atr_value = ta.atr(atr_length)

// Technical signals

stable_candle = math.abs(close - open) / ta.tr > candle_stability_index_param

rsig = ta.rsi(close, 14)

bullish_engulfing = close[1] < open[1] and close > open and close > open[1]
rsi_below = rsig < rsi_index_param

decrease_over = close < close[candle_delta_length_param]

bull = bullish_engulfing and stable_candle and rsi_below and decrease_over and

barstate.isconfirmed

bearish_engulfing = close[1] > open[1] and close < open and close < open[1]

rsi_above = rsig > 100 - rsi_index_param

increase_over = close > close[candle_delta_length_param]

bear = bearish_engulfing and stable_candle and rsi_above and increase_over and

barstate.isconfirmed

// Track last signal

var string last_signal = na

if bull and (disable_repeating_signals_param ? (last_signal != 'buy') : true)

// Calculate BUY take-profit and stop-loss

take_profit_buy = close + (atr_value * atr_multiplier_tp)

stop_loss_buy = close - (atr_value * atr_multiplier_sl)

// Plot BUY label with TP and SL

if label_style == 'text bubble'

label.new(bar_index, low, 'BUY\nTP: ' + str.tostring(take_profit_buy,

"#.##") + '\nSL: ' + str.tostring(stop_loss_buy, "#.##"), color=buy_label_color,
style=label.style_label_up, textcolor=label_text_color,
size=label_size,force_overlay=true)

else if label_style == 'triangle'

label.new(bar_index, low, 'BUY\nTP: ' + str.tostring(take_profit_buy,

"#.##") + '\nSL: ' + str.tostring(stop_loss_buy, "#.##"), yloc=yloc.belowbar,
color=buy_label_color, style=label.style_triangleup, textcolor=TRANSPARENT,
size=label_size,force_overlay=true)

else if label_style == 'arrow'

label.new(bar_index, low, 'BUY\nTP: ' + str.tostring(take_profit_buy,

"#.##") + '\nSL: ' + str.tostring(stop_loss_buy, "#.##"), yloc=yloc.belowbar,
color=buy_label_color, style=label.style_arrowup, textcolor=TRANSPARENT,
size=label_size,force_overlay=true)

last_signal := 'buy'

if bear and (disable_repeating_signals_param ? (last_signal != 'sell') : true)

// Calculate SELL take-profit and stop-loss

take_profit_sell = close - (atr_value * atr_multiplier_tp)

stop_loss_sell = close + (atr_value * atr_multiplier_sl)

// Plot SELL label with TP and SL

if label_style == 'text bubble'

label.new(bar_index, high, 'SELL\nTP: ' + str.tostring(take_profit_sell,

"#.##") + '\nSL: ' + str.tostring(stop_loss_sell, "#.##"), color=sell_label_color,
style=label.style_label_down, textcolor=label_text_color,
size=label_size,force_overlay=true)

else if label_style == 'triangle'

label.new(bar_index, high, 'SELL\nTP: ' + str.tostring(take_profit_sell,

"#.##") + '\nSL: ' + str.tostring(stop_loss_sell, "#.##"), yloc=yloc.abovebar,
color=sell_label_color, style=label.style_triangledown, textcolor=TRANSPARENT,
size=label_size,force_overlay=true)

else if label_style == 'arrow'

label.new(bar_index, high, 'SELL\nTP: ' + str.tostring(take_profit_sell,

"#.##") + '\nSL: ' + str.tostring(stop_loss_sell, "#.##"), yloc=yloc.abovebar,
color=sell_label_color, style=label.style_arrowdown, textcolor=TRANSPARENT,
size=label_size,force_overlay=true)

last_signal := 'sell'

// Alerts

alertcondition(bull, 'BUY Signals', 'New signal: BUY')

alertcondition(bear, 'SELL Signals', 'New signal: SELL')

// Trailing Stop-Loss Logic

var float trailing_stop = na

if use_trailing_stop

if last_signal == 'buy' and close > trailing_stop[1] + (atr_value *

trailing_stop_multiplier)

trailing_stop := close - (atr_value * trailing_stop_multiplier)

if last_signal == 'sell' and close < trailing_stop[1] - (atr_value *

trailing_stop_multiplier)

trailing_stop := close + (atr_value * trailing_stop_multiplier)