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

trend_up = 1
trend_down = -1

strategy(
     "unnamed [Strategy]",
     overlay = true,
     initial_capital = 10000,
     precision = 8,
     commission_type = strategy.commission.percent,
     commission_value= 0.05)


// Inputs
st_length     = input(48, title = "Super Trend - Length", type = input.integer, minval = 1, step = 1)
st_multiplier = input(8, title="Super Trend - Multiplier", type = input.float, minval = 1, step = 0.1)

jma_fast_length = input(125, title = "JMA - Fast Length", type = input.integer, minval = 1)
jma_fast_phase  = input(75, title = "JMA - Fast Phase", type = input.integer, minval = 1)
jma_fast_power  = input(1, title = "JMA - Fast Power", type = input.float, minval = 0.1)

jma_slow_length = input(350, title = "JMA - Slow Length", type = input.integer, minval = 1)
jma_slow_phase  = input(75, title = "JMA - Slow Phase", type = input.integer, minval = 1)
jma_slow_power  = input(1, title = "JMA - Slow Power", type = input.float, minval = 0.1)

range_resolution = input("D", title = "Range - Resolution", type = input.resolution)
range_session    = input("2300-2330:1234567", title = "Range - Session")

trade_both = "Both", trade_long = "Long", trade_short = "Short"
trade_direction       = input("Both", title = "Trade - Direction", options = [trade_both, trade_long, trade_short])

trade_risk            = input(10, title = "Trade - Risk %", type = input.integer, step = 1, minval = 1, maxval = 100)
trade_max_leverage = input(25, title = "Trade - Max Leverage %", type = input.integer, minval = 1, step = 1, maxval = 100)
trade_max_contract = input(150, title = "Trade - Max Contracts", type = input.integer, minval = 1, step = 1, maxval = 1000)

trade_profit_take = input(1, title = "Trade - Profit Take %", type = input.float, minval = 0.1, step = 0.1)
trade_profit_close = input(10, title = "Trade - Profit Close Take %", type = input.integer, minval = 1)

use_test_range = input(false, "Use Test Range", type = input.bool)
test_year      = input(2016, "Test - Year", type = input.integer, minval = 1970, maxval = 2222)
test_month     = input(01, "Test - Month", type = input.integer, minval = 1, maxval = 12)
test_day       = input(01, "Test - Day", type = input.integer,  minval = 1, maxval = 31)


// Functions
get_round(value, precision) => round(value * (pow(10, precision))) / pow(10, precision)

get_jma(values, length, phase, power) =>

    jma = 0.0
    e0 = 0.0
    e1 = 0.0
    e2 = 0.0

    ratio = phase < -100 ? 0.5 : phase > 100 ? 2.5 : phase / 100 + 1.5
    beta = 0.45 * (length - 1) / (0.45 * (length - 1) + 2)
    alpha = pow(beta, power)

    e0 := (1 - alpha) * values + alpha * nz(e0[1], values)
    e1 := (values - e0) * (1 - beta) + beta * nz(e1[1])
    e2 := (e0 + ratio * e1 - nz(jma[1], values)) * pow(1 - alpha, 2) + pow(alpha, 2) * nz(e2[1])

    jma := e2 + nz(jma[1], values)
    jma_slope = jma - nz(jma[1], values)

    [jma, jma_slope]

get_super_trend(high_values, low_values, length, multiplier) =>

    trend_bot = hl2 - atr(length) * multiplier
    trend_bot_prev = nz(trend_bot[1], trend_bot)
    trend_bot := low_values[1] > trend_bot_prev ? max(trend_bot, trend_bot_prev) : trend_bot

    trend_top = hl2 + atr(length) * multiplier
    trend_top_prev = nz(trend_top[1], trend_top)
    trend_top := high_values[1] < trend_top_prev ? min(trend_top, trend_top_prev) : trend_top

    trend_dir = 0
    trend_dir := high_values > trend_top_prev ? trend_up : low_values < trend_bot_prev ? trend_down : trend_dir[1]

    trend_line = trend_dir == trend_up ? trend_bot : trend_top

    [trend_top, trend_bot, trend_dir, trend_line]

is_new_bar(ses) =>
    t = time(range_resolution, ses)
    na(t[1]) and not na(t) or t[1] < t

is_session_open(ses) =>
    not na(time(timeframe.period, ses))


// Strategy
[st_trend_top, st_trend_bot, st_trend, st_line] = get_super_trend(close, close, st_length, st_multiplier)

[jma_fast, jma_fast_slope] = get_jma(close, jma_fast_length, jma_fast_phase, jma_fast_power)
[jma_slow, jma_slow_slope] = get_jma(close, jma_slow_length, jma_slow_phase, jma_slow_power)

float session_high = na
float session_low  = na

float range_high = na
float range_low  = na

if (is_session_open(range_session))
    if (is_new_bar(range_session))
        session_high := high
        session_low  := low
    else
        session_high := max(session_high[1], high)
        session_low  := min(session_low[1], low)
else
    session_high := session_high[1]
    session_low := session_low[1]
    range_high := nz(range_high, session_high)
    range_low  := nz(range_low,  session_low)


// Conditions
can_trade = not is_session_open(range_session)

range_long_condition = crossover(close, session_high)
range_short_condition = crossunder(close, session_low)

jma_long_condition = close > jma_slow and close > jma_fast and jma_fast > jma_slow
jma_short_condition = close < jma_slow and close < jma_fast and jma_fast < jma_slow

st_long_condition = crossover(close, st_line) //st_trend == trend_up
st_short_condition = crossunder(close, st_line)// st_trend == trend_down

enter_long_condition = can_trade and jma_long_condition and (st_long_condition or range_long_condition and close > st_line)
enter_short_condition = can_trade and jma_short_condition and (st_short_condition or range_short_condition and close < st_line)

exit_long_condition = not can_trade
exit_short_condition = not can_trade


// Backtesting

can_long  = trade_direction == trade_long or trade_direction == trade_both
can_short = trade_direction == trade_short or trade_direction == trade_both

int count = na, count := strategy.position_size == 0 ? na : nz(count[1])

float take_profit = na, take_profit := strategy.position_size == 0 ? na : nz(take_profit[1])
float liquidation = na, liquidation := strategy.position_size == 0 ? na : nz(liquidation[1])

float trade_leverage = na

strategy.cancel_all()

if(can_long)
    if(enter_long_condition and strategy.position_size == 0)

        trade_leverage := min(round((strategy.equity / (close - st_trend_bot)) * (trade_risk / 100)), trade_max_leverage)
        contracts = min(get_round(strategy.equity * trade_leverage / close, 2), trade_max_contract)

        // Market order
        strategy.order(
             "LONG",
             strategy.long,
             qty = contracts,
             oca_name = "LONG OCA")

        count := 1
        liquidation := close - (close / trade_leverage)
        take_profit := close * (1 + (trade_profit_take * (count / 100)))


if (can_short)
    if (enter_short_condition and strategy.position_size == 0)

        trade_leverage := min(round((strategy.equity / (st_trend_top - close)) * (trade_risk / 100)), trade_max_leverage)
        contracts = min(get_round(strategy.equity * trade_leverage / close, 2), trade_max_contract)

        // Market order
        strategy.order(
             "SHORT",
             strategy.short,
             qty = contracts,
             oca_name = "SHORT OCA")

        count := 1
        liquidation := close + (close / trade_leverage)
        take_profit := close * (1 - (trade_profit_take * (count / 100)))

if (strategy.position_size > 0)

    if (high > take_profit)
        count := count + 1

    take_profit := strategy.position_avg_price * (1 + (trade_profit_take * (count / 100)))
    amount = nz(strategy.position_size * (trade_profit_close / 100), 0.0)

    // Limit order
    strategy.order(
         "T/P", strategy.short,
         limit = take_profit,
         qty = get_round(amount, 2),
         oca_name = "LONG OCA",
         oca_type = strategy.oca.reduce,
         when = abs(strategy.position_size) > 0.5)

    // Market order
    strategy.order(
         "E/L", strategy.short,
         qty = get_round(abs(strategy.position_size), 2),
         oca_name = "LONG OCA",
         oca_type = strategy.oca.cancel,
         when = exit_long_condition)

    // Market order
    strategy.order(
         "S/L", strategy.short,
         stop = st_line,
         qty = get_round(abs(strategy.position_size), 2),
         oca_name = "LONG OCA",
         oca_type = strategy.oca.cancel)


if(strategy.position_size < 0)

    if (low < take_profit)
        count := count + 1

    take_profit := strategy.position_avg_price * (1 - (trade_profit_take * (count / 100)))
    amount = nz(abs(strategy.position_size) * (trade_profit_close / 100), 0.0)

    // Limit order
    strategy.order(
         "T/P", strategy.long,
         limit = take_profit,
         qty = get_round(amount, 2),
         oca_name = "SHORT OCA",
         oca_type = strategy.oca.reduce,
         when = abs(strategy.position_size) > 0.5)

    // Market order
    strategy.order(
         "E/L", strategy.long,
         qty = get_round(abs(strategy.position_size), 2),
         oca_name = "SHORT OCA",
         oca_type = strategy.oca.cancel,
         when = exit_long_condition)

    // Market order
    strategy.order(
         "S/L", strategy.long,
         stop = st_line,
         qty = get_round(abs(strategy.position_size), 2),
         oca_name = "SHORT OCA",
         oca_type = strategy.oca.cancel)


label label_leverage = na

if (not na(trade_leverage))
    label_leverage := label.new(na, na,
         "L " + tostring(trade_leverage),
         color = #363a45,
         textcolor = color.white,
         style = label.style_labeldown,
         yloc = yloc.abovebar)


plot(take_profit, color = color.blue, style = plot.style_cross)
plot(liquidation, color = color.yellow, style = plot.style_cross)

bgcolor(is_session_open(range_session) ? color.white : na, transp = 95)

color_green  = #4FC100
color_red    = #E50003
color_transp = color.new(color.white, 100)

get_color(values, min, max) =>
    i = abs(max - min) / 20
    result =
      values <= min + i * 1   ? #E50003 :
      values <= min + i * 2   ? #E30D00 :
      values <= min + i * 3   ? #E12100 :
      values <= min + i * 4   ? #DF3500 :
      values <= min + i * 5   ? #DD4800 :
      values <= min + i * 6   ? #DB5B00 :
      values <= min + i * 7   ? #D96E00 :
      values <= min + i * 8   ? #D78000 :
      values <= min + i * 9   ? #D59200 :
      values <= min + i * 10  ? #D3A400 :
      values <= min + i * 11  ? #D1B500 :
      values <= min + i * 12  ? #CFC600 :
      values <= min + i * 13  ? #C2CD00 :
      values <= min + i * 14  ? #AECB00 :
      values <= min + i * 15  ? #9AC900 :
      values <= min + i * 16  ? #87C700 :
      values <= min + i * 17  ? #74C500 :
      values <= min + i * 18  ? #61C300 :
      values <= min + i * 19  ? #4FC100 :
      #3DBF00

plot_trend_bot = plot(st_trend == trend_up ? st_trend_bot : na, color = color_green, linewidth = 1, transp = 50, style = plot.style_linebr)
plot_trend_top = plot(st_trend == trend_down ? st_trend_top : na, color = color_red, linewidth = 1, transp = 50, style = plot.style_linebr)
plot_mid = plot(ohlc4, color = color_transp)

fill(plot_mid, plot_trend_bot, color = color_green)
fill(plot_mid, plot_trend_top, color = color_red)

plot_jma_fast = plot(jma_fast, title="JMA Fast", linewidth = 1, color = get_color(jma_fast_slope, -2, 2), transp = 0)
plot_jma_slow = plot(jma_slow, title="JMA Slow", linewidth = 1, color = get_color(jma_slow_slope, -2, 2), transp = 0)

fill(plot_jma_fast, plot_jma_slow, color = get_color((jma_fast_slope + jma_slow_slope) / 2, -1, 1))

plot(range_high, title = "Range High", color = color_green, linewidth = 1, style = plot.style_cross)
plot(range_low, title = "Range Low", color = color_red, linewidth = 1, style = plot.style_cross)