// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

//@version=5
strategy("Breaks and Retests Strategy [AD]", overlay = true, default_qty_type = strategy.percent_of_equity, default_qty_value = 10, calc_on_every_tick = true)

g_sr = 'Support and Resistance'
p_kn = 'Advanced Settings'
b_ox = 'Box Settings'
g_c  = 'Conditions'
g_st = 'Styling'
t_r  = 'Bar Confirmation: Generates alerts when candle closes. (1 Candle Later) \n\nHigh & Low: By default, the Break & Retest system uses the current close value to determine a condition, selecting High & Low will make the script utilize these two values instead of the close value. In return, the script won\'t repaint and will yield different results.'
t_rv = 'Whenever a potential retest is detected, the indicator knows that a retest is about to happen. In that given situation, this input grants the ability to raise the limit on how many bars are allowed to be actively checked while a potential retest event is active.\n\nExample, if you see the potential retest label, how many bars do you want that potential retest label to be active for to eventually confirm a retest? This system was implemented to prevent retest alerts from going off 10+ bars later from the potential retest point leading to inaccurate results.'

input_pineconnector = input.int(defval = 8012783452373, title = 'PineConnector License', tooltip = 'PineConnector License Number', group = p_kn)
input_pineconnector_lot_size = input.float(defval = 0.1, title = 'Lot Size', minval = 0.01, tooltip = 'Lot Size to send to Pineconnnector', group = p_kn)
input_pineconnector_tp = input.int(defval = 1500, title='Take Profit', minval = 1, tooltip = 'Take Profit to set in the Trade', group = p_kn)
input_pineconnector_sl = input.int(defval = 800, title = 'Stop Loss', tooltip = 'Stop Loss to set in the trade', group=p_kn)
input_trailing_trigger = input.int(defval = 1000, title = 'Trailing Trigger Ticks', minval=1, tooltip = 'Ticks after Trailing SL will trigger', group = p_kn)
input_trailing_trigger_distance = input.int(defval = 100, title = 'Trailing Trigger Distance Ticks', minval=1, tooltip = 'Stop Loss Ticks from current Price after Trailing SL trigger', group = p_kn)
input_trailing_trigger_step = input.int(defval = 5, title = 'Trailing Trigger Steps Ticks', minval=1, tooltip = 'Steps Ticks from current after which SL will be updated after trailing SL trigger', group = p_kn)
input_disable_delete_box = input.bool(defval = true, title = 'Disable Deleting Boxes', tooltip = 'Enabling this will prevent indicator to delete the boxes in history', group = p_kn)
input_disable_alerts = input.bool(defval = true, title = 'Disable Useless alerts', tooltip = 'Disble Non-PineConnector Alerts', group = p_kn)
input_box_line_distance = input.int(defval = 10, title = 'Line Distance', minval = 1 , tooltip = 'How far line should appear on the chart', group = b_ox)
input_box_line_width = input.int(defval = 2, title = 'Line Width & Color', minval = 1 , tooltip = 'Line Width', group = b_ox, inline = "line")
input_box_line_color = input.color(defval = color.lime, title = '', tooltip = 'Main Line Settings', group = b_ox, inline = 'line')
input_box_tp_line_width = input.int(defval = 2, title = 'TP Line Width & Color', minval = 1 , tooltip = 'Line Width', group = b_ox, inline = "TPline")
input_box_tp_line_color = input.color(defval = color.lime, title = '', tooltip = 'TP Line Settings', group = b_ox, inline = 'TPline')
input_box_sl_line_width = input.int(defval = 2, title = 'SL Line Width & Color', minval = 1 , tooltip = 'Line Width', group = b_ox, inline = "SLline")
input_box_sl_line_color = input.color(defval = color.red, title = '', tooltip = 'SL Line Settings', group = b_ox, inline = 'SLline')
input_label_color = input.color(defval = color.white, title = 'Label Color', tooltip = 'Label Text Settings', group = b_ox)
input_label_tp_back = input.color(defval = color.lime, title = 'TP Label Background', tooltip = 'TP Label Settings', group = b_ox)
input_label_entry_back = input.color(defval = color.blue, title = 'Entry Label Background', tooltip = 'Entry Label Settings', group = b_ox)
input_label_sl_back = input.color(defval = color.red, title = 'SL Label Background', tooltip = 'SL Label Settings', group = b_ox)

input_lookback  = input.int(defval = 20, title = 'Lookback Range', minval = 1, tooltip = 'How many bars for a pivot event to occur.', group = g_sr)
input_retSince  = input.int(defval = 2, title = 'Bars Since Breakout', minval = 1, tooltip = 'How many bars since breakout in order to detect a retest.', group = g_sr)
input_retValid  = input.int(defval = 2, title = 'Retest Detection Limiter', minval = 1, tooltip = t_rv, group = g_sr)
input_breakout  = input.bool(defval = true, title = 'Breakouts', group = g_c)
input_retest    = input.bool(defval = true, title = 'Retests', group = g_c)
input_repType   = input.string(defval = 'On', title = 'Repainting', options = ['On', 'Off: Candle Confirmation', 'Off: High & Low'], tooltip = t_r, group = g_c)
input_outL      = input.string(defval = line.style_dotted, title = 'Outline', group = g_st, options = [line.style_dotted, line.style_dashed, line.style_solid])
input_extend    = input.string(defval = extend.none, title = 'Extend', group = g_st, options = [extend.none, extend.right, extend.left, extend.both])
input_labelType = input.string(defval = 'Full', title = 'Label Type', options = ['Full', 'Simple'], group = g_st)
input_labelSize = input.string(defval = size.small, title = 'Label Size', options = [size.tiny, size.small, size.normal, size.large, size.huge], group = g_st)
input_plColor   = input.color(defval = color.red, title = 'Support', inline = 'Color', group = g_st)
input_phColor   = input.color(defval = #089981, title = 'Resistance', inline = 'Color', group = g_st)
input_override  = input.bool(defval = false, title = 'Override Text Color ', inline = 'Override', group = g_st)
input_textColor = input.color(defval = color.white, title = '', inline = 'Override', group = g_st)
bb              = input_lookback

rTon            = input_repType == 'On'
rTcc            = input_repType == 'Off: Candle Confirmation'
rThv            = input_repType == 'Off: High & Low'
breakText       = input_labelType == 'Simple' ? 'Br' : 'Break'

// Pivot Instance
pl = fixnan(ta.pivotlow(low, bb, bb))
ph = fixnan(ta.pivothigh(high, bb, bb))

// Box Height
s_yLoc = low[bb + 1] > low[bb - 1] ? low[bb - 1] : low[bb + 1]
r_yLoc = high[bb + 1] > high[bb - 1] ? high[bb + 1] : high[bb - 1]

//-----------------------------------------------------------------------------
// Functions
//-----------------------------------------------------------------------------
drawBox(condition, y1, y2, color) =>
    var box drawBox = na
    if condition
        box.set_right(drawBox, bar_index - bb)
        drawBox.set_extend(extend.none)
        drawBox := box.new(bar_index - bb, y1, bar_index, y2, color, bgcolor = color.new(color, 90), border_style = input_outL, extend = input_extend)
    [drawBox]

updateBox(box) =>
    if barstate.isconfirmed
        box.set_right(box, bar_index + 5)

breakLabel(y, color, style, textform) => label.new(bar_index, y, textform, textcolor = input_override ? input_textColor : color, style = style, color = color.new(color, 50), size = input_labelSize)
retestCondition(breakout, condition) => ta.barssince(na(breakout)) > input_retSince and condition
repaint(c1, c2, c3) => rTon ? c1 : rThv ? c2 : rTcc ? c3 : na

//-----------------------------------------------------------------------------
// Draw and Update Boxes
//-----------------------------------------------------------------------------
[sBox] = drawBox(ta.change(pl), s_yLoc, pl, input_plColor)
[rBox] = drawBox(ta.change(ph), ph, r_yLoc, input_phColor)
sTop = box.get_top(sBox), rTop = box.get_top(rBox)
sBot = box.get_bottom(sBox), rBot = box.get_bottom(rBox)

updateBox(sBox), updateBox(rBox)

//-----------------------------------------------------------------------------
// Breakout Event
//-----------------------------------------------------------------------------
var bool sBreak = na
var bool rBreak = na
cu = repaint(ta.crossunder(close, box.get_bottom(sBox)), ta.crossunder(low, box.get_bottom(sBox)), ta.crossunder(close, box.get_bottom(sBox)) and barstate.isconfirmed)
co = repaint(ta.crossover(close, box.get_top(rBox)), ta.crossover(high, box.get_top(rBox)), ta.crossover(close, box.get_top(rBox)) and barstate.isconfirmed)

switch
    cu and na(sBreak) =>
        sBreak := true
        if input_breakout
            breakLabel(sBot, input_plColor, label.style_label_upper_right, breakText)
    co and na(rBreak) =>
        rBreak := true
        if input_breakout
            breakLabel(rTop, input_phColor, label.style_label_lower_right, breakText)

if not input_disable_delete_box
    if ta.change(pl)
        if na(sBreak)
            box.delete(sBox[1])
        sBreak := na
    if ta.change(ph)
        if na(rBreak)
            box.delete(rBox[1])
        rBreak := na

//-----------------------------------------------------------------------------
// Retest Event
//-----------------------------------------------------------------------------
s1 = retestCondition(sBreak, high >= sTop and close <= sBot)                                            // High is GOET top sBox value and the close price is LOET the bottom sBox value.
s2 = retestCondition(sBreak, high >= sTop and close >= sBot and close <= sTop)                          // High is GOET top sBox value and close is GOET the bottom sBox value and closing price is LOET the top sBox value.
s3 = retestCondition(sBreak, high >= sBot and high <= sTop)                                             // High is in between the sBox.
s4 = retestCondition(sBreak, high >= sBot and high <= sTop and close < sBot)                            // High is in between the sBox, and the closing price is below.

r1 = retestCondition(rBreak, low <= rBot and close >= rTop)                                             // Low is LOET bottom rBox value and close is GOET the top sBox value
r2 = retestCondition(rBreak, low <= rBot and close <= rTop and close >= rBot)                           // Low is LOET bottom rBox value and close is LOET the top sBox value and closing price is GOET the bottom rBox value.
r3 = retestCondition(rBreak, low <= rTop and low >= rBot)                                               // Low is in between the rBox.
r4 = retestCondition(rBreak, low <= rTop and low >= rBot and close > rTop)                              // Low is in between the rBox, and the closing price is above.

retestEvent(c1, c2, c3, c4, y1, y2, col, style, pType) =>
    if input_retest
        var bool retOccurred = na
        retActive   = c1 or c2 or c3 or c4
        retEvent    = retActive and not retActive[1]
        retValue    = ta.valuewhen(retEvent, y1, 0) 

        if pType == 'ph' ? y2 < ta.valuewhen(retEvent, y2, 0) : y2 > ta.valuewhen(retEvent, y2, 0)
            retEvent := retActive

        // Must be reassigned here just in case the above if statement triggers.
        retValue := ta.valuewhen(retEvent, y1, 0) 

        retSince = ta.barssince(retEvent)
        var retLabel = array.new<label>()

        if retEvent
            retOccurred := na
            array.push(retLabel, label.new(bar_index - retSince, y2[retSince], text = input_labelType == 'Simple' ? 'P. Re' : 'Potential Retest', color = color.new(col, 50), style = style, textcolor = input_override ? input_textColor : col, size = input_labelSize))

        if array.size(retLabel) == 2
            label.delete(array.first(retLabel))
            array.shift(retLabel)

        retConditions = pType == 'ph' ? repaint(close >= retValue, high >= retValue, close >= retValue and barstate.isconfirmed) : repaint(close <= retValue, low <= retValue, close <= retValue and barstate.isconfirmed)
        retValid = ta.barssince(retEvent) > 0 and ta.barssince(retEvent) <= input_retValid and retConditions and not retOccurred

        if retValid
            label.new(bar_index - retSince, y2[retSince], text = input_labelType == 'Simple' ? 'Re' : 'Retest', color = color.new(col, 50), style = style, textcolor = input_override ? input_textColor : col, size = input_labelSize)
            retOccurred := true

        if retValid or ta.barssince(retEvent) > input_retValid
            label.delete(array.first(retLabel))

        if pType == 'ph' and ta.change(ph) and retOccurred
            box.set_right(rBox[1], bar_index - retSince)
            retOccurred := na

        if pType == 'pl' and ta.change(pl) and retOccurred
            box.set_right(sBox[1], bar_index - retSince)
            retOccurred := na
        [retValid, retEvent, retValue]

[rRetValid, rRetEvent] = retestEvent(r1, r2, r3, r4, high, low, input_phColor, label.style_label_upper_left, 'ph')
[sRetValid, sRetEvent] = retestEvent(s1, s2, s3, s4, low, high, input_plColor, label.style_label_lower_left, 'pl')


//-----------------------------------------------------------------------------
// Alerts
//-----------------------------------------------------------------------------
alertcondition(ta.change(pl), 'New Support Level')
alertcondition(ta.change(ph), 'New Resistance Level')
alertcondition(ta.barssince(na(sBreak)) == 1, 'Support Breakout')
alertcondition(ta.barssince(na(rBreak)) == 1, 'Resistance Breakout')
alertcondition(sRetValid, 'Support Retest')
alertcondition(sRetEvent, 'Potential Support Retest')
alertcondition(rRetValid, 'Resistance Retest')
alertcondition(rRetEvent, 'Potential Resistance Retest')

AllAlerts(condition, message) =>
    if condition
        alert(message)

if not input_disable_alerts
    AllAlerts(ta.change(pl), 'New Support Level')
    AllAlerts(ta.change(ph), 'New Resistance Level')
    AllAlerts(ta.barssince(na(sBreak)) == 1, 'Support Breakout')
    AllAlerts(ta.barssince(na(rBreak)) == 1, 'Resistance Breakout')
    AllAlerts(sRetValid, 'Support Retest')
    AllAlerts(sRetEvent, 'Potential Support Retest')
    AllAlerts(rRetValid, 'Resistance Retest')
    AllAlerts(rRetEvent, 'Potential Resistance Retest')


buyMessage = str.tostring(input_pineconnector) + ",buy," + syminfo.ticker + ",risk=" + str.tostring(input_pineconnector_lot_size) + ',tp=' + str.tostring(input_pineconnector_tp) + ',sl=' + str.tostring(input_pineconnector_sl) + ',trailtrig=' + str.tostring(input_trailing_trigger) + ',traildist=' + str.tostring(input_trailing_trigger_distance) + ',trailstep=' + str.tostring(input_trailing_trigger_step)
sellMessage = str.tostring(input_pineconnector) + ",sell," + syminfo.ticker + ",risk=" + str.tostring(input_pineconnector_lot_size) + ',tp=' + str.tostring(input_pineconnector_tp) + ',sl=' + str.tostring(input_pineconnector_sl) + ',trailtrig=' + str.tostring(input_trailing_trigger) + ',traildist=' + str.tostring(input_trailing_trigger_distance) + ',trailstep=' + str.tostring(input_trailing_trigger_step)

tp = input_pineconnector_tp
sl = input_pineconnector_sl

var bool inTrade = false
var float lastBuyBoxLow = na
var float lastSellBoxHigh = na

// Buy: price comes from below and touches bottom of green resistance box (rBox)
buyTouch = not na(rBox) and low[1] < rBot and high >= rBot

// Sell: price comes from above and touches top of red support box (sBox)
sellTouch = not na(sBox) and high[1] > sTop and low <= sTop

newBuyBox = not na(sTop) and (na(lastBuyBoxLow) or sTop != lastBuyBoxLow)
newSellBox = not na(rBot) and (na(lastSellBoxHigh) or rBot != lastSellBoxHigh)

var line EntryLine = na
var line SLLine = na
var line TPLine = na

var label EntryLabel = na
var label SLLabel = na
var label TPLabel = na

DrawBox(case) =>
    // Local temp variables for return
    line newEntry = na
    line newSL = na
    line newTP = na

    // Remove previous lines if they exist
    line.delete(EntryLine)
    line.delete(SLLine)
    line.delete(TPLine)

    label.delete(EntryLabel)
    label.delete(SLLabel)
    label.delete(TPLabel)

    float entryPrice = 0
    float slPrice = 0
    float TPPrice = 0
    pipSize = syminfo.mintick

    if str.lower(case) == "short"
        entryPrice := close
        slPrice := close + input_pineconnector_sl * pipSize
        TPPrice := close - input_pineconnector_tp* pipSize
    else 
        entryPrice := close
        slPrice := close - input_pineconnector_sl* pipSize
        TPPrice := close + input_pineconnector_tp* pipSize
    
    newEntry := line.new(bar_index, entryPrice, bar_index + input_box_line_distance, entryPrice, color=input_box_line_color, width=input_box_line_width)
    newSL := line.new(bar_index, slPrice, bar_index + input_box_line_distance, slPrice, color=input_box_sl_line_color, width=input_box_sl_line_width)
    newTP := line.new(bar_index, TPPrice, bar_index + input_box_line_distance, TPPrice, color=input_box_tp_line_color, width=input_box_tp_line_width)

    [newEntry, newSL, newTP]
    

if ta.change(rBot) or ta.change(sBot)
    lastBuyBoxLow := na
    lastSellBoxHigh := na

if not inTrade and buyTouch and newBuyBox
    AllAlerts(buyTouch, buyMessage)
    strategy.entry("Buy", strategy.long)
    strategy.exit("TP/SL Buy", from_entry = "Buy", profit = tp, loss = sl)
    inTrade := true
    lastBuyBoxLow := sTop
    [entryLineTemp, slLineTemp, tpLineTemp] = DrawBox("long")
    EntryLine := entryLineTemp
    SLLine    := slLineTemp
    TPLine    := tpLineTemp
    

if not inTrade and sellTouch and newSellBox
    AllAlerts(sellTouch, sellMessage)
    strategy.entry("Sell", strategy.short)
    strategy.exit("TP/SL Sell", from_entry = "Sell", profit = tp, loss = sl)
    inTrade := true
    lastSellBoxHigh := rBot
    [entryLineTemp, slLineTemp, tpLineTemp] = DrawBox("short")
    EntryLine := entryLineTemp
    SLLine    := slLineTemp
    TPLine    := tpLineTemp
    
   
// Trailing Stop Logic
if inTrade
    if strategy.opentrades > 0
        currentPrice = strategy.opentrades.entry_price(0)
        float trailingStop = 0
        // Calculate trailing stop based on direction of the trade
        if strategy.opentrades.size(0) > 0
            // For long positions, calculate trailing stop
            if close - currentPrice >= input_trailing_trigger * syminfo.mintick
                trailingStop := close - input_trailing_trigger_distance * syminfo.mintick
            if close > trailingStop
                strategy.exit("Trailing Stop", from_entry="Buy", stop=trailingStop)
        if strategy.opentrades.size(0) < 0
            // For short positions, calculate trailing stop
            if currentPrice - close >= input_trailing_trigger * syminfo.mintick
                trailingStop := close + input_trailing_trigger_distance * syminfo.mintick
            if close < trailingStop
                strategy.exit("Trailing Stop", from_entry="Sell", stop=trailingStop)

if strategy.opentrades > 0
    inTrade := true
else
    inTrade := false

// Label Text for Entry TP and SL
if (not na(TPLine)) 
    label.new(x = line.get_x2(TPLine) + 2, y = line.get_y2(TPLine), text = "TP", style = label.style_label_left, color = input_label_tp_back, textcolor = input_label_color, size = size.small, tooltip = "Take Profit")

if (not na(EntryLine)) 
    label.new(x = line.get_x2(EntryLine) + 2, y = line.get_y2(EntryLine), text = "Entry", style = label.style_label_left, color = input_label_entry_back, textcolor = input_label_color, size = size.small, tooltip = "Entry Price")

if (not na(SLLine)) 
    label.new(x = line.get_x2(SLLine) + 2, y = line.get_y2(SLLine), text = "SL", style = label.style_label_left, color = input_label_sl_back, textcolor = input_label_color, size = size.small, tooltip = "Stop Loss")