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

//@version=5
strategy("Futures and Forex [Crkissoon]", "Futures and Forex", overlay=true, process_orders_on_close=true, initial_capital=10000, default_qty_type=strategy.cash)

_green = color.new(color.green, 85)
_red = color.new(color.red, 85)
pv = syminfo.pointvalue


/////////////////////////////////////////////////////////////           Strategy Settings           /////////////////////////////////////////////////////////////
risk_type_per = "%", risk_type_cash = "$"

in_alert_en = input.bool(false, "Enable PineConnector alerts?", group="Alert Settings")
in_alert_key = input.string("", "License ID", group="Alert Settings")

in_strat_risk_amount_val = input.float(1000.0, "Risk Amount", inline="Risk", group="Strategy Settings")
in_strat_risk_amount_type = input.string(risk_type_cash, "", [risk_type_cash, risk_type_per], inline="Risk", group="Strategy Settings")
in_strat_session_time_en = input.bool(true, "Enable session time?", group="Strategy Settings")
in_strat_session_time = input.session("0800-2000", "Session time", inline="SSesT", group="Strategy Settings")
in_strat_tz = input.string('GMT-4', '', ['GMT-11', 'GMT-10', 'GMT-9', 'GMT-8', 'GMT-7', 'GMT-6', 'GMT-5', 'GMT-4', 'GMT-3', 'GMT-2', 'GMT-1', 'GMT', 'GMT+1', 'GMT+2', 'GMT+3', 'GMT+4', 'GMT+5', 'GMT+6', 'GMT+7', 'GMT+8', 'GMT+9', 'GMT+10', 'GMT+11', 'GMT+12'], inline="SSesT", group='Strategy Settings')
in_strat_session_highlight = input.bool(true, "Highlight session?", inline="SSesHigh", group="Strategy Settings")
in_strat_session_highlight_col = input.color(color.new(color.blue, 85), "", inline="SSesHigh", group="Strategy Settings")

in_strat_atr_tf = input.timeframe("", "ATR Timeframe", group="Exit Settings")
in_strat_atr_len = input.int(15, "ATR Length", minval=1, group="Exit Settings")
in_strat_atr_smoothing = input.string("RMA", "Smoothing", ["RMA", "SMA", "EMA", "WMA"], group="Exit Settings")
in_strat_tp_mul = input.float(2, "ATR Take profit multiplier", step=0.1, group="Exit Settings")
in_strat_sl_mul = input.float(2, "ATR Stop loss multiplier", step=0.1, group="Exit Settings")
in_strat_be_en = input.bool(false, "Enable breakeven?", group="Exit Settings")
in_strat_sl_be = input.float(2, "ATR move to break even multiplier", step=0.1, group="Exit Settings")

in_strat_ep_col = input.color(color.white, "EP", inline="SCOL", group="Display Settings")
in_strat_tp_col = input.color(color.green, "TP", inline="SCOL", group="Display Settings")
in_strat_sl_col = input.color(color.red, "SL", inline="SCOL", group="Display Settings")
in_strat_be_col = input.color(color.orange, "BE", inline="SCOL", group="Display Settings")

in_strat_std_en = input.bool(true, "Enable Standard Entry?", group="Standard Entry")

in_strat_sosc_en = input.bool(true, "Enable SuperOSC Entry?", group="SuperOSC Entry")
in_strat_sosc_barssince = input.int(3, "Allowed # of bars for the conditions to be true", minval=0, group="SuperOSC Entry")

in_strat_pb_en = input.bool(false, "Enable Pullback Entry?", group="Pullback Entry")
in_strat_kama_bars = input.int(12, "Number of bars the price should be under the KAMA baseline", minval=0, group="Pullback Entry")
in_strat_st_bars = input.int(6, "Number of bars supertrend should be bullish/bearish", minval=0, group="Pullback Entry")
in_strat_kama_cx_bars = input.int(2, "Number of bars KAMA needs to cross above and below the KAMA baseline within", minval=0, inline="For Pullback entry only", group="Pullback Entry")

kama_baseline_src = input.source(close, 'Baseline Source', group="KAMA Baseline + ATR")
kama_baseline_len = input.int(20, 'Baseline Length', group="KAMA Baseline + ATR")
kama_fast = input.int(2, 'Fast SC (for kama)', group="KAMA Baseline + ATR")
kama_slow = input.int(30, 'Slow SC (for kama)', group="KAMA Baseline + ATR")

kama_atr_len = input.int(20, 'ATR Length', group="KAMA Baseline + ATR")
kama_baselinechoice = input.string('KAMA', 'Baseline', ['EMA', 'KAMA'], group="KAMA Baseline + ATR")
kama_atr_factor = input.float(1.1, 'ATR * x', group="KAMA Baseline + ATR")
kama_darkmode = input.bool(false, 'darkmode ?', group="KAMA Baseline + ATR")
kama_plotit = input.bool(true, 'plot the atr lines ?', group="KAMA Baseline + ATR")
kama_fillit = input.bool(false, 'fill the atr channel ?', group="KAMA Baseline + ATR")
kama_show_cx = input.bool(false, "Show baseline crosses?", group="KAMA Baseline + ATR")

qqe_src = input.source(close, "Source", group="QQE")
qqe_length = input.int(20, 'RSI Length', minval=1, group="QQE")
qqe_SSF = input.int(1, 'SF RSI SMoothing Factor', minval=1, group="QQE")

st_atrPeriod = input(30, "ATR Length", group="Supertrend")
st_factor = input.float(5.0, "Factor", step = 0.01, group="Supertrend")

kama_adapt_adapt_Length = input.int(200, "Length", minval=1, group="KAMA Adaptive")

st_osc_length = input.int(35, "Length", minval=1, group="SuperTrend Oscillator")
st_osc_mult = input.float(3., "Multiplier", minval=1, group="SuperTrend Oscillator")
st_osc_smooth = input.int(72, "Smooth", minval=1, group="SuperTrend Oscillator")

dpo_Length = input.int(25, 'Period', minval=1, group="Detrend Price DPO Indicator")
dpo_isCentered = input.bool(false, "Is Centered?", group="Detrend Price DPO Indicator")

wad_sensitivity = input(150, 'Sensitivity', group="Waddah Attar Explosion")
wad_fastLength = input(20, 'FastEMA Length', group="Waddah Attar Explosion")
wad_slowLength = input(40, 'SlowEMA Length', group="Waddah Attar Explosion")
wad_channelLength = input(20, 'BB Channel Length', group="Waddah Attar Explosion")
wad_mult = input(3.0, 'BB Stdev Multiplier', group="Waddah Attar Explosion")
/////////////////////////////////////////////////////////////           Strategy Settings           /////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////           KAMA            /////////////////////////////////////////////////////////////
kama_price = close

kama_ma(type, src, len) =>
    float result = 0
    if type == 'EMA'  // Exponential
        result := ta.ema(src, len)
        result
    if type == 'RMA'
        result := ta.rma(src, len)
        result
    if type == 'KAMA'
        volatility = math.sum(math.abs(src - src[1]), len)
        change = math.abs(src - src[len])
        efficiency_ratio = float(na)
        if volatility == 0  // because we don't want to break the universe
            efficiency_ratio := 0
            efficiency_ratio
        else
            efficiency_ratio := change / volatility
            efficiency_ratio
        fastest_smoothing_constant = 2 / (kama_fast + 1)
        slowest_smoothing_constant = 2 / (kama_slow + 1)
        smoothing_constant = math.pow(efficiency_ratio * (fastest_smoothing_constant - slowest_smoothing_constant) + slowest_smoothing_constant, 2)
        kama = 0.0
        kama := nz(kama[1]) + smoothing_constant * (src - nz(kama[1]))
        result := kama
        result
    result

kama_baseline = kama_ma(kama_baselinechoice, kama_baseline_src, kama_baseline_len)
kama_atr = kama_ma('RMA', ta.tr(true), kama_atr_len)
kama_baselinetopatr = kama_baseline + kama_atr * kama_atr_factor
kama_baselinebottomatr = kama_baseline - kama_atr * kama_atr_factor

kama_mycolor = color(na)

if kama_darkmode == true
    kama_mycolor := color(color.white)
    kama_mycolor
else
    kama_mycolor := color(color.black)
    kama_mycolor

kama_is_in_bands = (close > kama_baselinebottomatr) and (close < kama_baselinetopatr)

var kama_pb_cnt_long = 0
var kama_pb_cnt_short = 0
var kama_pb_is_cnt_long_valid = false
var kama_pb_is_cnt_short_valid = false

kama_long_co = ta.crossover(close, kama_baseline)
kama_short_cu = ta.crossunder(close, kama_baseline)

kama_long = kama_long_co and (close < kama_baselinetopatr)
kama_short = kama_short_cu and (close > kama_baselinebottomatr)

plotshape(kama_show_cx and kama_long, "Kama long cross", shape.triangleup, location.belowbar, color.green)
plotshape(kama_show_cx and kama_short, "Kama short cross", shape.triangledown, location.abovebar, color.red)

kama_long_bs = ta.barssince(kama_long)
kama_short_bs = ta.barssince(kama_short)

kama_socs_in_long_zone = kama_long_bs <= in_strat_sosc_barssince
kama_socs_in_short_zone = kama_short_bs <= in_strat_sosc_barssince

kama_sosc_long = (close > kama_baseline) and kama_is_in_bands
kama_sosc_short = (close < kama_baseline) and kama_is_in_bands

kama_pb_barssince_co = ta.barssince(kama_long_co)
kama_pb_barssince_cu = ta.barssince(kama_short_cu)

kama_pb_cnt_long := (close > kama_baseline) ? kama_pb_cnt_long + 1 : 0
kama_pb_cnt_short := (close < kama_baseline) ? kama_pb_cnt_short + 1 : 0

kama_pb_cnt_long_valid = (kama_pb_cnt_long >= in_strat_kama_bars)
kama_pb_cnt_short_valid = (kama_pb_cnt_short >= in_strat_kama_bars)

kama_pb_is_cnt_long_valid := kama_long_co[1] ? false : kama_short_cu ? kama_pb_cnt_long_valid[1] : kama_pb_is_cnt_long_valid
kama_pb_is_cnt_short_valid := kama_short_cu[1] ? false : kama_long_co ? kama_pb_cnt_short_valid[1] : kama_pb_is_cnt_short_valid

kama_pb_long_cx_valid = (kama_pb_barssince_cu > 0) and (kama_pb_barssince_cu <= in_strat_kama_cx_bars) and kama_long_co
kama_pb_short_cx_valid = (kama_pb_barssince_co > 0) and (kama_pb_barssince_co <= in_strat_kama_cx_bars) and kama_short_cu

kama_pb_long = kama_pb_is_cnt_long_valid and kama_is_in_bands and kama_pb_long_cx_valid
kama_pb_short = kama_pb_is_cnt_short_valid and kama_is_in_bands and kama_pb_short_cx_valid

var kama_pb_active_long = false
var kama_pb_active_short = false
kama_pb_active_long := kama_long_co ? false : kama_short_cu ? true : kama_pb_active_long
kama_pb_active_short := kama_short_cu ? false : kama_long_co ? true : kama_pb_active_short

kama_pb_new_active_long = not kama_pb_active_long[1] and kama_pb_active_long
kama_pb_new_active_short = not kama_pb_active_short[1] and kama_pb_active_short

plot(kama_baseline, color=color.new(color.aqua, 0), linewidth=1, title='KAMA - Baseline')

//we plot the kama_atr channel if option kama_plotit is true
kama_A = plot(kama_baselinetopatr, color=kama_plotit ? kama_mycolor : na, linewidth=1, title='KAMA - Baselinetop')
kama_B = plot(kama_baselinebottomatr, color=kama_plotit ? kama_mycolor : na, linewidth=1, title='KAMA - Baselinebottom')
//we fill it if the option kama_fillit is true
fill(kama_A, kama_B, color=kama_fillit ? color.new(kama_mycolor, 90) : na)
/////////////////////////////////////////////////////////////           KAMA            /////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////           QQE         /////////////////////////////////////////////////////////////
qqe_RSII = ta.ema(ta.rsi(qqe_src, qqe_length), qqe_SSF)
qqe_TR = math.abs(qqe_RSII - qqe_RSII[1])
qqe_wwalpha = 1 / qqe_length
qqe_WWMA = 0.0
qqe_WWMA := qqe_wwalpha * qqe_TR + (1 - qqe_wwalpha) * nz(qqe_WWMA[1])
qqe_ATRRSI = 0.0
qqe_ATRRSI := qqe_wwalpha * qqe_WWMA + (1 - qqe_wwalpha) * nz(qqe_ATRRSI[1])
qqe_QQEF = ta.ema(ta.rsi(qqe_src, qqe_length), qqe_SSF)
qqe_QUP = qqe_QQEF + qqe_ATRRSI * 4.236
qqe_QDN = qqe_QQEF - qqe_ATRRSI * 4.236
qqe_QQES = 0.0
qqe_QQES := qqe_QUP < nz(qqe_QQES[1]) ? qqe_QUP : qqe_QQEF > nz(qqe_QQES[1]) and qqe_QQEF[1] < nz(qqe_QQES[1]) ? qqe_QDN : qqe_QDN > nz(qqe_QQES[1]) ? qqe_QDN : qqe_QQEF < nz(qqe_QQES[1]) and qqe_QQEF[1] > nz(qqe_QQES[1]) ? qqe_QUP : nz(qqe_QQES[1])

qqe_long = qqe_QQEF > qqe_QQES
qqe_short = qqe_QQEF < qqe_QQES

var qqe_sosc_long = false
var qqe_sosc_short = false
qqe_sosc_long := not kama_socs_in_long_zone ? false : not qqe_sosc_long ? (qqe_long and kama_socs_in_long_zone) : qqe_sosc_long
qqe_sosc_short := not kama_socs_in_short_zone ? false : not qqe_sosc_short ? (qqe_short and kama_socs_in_short_zone) : qqe_sosc_short
/////////////////////////////////////////////////////////////           QQE         /////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////           Supertrend          /////////////////////////////////////////////////////////////
[st_supertrend, st_direction] = ta.supertrend(st_factor, st_atrPeriod)

st_bodyMiddle = plot((open + close) / 2, display=display.none)
st_upTrend = plot(st_direction < 0 ? st_supertrend : na, "Up Trend", color = color.green, style=plot.style_linebr)
st_downTrend = plot(st_direction < 0? na : st_supertrend, "Down Trend", color = color.red, style=plot.style_linebr)

fill(st_bodyMiddle, st_upTrend, color.new(color.green, 90), fillgaps=false)
fill(st_bodyMiddle, st_downTrend, color.new(color.red, 90), fillgaps=false)

st_long = st_direction < 0
st_short = st_direction > 0

st_is_new_long = not st_long[1] and st_long
st_is_new_short = not st_short[1] and st_short

st_long_bs = ta.barssince(st_is_new_long)
st_short_bs = ta.barssince(st_is_new_short)

var st_sosc_long = false
var st_sosc_short = false
st_sosc_long := not kama_socs_in_long_zone ? false : not st_sosc_long ? (st_long and kama_socs_in_long_zone) : st_sosc_long
st_sosc_short := not kama_socs_in_short_zone ? false : not st_sosc_short ? (st_short and kama_socs_in_short_zone) : st_sosc_short

var st_pb_long_cnt = 0
var st_pb_short_cnt = 0
var st_pb_is_cnt_long_valid = false
var st_pb_is_cnt_short_valid = false

st_pb_long_cnt := st_long ? st_pb_long_cnt + 1 : 0
st_pb_short_cnt := st_short ? st_pb_short_cnt + 1 : 0

st_pb_cnt_long_valid = (st_pb_long_cnt >= in_strat_st_bars)
st_pb_cnt_short_valid = (st_pb_short_cnt >= in_strat_st_bars)

st_pb_is_cnt_long_valid := kama_long_co[1] ? false : kama_short_cu ? st_pb_cnt_long_valid[1] : st_pb_is_cnt_long_valid
st_pb_is_cnt_short_valid := kama_short_cu[1] ? false : kama_long_co ? st_pb_cnt_short_valid[1] : st_pb_is_cnt_short_valid

var st_pb_no_flip_long = false
var st_pb_no_flip_short = false

st_pb_no_flip_long := kama_pb_new_active_long ? true : (kama_pb_new_active_short[1] or st_short) ? false : st_pb_no_flip_long
st_pb_no_flip_short := kama_pb_new_active_short ? true : (kama_pb_new_active_long[1] or st_long) ? false : st_pb_no_flip_short

st_pb_long = st_pb_is_cnt_long_valid and st_pb_no_flip_long
st_pb_short = st_pb_is_cnt_short_valid and st_pb_no_flip_short
/////////////////////////////////////////////////////////////           Supertrend          /////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////           Kaufman MA          /////////////////////////////////////////////////////////////
kama_adapt_xPrice = close
kama_adapt_xvnoise = math.abs(kama_adapt_xPrice - kama_adapt_xPrice[1])
kama_adapt_nAMA = 0.0
kama_adapt_nfastend = 0.666
kama_adapt_nslowend = 0.0645
kama_adapt_nsignal = math.abs(kama_adapt_xPrice - kama_adapt_xPrice[kama_adapt_adapt_Length])
kama_adapt_nnoise = math.sum(kama_adapt_xvnoise, kama_adapt_adapt_Length)
kama_adapt_nefratio = kama_adapt_nnoise != 0 ? kama_adapt_nsignal / kama_adapt_nnoise : 0
kama_adapt_nsmooth = math.pow(kama_adapt_nefratio * (kama_adapt_nfastend - kama_adapt_nslowend) + kama_adapt_nslowend, 2)
kama_adapt_nAMA := nz(kama_adapt_nAMA[1]) + kama_adapt_nsmooth * (kama_adapt_xPrice - nz(kama_adapt_nAMA[1]))

plot(kama_adapt_nAMA, color=color.new(color.yellow, 0), title='KAMA')

kama_adapt_long = (close > kama_adapt_nAMA)
kama_adapt_short = (close < kama_adapt_nAMA)

var kama_adapt_sosc_long = false
var kama_adapt_sosc_short = false
kama_adapt_sosc_long := not kama_socs_in_long_zone ? false : not kama_adapt_sosc_long ? (kama_adapt_long and kama_socs_in_long_zone) : kama_adapt_sosc_long
kama_adapt_sosc_short := not kama_socs_in_short_zone ? false : not kama_adapt_sosc_short ? (kama_adapt_short and kama_socs_in_short_zone) : kama_adapt_sosc_short
/////////////////////////////////////////////////////////////           Kaufman MA          /////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////           Supertrend Osc          /////////////////////////////////////////////////////////////
//----
st_osc_src = close
st_osc_lower = 0.
st_osc_upper = 0.
st_osc_trend = 0

//----
st_osc_atr = ta.atr(st_osc_length) * st_osc_mult
st_osc_up = hl2 + st_osc_atr
st_osc_dn = hl2 - st_osc_atr
st_osc_upper := st_osc_src[1] < st_osc_upper[1] ? math.min(st_osc_up, st_osc_upper[1]) : st_osc_up
st_osc_lower := st_osc_src[1] > st_osc_lower[1] ? math.max(st_osc_dn, st_osc_lower[1]) : st_osc_dn
st_osc_trend := st_osc_src > st_osc_upper[1] ? 1 : st_osc_src < st_osc_lower[1] ? 0 : st_osc_trend[1]
st_osc_Spt = st_osc_trend * st_osc_lower + (1 - st_osc_trend) * st_osc_upper
//----
st_osc_osc = math.max(math.min((st_osc_src - st_osc_Spt) / (st_osc_upper - st_osc_lower), 1), -1)

st_osc_long = (st_osc_osc * 100) > 0
st_osc_short = (st_osc_osc * 100) < 0

st_osc_is_new_long = not st_osc_long[1] and st_osc_long
st_osc_is_new_short = not st_osc_short[1] and st_osc_short

st_osc_long_bs = ta.barssince(st_osc_is_new_long)
st_osc_short_bs = ta.barssince(st_osc_is_new_short)

st_osc_sosc_long_cond = st_osc_long and (st_osc_osc == 1)
st_osc_sosc_short_cond = st_osc_short and (st_osc_osc == -1)

var st_osc_sosc_long = false
var st_osc_sosc_short = false
st_osc_sosc_long := not kama_socs_in_long_zone ? false : not st_osc_sosc_long ? (st_osc_sosc_long_cond and kama_socs_in_long_zone) : st_osc_sosc_long
st_osc_sosc_short := not kama_socs_in_short_zone ? false : not st_osc_sosc_short ? (st_osc_sosc_short_cond and kama_socs_in_short_zone) : st_osc_sosc_short

var st_osc_pb_long = false
var st_osc_pb_short = false

st_osc_pb_long := kama_pb_new_active_long ? true : (kama_pb_new_active_short[1] or st_osc_short) ? false : st_osc_pb_long
st_osc_pb_short := kama_pb_new_active_short ? true : (kama_pb_new_active_long[1] or st_osc_long) ? false : st_osc_pb_short
/////////////////////////////////////////////////////////////           Supertrend Osc          /////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////           Detrend PriceOscillator         /////////////////////////////////////////////////////////////
dpo_barsback = dpo_Length / 2 + 1
dpo_xSMA = ta.sma(hl2, dpo_Length)
dpo_DPO = dpo_isCentered ? hl2[dpo_barsback] - dpo_xSMA : hl2 - dpo_xSMA[dpo_barsback]
dpo_sma = ta.ema(dpo_DPO, 26)

dpo_long = (dpo_DPO > 0)
dpo_short = (dpo_DPO < 0)

dpo_is_new_long = not dpo_long[1] and dpo_long
dpo_is_new_short = not dpo_short[1] and dpo_short

dpo_long_bs = ta.barssince(dpo_is_new_long)
dpo_short_bs = ta.barssince(dpo_is_new_short)

var dpo_pb_long = false
var dpo_pb_short = false

dpo_pb_long := kama_pb_new_active_long ? true : (kama_pb_new_active_short[1] or dpo_short) ? false : dpo_pb_long
dpo_pb_short := kama_pb_new_active_short ? true : (kama_pb_new_active_long[1] or dpo_long) ? false : dpo_pb_short
/////////////////////////////////////////////////////////////           Detrend PriceOscillator         /////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////           Waddah Attar Explosion          /////////////////////////////////////////////////////////////
wad_DEAD_ZONE = nz(ta.rma(ta.tr(true), 100)) * 3.7

wad_calc_macd(source, wad_fastLength, wad_slowLength) =>
    fastMA = ta.ema(source, wad_fastLength)
    slowMA = ta.ema(source, wad_slowLength)
    fastMA - slowMA

wad_calc_BBUpper(source, length, wad_mult) =>
    basis = ta.sma(source, length)
    dev = wad_mult * ta.stdev(source, length)
    basis + dev

wad_calc_BBLower(source, length, wad_mult) =>
    basis = ta.sma(source, length)
    dev = wad_mult * ta.stdev(source, length)
    basis - dev

wad_t1 = (wad_calc_macd(close, wad_fastLength, wad_slowLength) - wad_calc_macd(close[1], wad_fastLength, wad_slowLength)) * wad_sensitivity

wad_e1 = wad_calc_BBUpper(close, wad_channelLength, wad_mult) - wad_calc_BBLower(close, wad_channelLength, wad_mult)

wad_trendUp = wad_t1 >= 0 ? wad_t1 : 0
wad_trendDown = wad_t1 < 0 ? -1 * wad_t1 : 0

wad_long = (wad_trendUp > wad_e1) and (wad_trendUp > wad_DEAD_ZONE)
wad_short = (wad_trendDown > wad_e1) and (wad_trendDown > wad_DEAD_ZONE)
wad_entry = wad_long or wad_short

var wad_sosc_long_entry = false
var wad_sosc_short_entry = false
wad_sosc_long_entry := not kama_socs_in_long_zone ? false : not wad_sosc_long_entry ? (wad_entry and kama_socs_in_long_zone) : wad_sosc_long_entry
wad_sosc_short_entry := not kama_socs_in_short_zone ? false : not wad_sosc_short_entry ? (wad_entry and kama_socs_in_short_zone) : wad_sosc_short_entry
/////////////////////////////////////////////////////////////           Waddah Attar Explosion          /////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////           Strategy            /////////////////////////////////////////////////////////////
atr_ma_function(source, length, smoothing) =>
    switch smoothing
        "RMA" => ta.rma(source, length)
        "SMA" => ta.sma(source, length)
        "EMA" => ta.ema(source, length)
        => ta.wma(source, length)

var float strat_atr_at_entry = na
var float strat_entry_price = na
var float strat_tp_price = na
var float strat_be_price = na
var float strat_sl_initial_price = na
var float strat_sl_price = na
var bool strat_long_be_hit = false
var bool strat_short_be_hit = false
var bool strat_be_hit = false

strat_is_long = strategy.position_size > 0
strat_is_short = strategy.position_size < 0
strat_is_pos_closed = (strategy.position_size[1] != 0) and (strategy.position_size == 0)
strat_not_in_pos = strategy.position_size == 0

strat_std_long_cond = in_strat_std_en ? (wad_entry and kama_long and (st_long or kama_adapt_long) and qqe_long and (st_osc_long or dpo_long)) : false
strat_std_short_cond = in_strat_std_en ? (wad_entry and kama_short and (st_short or kama_adapt_short) and qqe_short and (st_osc_short or dpo_short)) : false

strat_sosc_long_cond = in_strat_sosc_en ? (wad_sosc_long_entry and st_osc_sosc_long and kama_sosc_long and (st_sosc_long or kama_adapt_sosc_long) and qqe_long and st_osc_sosc_long_cond and kama_is_in_bands) : false
strat_sosc_short_cond = in_strat_sosc_en ? (wad_sosc_short_entry and st_osc_sosc_short and kama_sosc_short and (st_sosc_short or kama_adapt_sosc_short) and qqe_short and st_osc_sosc_short_cond and kama_is_in_bands) : false

strat_pb_long_cond = in_strat_pb_en ? (kama_pb_long and st_pb_long and st_osc_pb_long and dpo_pb_long) : false
strat_pb_short_cond = in_strat_pb_en ? (kama_pb_short and st_pb_short and st_osc_pb_short and dpo_pb_short) : false

time_is_allowed = in_strat_session_time_en ? (time(timeframe.period, in_strat_session_time + ":1234567", in_strat_tz)) : true
bgcolor((in_strat_session_time_en and time_is_allowed and in_strat_session_highlight) ? in_strat_session_highlight_col : na)

strat_long_cond = time_is_allowed and (strat_std_long_cond or strat_sosc_long_cond or strat_pb_long_cond)
strat_short_cond = time_is_allowed and (strat_std_short_cond or strat_sosc_short_cond or strat_pb_short_cond)

strat_is_new_long_pos = (strat_not_in_pos and strat_long_cond) or (strat_is_short and strat_long_cond)
strat_is_new_short_pos = (strat_not_in_pos and strat_short_cond) or (strat_is_long and strat_short_cond)
strat_is_new_pos = strat_is_new_long_pos or strat_is_new_short_pos

strat_is_long := strat_is_long or strat_is_new_long_pos
strat_is_short := strat_is_short or strat_is_new_short_pos

strat_atr_ctf = atr_ma_function(ta.tr(true), in_strat_atr_len, in_strat_atr_smoothing)
strat_atr_mtf = request.security(syminfo.tickerid, in_strat_atr_tf, strat_atr_ctf[1], lookahead=barmerge.lookahead_on)
strat_atr = in_strat_atr_tf == "" ? strat_atr_ctf : strat_atr_mtf

strat_atr_at_entry := strat_is_new_pos ? strat_atr : strat_is_pos_closed ? na : strat_atr_at_entry
strat_entry_price := strat_is_new_pos ? close : strat_is_pos_closed ? na : strat_entry_price
//strat_entry_price := strat_is_new_pos ? (strategy.opentrades.entry_price(strategy.opentrades-1)) : strat_is_pos_closed ? na : strat_entry_price

strat_long_tp_price = strat_entry_price + (strat_atr_at_entry * in_strat_tp_mul)
strat_long_sl_price = strat_entry_price - (strat_atr_at_entry * in_strat_sl_mul)
strat_long_be_price = strat_entry_price + (strat_atr_at_entry * in_strat_sl_be)
strat_long_be_hit := strat_is_pos_closed ? false : not strat_long_be_hit ? (strat_is_long and (high >= strat_long_be_price)) ? true : strat_long_be_hit : strat_long_be_hit

strat_short_tp_price = strat_entry_price - (strat_atr_at_entry * in_strat_tp_mul)
strat_short_sl_price = strat_entry_price + (strat_atr_at_entry * in_strat_sl_mul)
strat_short_be_price = strat_entry_price - (strat_atr_at_entry * in_strat_sl_be)
strat_short_be_hit := strat_is_pos_closed ? false : not strat_short_be_hit ? strat_is_short and (low <= strat_short_be_price) ? true : strat_short_be_hit : strat_short_be_hit

strat_tp_price := strat_is_long ? strat_long_tp_price : strat_is_short ? strat_short_tp_price : na
strat_sl_initial_price := strat_is_long ? strat_long_sl_price : strat_is_short ? strat_short_sl_price : na
strat_be_price := strat_is_long ? strat_long_be_price : strat_is_short ? strat_short_be_price : na

strat_be_hit := strat_is_long ? strat_long_be_hit : strat_is_short ? strat_short_be_hit : false
strat_sl_price := strat_be_hit and in_strat_be_en ? strat_entry_price : strat_sl_initial_price

strat_sl_dist = math.abs(strat_entry_price - strat_sl_price)
strat_risk_amount_per = in_strat_risk_amount_val * 0.01
strat_position_value_per = strategy.equity * strat_risk_amount_per / (strat_sl_dist / strat_entry_price)
strat_pos_size_per = strat_position_value_per / strat_entry_price

strat_pos_size_cash = math.max(1, math.round((in_strat_risk_amount_val / (pv * strat_atr))))

strat_pos_size = switch in_strat_risk_amount_type
    risk_type_per => strat_pos_size_per
    risk_type_cash => strat_pos_size_cash
    => na

if (strat_long_cond)
    s_alert = ""
    
    if ((in_alert_en) and (in_strat_risk_amount_type == risk_type_per))
        s_alert := in_alert_key + ',buy,' + syminfo.ticker + ',sl=' +str.tostring(strat_sl_price) + ',tp=' +str.tostring(strat_tp_price)+ ',risk=' + str.tostring(strat_risk_amount_per)
    else
        s_alert := "Enter Long"
    
    strategy.entry("Long", strategy.long, qty=strat_pos_size, alert_message=s_alert)

if (strat_short_cond)
    s_alert = ""
    
    if ((in_alert_en) and (in_strat_risk_amount_type == risk_type_per))
        s_alert := in_alert_key + ',sell,' + syminfo.ticker + ',sl=' +str.tostring(strat_sl_price) + ',tp=' +str.tostring(strat_tp_price)+ ',risk=' + str.tostring(strat_risk_amount_per)
    else
        s_alert := "Enter Short"
        
    strategy.entry("Short", strategy.short, qty=strat_pos_size, alert_message=s_alert)

if (strat_is_long)
    strategy.exit("Long Exit", "Long", limit=strat_tp_price, stop=strat_sl_price, comment_profit="Long TP", comment_loss="Long SL")

if (strat_is_short)
    strategy.exit("Short Exit", "Short", limit=strat_tp_price, stop=strat_sl_price, comment_profit="Short TP", comment_loss="Short SL")

plot(strat_entry_price, "Entry Price", in_strat_ep_col, 1, plot.style_circles)
plot(strat_tp_price, "Take Profit", in_strat_tp_col, 1, plot.style_circles)
plot(strat_sl_price, "Stop Loss", in_strat_sl_col, 1, plot.style_circles)
plot(in_strat_be_en ? strat_be_price : na, "Break Even", in_strat_be_col, 1, plot.style_circles)
/////////////////////////////////////////////////////////////           Strategy            /////////////////////////////////////////////////////////////