Edge 59

//@version=5
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © bford

strategy(title="Edge 59", overlay=true)

// START of INDICATOR

// ADX
// OG: E59 was 14,14,17,10 - but first visual test I did was with defaults 14,14,18,34 - and this worked really well
lenadx = input.int(14, minval=1, title="DI Length")
lensig = input.int(14, title="ADX Smoothing", minval=1, maxval=50)
limadx = input.int(17, minval=1, title="ADX MA Active")
len = input.int(10, minval=1, title="Length")
up = ta.change(high)
down = -ta.change(low)
trur = ta.rma(ta.tr, lenadx) // TODO: what is 'tr' here?
plus = fixnan(100 * ta.rma(up > down and up > 0 ? up : 0, lenadx) / trur)
minus = fixnan(100 * ta.rma(down > up and down > 0 ? down : 0, lenadx) / trur)
sum = plus + minus 
adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), lensig)
macol = adx > limadx and plus > minus ? color.lime : adx > limadx and plus < minus ? color.red :color.black
src = input(close, title="Source")
out = ta.wma(src, len)
plot(out, color=macol, title="MA", linewidth= 3)
adx_long_filter = macol == color.lime 
adx_short_filter = macol == color.red

// Trend Follower
matype= 'EMA'
prd = input.int(20, title = "Period to Check Trend", minval = 5)
maprd = input.int(20, title = "MA Period", minval = 2)
rateinp = input.float(1, title = "Trend Channel Rate %", minval = 0.1, step = 0.1)
ulinreg = input.bool(true, title = "Use Linear Regression")
linprd = input.int(5, title = "Linear Regression Period", minval = 2)

rate = rateinp / 100
pricerange = ta.highest(280) - ta.lowest(280) // TODO: what are these hardcoded 280's?
chan = pricerange * rate
    
gettrend(len)=>
    masrc = matype == 'EMA' ? ta.ema(close, len) : matype == 'RMA' ? ta.rma(close, len) : matype == 'VWMA' ? ta.vwma(close, len) : matype == 'WMA' ? ta.wma(close, len) : ta.sma(close, len)
    ma = ulinreg ? ta.linreg(masrc, linprd, 0) : masrc
    
    hh = ta.highest(ma, prd)
    ll = ta.lowest(ma, prd)
    diff = math.abs(hh - ll)
    
    inner = ma < hh - chan ? -1 : 0
    middle = ma > ll + chan ? 1 : inner
    trend = diff > chan ? middle : 0
    _ret = trend * diff / chan
    _ret

trend = gettrend(maprd)

trandchanged = trend - nz(trend[1])
tcol =  trend > 0 ? trandchanged> 0 ? #00FF00ff : trandchanged <= 0 ? #00FF006f : #00FF00af :
  trend < 0 ? trandchanged < 0 ? #FF0000ff: trandchanged >= 0 ? #FF00006f : #FF0000af : na

trend_follower_long_filter = tcol == #00FF00ff
trend_follower_short_filter  = tcol == #FF0000ff

// 22 Days high/low body prices
num_breakout_days = input.int(22, minval=1, title="Number of Days (Close Breakout)")

lowest_low = ta.lowest(low, num_breakout_days)[1]
highest_high = ta.highest(high, num_breakout_days)[1]

long_entry_signal = high > highest_high
short_entry_signal = low < lowest_low

// debug
plot(lowest_low)
plot(highest_high)

// Combine Filters

long_filter = adx_long_filter and trend_follower_long_filter
short_filter = adx_short_filter and trend_follower_short_filter

long_entry = long_filter and long_entry_signal
short_entry = short_filter and short_entry_signal

// Plots

// DEBUG: New Price High Lows (unfiltered entry signals)
// plotarrow(long_entry_signal, colorup = color.green)
// plotarrow(-short_entry_signal, colordown = color.red)

// Filters
plotarrow(long_filter?1:0, colorup = color.green, transp= 60)
plotarrow(short_filter?-1:0, colordown = color.red, transp=60)

// Filtered Entry (actual edge signal)
plotarrow(long_entry?1:0, colorup = color.green)
plotarrow(short_entry?-1:0, colordown = color.red)
// Study exit API
// long_entry and short_entry: entry signal with filters applied
// long_filter and short_filter: entry/stay in position filters are active: close position whenever this is false

// END of INDICATOR


// START of STRATEGY

// Entry and Exit

// Stops - 5-10% for each individual entry
long_stop_price = close * 0.9
short_stop_price = close *1.1
// note we might need to cancel stop orders manually when we exit

max_ordersize=math.floor(strategy.equity/close) // To dynamically calculate the order size as the account equity increases or decreases.
position_size = max_ordersize

// Entry is crossunder/over of lowest_body/highest_body, when = matching long/short_filter
// long entry
strategy.entry("long", strategy.long, position_size, when=long_entry)
// short entry
strategy.entry("short", strategy.short, position_size, when=short_entry)
// TODO: add stops with:  strategy.exit
// TODO: this is not adding to positions


// close_all when filters dont match trade direction
strategy.close('long', when=not long_filter)
strategy.close('short', when=not short_filter)
// plot(strategy.position_size)


//scratch
// if (not long_filter)
//     strategy.exit("long_trailing_stop", "long", trail_points = 4000, trail_offset = 1500)
// if (not short_filter)
//     strategy.exit("short_trailing_stop", "short", trail_points = 4000, trail_offset = 1500)