RSI Divergence+

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

// This indicator is intended to be used on the Daily Timeframe
// By changing the overlay to false just below, the divergence lines, etc. will
// be drawn on the RSI instead of the price chart

//@version=4
study("RSI Divergence+", overlay = true)

barsback         = input(title = "Price Lookback",      type = input.integer, defval = 15, minval = 1)
lookback         = input(title = "RSI Lookback",        type = input.integer, defval = 15,  minval = 1)
shortRangeString = input(title = "Divergence Range",    type = input.string,  defval = "Short", options = ["Short", "Med", "Long"])
priceTolerance   = input(title = "Price Epsilon (%)",   type = input.float,   defval = 1.0, minval = 0.0)
rsiTolerance     = input(title = "RSI Epsilon (%)",     type = input.float,   defval = 1.0, minval = 0.0)

len1     = input(14, minval = 1, title = "RSI Length")
src1     = input(close, "RSI Source", type = input.source)
rsiOver  = 70
rsiMid   = 50
rsiUnder = 30

displayHighLows = input(title = "Display High/Low Pivots", type=input.bool, defval = false)
overlayMode     = input(title = "Overlay Price Chart", type = input.bool, defval = true)

shortRange = 1
if shortRangeString == "Med"
    shortRange := 2
else if shortRangeString == "Long"
    shortRange := 3

up   = rma(max(change(src1), 0), len1)
down = rma(-min(change(src1), 0), len1)
rsi  = ((down == 0) ? 100 : ((up == 0) ? 0 : (100 - (100 / (1 + up / down)))))

overlayModeOrange  = color.new(color.orange, transp = not overlayMode ? 0 : 100)
overlayModeBlue    = color.new(color.blue,   transp = not overlayMode ? 0 : 100)
overlayModeWhite   = color.new(color.white,  transp = not overlayMode ? 0 : 100)
overlayModeWhite90 = color.new(color.white,  transp = not overlayMode ? 90 : 100)
overlayModeWhite85 = color.new(color.white,  transp = not overlayMode ? 85 : 100)
overlayModeWhite80 = color.new(color.white,  transp = not overlayMode ? 80 : 100)

plot(rsi, "RSI", color=overlayModeOrange, linewidth=2)

band80 = hline(rsiOver + 10,  "Upper Band",  color = (not overlayMode ? color.white : na), linewidth = 1, linestyle = hline.style_dashed)
band50 = hline(rsiMid,        "Middle Band", color = (not overlayMode ? color.blue  : na), linewidth = 2, linestyle = hline.style_solid)
band20 = hline(rsiUnder - 10, "Lower Band",  color = (not overlayMode ? color.white : na), linewidth = 1, linestyle = hline.style_dashed)
band70 = hline(rsiOver,       "Upper Band",  color = (not overlayMode ? color.white : na), linewidth = 1, linestyle = hline.style_dashed)
band30 = hline(rsiUnder,      "Lower Band",  color = (not overlayMode ? color.white : na), linewidth = 1, linestyle = hline.style_dashed)
fill(band50, band70, color = overlayModeWhite90, title = "Background")
fill(band30, band50, color = overlayModeWhite90, title = "Background")
fill(band70, band80, color = overlayModeWhite85, title = "Background")
fill(band20, band30, color = overlayModeWhite85, title = "Background")

fill(band80, hline(100, color = (not overlayMode ? color.white : na), linestyle = hline.style_solid, linewidth = 2), color = overlayModeWhite80, title = "Background")
fill(hline(0, color = (not overlayMode ? color.white : na), linestyle = hline.style_solid, linewidth = 2), band20, color = overlayModeWhite80, title = "Background")

var bool priceHighSet = na
var bool priceLowSet  = na
var bool rsiHighSet   = na
var bool rsiLowSet    = na

currHigh = pivothigh(rsi, lookback, lookback)
currLow  = pivotlow(rsi,  lookback, lookback)

lastHighShort = valuewhen(not na(currHigh), currHigh, shortRange)
lastLowShort  = valuewhen(not na(currLow),  currLow,  shortRange)

lowerHighShort  = not na(currHigh) ? lastHighShort > (currHigh * (1 + (rsiTolerance / 100))) : false
higherHighShort = not na(currHigh) ? lastHighShort < (currHigh * (1 - (rsiTolerance / 100))) : false
lowerLowShort   = not na(currLow)  ? lastLowShort  > (currLow *  (1 + (rsiTolerance / 100))) : false
higherLowShort  = not na(currLow)  ? lastLowShort  < (currLow *  (1 - (rsiTolerance / 100))) : false

currPriceHigh = pivothigh(high, barsback, barsback)
currPriceLow  = pivotlow(low,   barsback, barsback)

lastPriceHighShort = valuewhen(not na(currPriceHigh), currPriceHigh, shortRange)
lastPriceLowShort  = valuewhen(not na(currPriceLow),  currPriceLow, shortRange)

lowerPriceHighShort  = not na(currPriceHigh) ? lastPriceHighShort > (currPriceHigh * (1 + (priceTolerance / 100))) : false
higherPriceHighShort = not na(currPriceHigh) ? lastPriceHighShort < (currPriceHigh * (1 - (priceTolerance / 100))) : false
lowerPriceLowShort   = not na(currPriceLow)  ? lastPriceLowShort  > (currPriceLow *  (1 + (priceTolerance / 100))) : false
higherPriceLowShort  = not na(currPriceLow)  ? lastPriceLowShort  < (currPriceLow *  (1 - (priceTolerance / 100))) : false

lowerLowRecent   = barssince(lowerLowShort)   < lookback
lowerHighRecent  = barssince(lowerHighShort)  < lookback
higherLowRecent  = barssince(higherLowShort)  < lookback
higherHighRecent = barssince(higherHighShort) < lookback
    
lowerPriceLowRecent   = barssince(lowerPriceLowShort)   < barsback
lowerPriceHighRecent  = barssince(lowerPriceHighShort)  < barsback
higherPriceLowRecent  = barssince(higherPriceLowShort)  < barsback
higherPriceHighRecent = barssince(higherPriceHighShort) < barsback

regShortBullish = lowerPriceLowRecent and higherLowRecent
hidShortBullish = higherPriceLowRecent and lowerLowRecent
regShortBearish = higherPriceHighRecent and lowerHighRecent
hidShortBearish = lowerPriceHighRecent and higherHighRecent

priceHighIndex = barssince(not na(priceHighSet))
priceLowIndex  = barssince(not na(priceLowSet))
rsiHighIndex   = barssince(not na(rsiHighSet))
rsiLowIndex    = barssince(not na(rsiLowSet))

priceHighSet := not na(currPriceHigh) ? true : na
priceLowSet  := not na(currPriceLow)  ? true : na
rsiHighSet   := not na(currHigh)      ? true : na
rsiLowSet    := not na(currLow)       ? true : na

currPriceHigh := na(currPriceHigh) ? currPriceHigh[1] : currPriceHigh
currPriceLow  := na(currPriceLow)  ? currPriceLow[1]  : currPriceLow
currHigh      := na(currHigh)      ? currHigh[1]      : currHigh
currLow       := na(currLow)       ? currLow[1]       : currLow

newIndexLow = rsiLowIndex
newIndexLow2 = bar_index - lookback
if rsiLowIndex < lookback
    for i = 0 to lookback
        if rsiLowIndex[i] == 0
            newIndexLow := rsiLowIndex[i + 1] + (i + 1)
            newIndexLow2 -= i + 1
            break
            
newIndexHigh = rsiHighIndex
newIndexHigh2 = bar_index - lookback
if rsiHighIndex < lookback
    for i = 0 to lookback
        if rsiHighIndex[i] == 0
            newIndexHigh := rsiHighIndex[i + 1] + (i + 1)
            newIndexHigh2 -= i + 1
            break
            
newIndexPriceLow = priceLowIndex
newIndexPriceLow2 = bar_index - barsback
if priceLowIndex < barsback
    for i = 0 to barsback
        if priceLowIndex[i] == 0
            newIndexPriceLow := priceLowIndex[i + 1] + (i + 1)
            newIndexPriceLow2 -= i + 1 
            break

newIndexPriceHigh = priceHighIndex
newIndexPriceHigh2 = bar_index - barsback
if priceHighIndex < barsback
    for i = 0 to barsback
        if priceHighIndex[i] == 0
            newIndexPriceHigh += priceHighIndex[i + 1] + 1
            newIndexPriceHigh2 -= i + 1
            break

max_bars_back(rsiLowIndex, 500)
max_bars_back(rsiHighIndex, 500)
max_bars_back(priceLowIndex, 500)
max_bars_back(priceHighIndex, 500)

if shortRange <= 1
    prevPivot = 0
else
    newIndexLow       += rsiLowIndex[newIndexLow + 1] + 1
    newIndexHigh      += rsiHighIndex[newIndexHigh + 1] + 1
    newIndexPriceLow  += priceLowIndex[newIndexPriceLow + 1] + 1
    newIndexPriceHigh += priceHighIndex[newIndexPriceHigh + 1] + 1
    
if shortRange == 3
    newIndexLow       += rsiLowIndex[newIndexLow + 1] + 1
    newIndexHigh      += rsiHighIndex[newIndexHigh + 1] + 1
    newIndexPriceLow  += priceLowIndex[newIndexPriceLow + 1] + 1
    newIndexPriceHigh += priceHighIndex[newIndexPriceHigh + 1] + 1

x_low            = bar_index - lookback - newIndexLow - 1
x_low_mid        = bar_index - lookback - (newIndexLow / 2)
x_high           = bar_index - lookback - newIndexHigh - 1
x_high_mid       = bar_index - lookback - (newIndexHigh / 2)
x_price_low      = bar_index - barsback - newIndexPriceLow - 1
x_price_low_mid  = bar_index - barsback - (newIndexPriceLow / 2)
x_price_high     = bar_index - barsback - newIndexPriceHigh - 1
x_price_high_mid = bar_index - barsback - (newIndexPriceHigh / 2)

if (regShortBearish and not regShortBearish[1]) or (hidShortBearish and not hidShortBearish[1])
    var line highPriceLine = na
    var line highRsiLine   = na
    if not overlayMode // RSI
        highRsiLine := line.new(0, 0, 0, 0)
        line.set_x1(highRsiLine, x_high)
        line.set_y1(highRsiLine, lastHighShort)
        line.set_x2(highRsiLine, newIndexHigh2)
        line.set_y2(highRsiLine, currHigh)
        line.set_style(highRsiLine, line.style_dotted)
        line.set_width(highRsiLine, 2)
        line.set_color(highRsiLine, color=regShortBearish ? color.red : color.yellow)
    else
        highPriceLine := line.new(0, 0, 0, 0)
        line.set_x1(highPriceLine, x_price_high)
        line.set_y1(highPriceLine, lastPriceHighShort)
        line.set_x2(highPriceLine, newIndexPriceHigh2)
        line.set_y2(highPriceLine, currPriceHigh)
        line.set_style(highPriceLine, line.style_dotted)
        line.set_width(highPriceLine, 3)
        line.set_color(highPriceLine, color=regShortBearish ? color.red : color.yellow)

if (regShortBullish and not regShortBullish[1]) or (hidShortBullish and not hidShortBullish[1])
    var line lowPriceLine = na
    var line lowRsiLine    = na
    if not overlayMode // RSI
        lowRsiLine := line.new(0, 0, 0, 0)
        line.set_x1(lowRsiLine, x_low)
        line.set_y1(lowRsiLine, lastLowShort)
        line.set_x2(lowRsiLine, newIndexLow2)
        line.set_y2(lowRsiLine, currLow)
        line.set_style(lowRsiLine, line.style_dotted)
        line.set_width(lowRsiLine, 2)
        line.set_color(lowRsiLine, color=regShortBullish ? color.green : color.blue)
    else
        lowPriceLine := line.new(0, 0, 0, 0)
        line.set_x1(lowPriceLine, x_price_low)
        line.set_y1(lowPriceLine, lastPriceLowShort)
        line.set_x2(lowPriceLine, newIndexPriceLow2)
        line.set_y2(lowPriceLine, currPriceLow)
        line.set_style(lowPriceLine, line.style_dotted)
        line.set_width(lowPriceLine, 3)
        line.set_color(lowPriceLine, color=regShortBullish ? color.green : color.blue)

if not overlayMode and displayHighLows // RSI
    if lowerHighShort
        label.new(bar_index - lookback, currHigh + 10, style=label.style_triangledown, color=color.new(color.yellow, transp=75), size=size.tiny)
    if higherHighShort
        label.new(bar_index - lookback, currHigh + 10, style=label.style_triangledown, color=color.new(color.green, transp=75), size=size.tiny)
    if lowerLowShort
        label.new(bar_index - lookback, currLow - 10, style=label.style_triangleup, color=color.new(color.red, transp=75), size=size.tiny)
    if higherLowShort
        label.new(bar_index - lookback, currLow - 10, style=label.style_triangleup, color=color.new(color.blue, transp=75), size=size.tiny)
else if displayHighLows
    if lowerPriceHighShort
        label.new(bar_index - barsback, currPriceHigh * 1.05, style=label.style_triangledown, color=color.new(color.yellow, transp=75), size=size.tiny)
    if higherPriceHighShort
        label.new(bar_index - barsback, currPriceHigh * 1.05, style=label.style_triangledown, color=color.new(color.green, transp=75), size=size.tiny)
    if lowerPriceLowShort
        label.new(bar_index - barsback, currPriceLow * 0.95, style=label.style_triangleup, color=color.new(color.red, transp=75), size=size.tiny)
    if higherPriceLowShort
        label.new(bar_index - barsback, currPriceLow * 0.95, style=label.style_triangleup, color=color.new(color.blue, transp=75), size=size.tiny)

labelColor1 = color.new(color.black, transp=25)
// Short Regular Bullish Divergence - trend reversal
// Price makes lower lows while rsi makes higher lows
if regShortBullish and not regShortBullish[1]
    if not overlayMode // RSI
        label.new(x_low_mid, (currLow + lastLowShort) / 2, "Reg Bull Div", color=labelColor1, style=label.style_label_up, textcolor=color.green, size=size.small)
    else
        label.new(x_price_low_mid, (currPriceLow + lastPriceLowShort) / 2, "Reg RSI Bull Div", color=labelColor1, style=label.style_label_up, textcolor=color.green, size=size.normal)

// Short Hidden Bullish Divergence - trend continuation
// Price makes higher lows while rsi makes lower lows
if hidShortBullish and not hidShortBullish[1]
    if not overlayMode // RSI
        label.new(x_low_mid, (currLow + lastLowShort) / 2, "Hid Bull Div", color=labelColor1, style=label.style_label_up, textcolor=color.blue, size=size.small)
    else
        label.new(x_price_low_mid, (currPriceLow + lastPriceLowShort) / 2, "Hid RSI Bull Div", color=labelColor1, style=label.style_label_up, textcolor=color.blue, size=size.normal)


// Short Regular Bearish Divergence - trend reversal
// Price makes higher highs while rsi makes lower highs
if regShortBearish and not regShortBearish[1]
    if not overlayMode // RSI
        label.new(x_high_mid, (currHigh + lastHighShort) / 2, " Reg Bear Div", color=labelColor1, textcolor=color.red, size=size.small)
    else
        label.new(x_price_high_mid, (currPriceHigh + lastPriceHighShort) / 2, "Reg RSI Bear Div", color=labelColor1, textcolor=color.red, size=size.normal)
        
// Short Hidden Bearish Divergence - trend continuation
// Price makes lower highs while rsi makes higher highs
if hidShortBearish and not hidShortBearish[1]
    if not overlayMode // RSI
        label.new(x_high_mid, (currHigh + lastHighShort) / 2, "Hid Bear Div", color=labelColor1, textcolor=color.yellow, size=size.small)
    else
        label.new(x_price_high_mid, (currPriceHigh + lastPriceHighShort) / 2, "Hid RSI Bear Div", color=labelColor1, textcolor=color.yellow, size=size.normal)