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

strategy(title="Dynamic DCA Grid", shorttitle="DDcaG", initial_capital=1000, overlay=true)

sleepingHoursValue = input(title="Sleeping Hours (0400-1700) UTC", defval="0400-1700")
sleepingHours = time(timeframe.period, sleepingHoursValue)
bgcolor(not na(sleepingHours) ? color.green : na)



CloseSource = input(title="CloseSource", type=input.source, defval=close)
openSrc = input(title="OpenSource", type=input.source, defval=open)
studyLength = input(title="Study Length (3602h-7201h)", defval=360)

get_high_average() =>
    firstValue = openSrc[1]
    highestValue = 0.0
    for n = 2 to studyLength
        if openSrc[n] > highestValue
            highestValue := openSrc[n]
            
    highestValue
    
get_low_average() =>
    firstValue = CloseSource[1]
    lowestValue = 0.0
    for n = 2 to studyLength
        if CloseSource[n] < lowestValue
            lowestValue := CloseSource[n]
            
    lowestValue
    
avg_of_indv = avg(openSrc[1], openSrc[1])
tenpercent = round(openSrc[1]/(get_high_average()/10))*(get_high_average()/10)
get_average(avg_src, avg_len) =>
    ret_val = 0.0
    for i = 1 to avg_len
        ret_val := ret_val + avg_src[i]
    ret_val/avg_len

avg_of_func = ema(openSrc, 16)
avg_of_func2 = get_average(openSrc, 20)
super_high_average = get_high_average()
super_low_average = get_low_average()

volPercent = input(17, "Percent Volatility Length")
Difference = ((close - open)/((close + open)/2) * 100)
MovingAverage2 = sma(Difference, volPercent)
percentChange = MovingAverage2

smProfitPercent = input(title="% SM Profit", defval=0.24)
smProfit = (volPercent*smProfitPercent/100)

smLongPercent = input(title="% SM Long", defval=0.47)
smLong = (volPercent*smLongPercent)/100

mdLongPercent = input(title="% MD Long", defval=0.8)
mdLong = (volPercent*mdLongPercent)/100

lgLong = volPercent/100


lgmdLong = avg(lgLong,mdLong)

plot(avg_of_func,offset=5)
plot(super_high_average, color=color.red, linewidth=2)
plot(super_high_average-(super_high_average*smProfit), color=color.red, linewidth=1)
plot(super_high_average-(super_high_average*smLong), color=color.green, linewidth=1)
plot(super_high_average-(super_high_average*mdLong), color=color.green, linewidth=1)
plot(super_high_average-(super_high_average*lgLong), color=color.green, linewidth=2)

startDate = input(timestamp("2021-01-01T00:00:00"), type = input.time)
endDate = input(timestamp("2021-01-31T00:00:00"), type = input.time)

asd = time >= startDate and time <= endDate



smAmount = input(10, "SM Amount")/10
mdAmount = input(10, "MD Amount")/10
lgAmount = input(10, "LG Amount")/10

smAmountReal = (smAmount*100)/close/10
mdAmountReal = (mdAmount*100)/close/10
lgAmountReal = (lgAmount*100)/close/10

smOpenLong = asd and crossunder(hl2,super_high_average-(super_high_average*smLong))
smCloseLong = asd and cross(close, super_high_average-(super_high_average*(smProfit)))
smCloseLong2 = asd and cross(close, super_high_average)

mdOpenLong = asd and crossunder(hl2,super_high_average-(super_high_average*mdLong))
mdCloseLong = asd and cross(close, super_high_average-(super_high_average*(smProfit)))
mdCloseLong2 = asd and cross(close, super_high_average)

lgOpenLong = asd and crossunder(hl2, super_high_average-(super_high_average*lgLong))
lgCloseLong = asd and cross(close, super_high_average-(super_high_average*(smLong)))
lgCloseLong2 = asd and cross(close, super_high_average)

smPos = 0
p1 = close / 100 / syminfo.mintick

//if barssince(mdOpenLong) < 5

strategy.order("smLong", strategy.long, smAmountReal, when = smOpenLong)
strategy.order("smLong2", strategy.long, smAmountReal, when = smOpenLong)
strategy.close("smLong", when = smCloseLong)
strategy.close("smLong2", when = smCloseLong2)
alertcondition(smOpenLong, "SM Buy {{ticker}}", "{{ticker}}, price = {{close}}")
alertcondition(smCloseLong, "SM Sell 1 {{ticker}}", "{{ticker}}, price = {{close}}")
alertcondition(smCloseLong2, "SM Sell 2 {{ticker}}", "{{ticker}}, price = {{close}}")

strategy.order("mdLong", strategy.long, mdAmountReal, when = mdOpenLong)
strategy.order("mdLong2", strategy.long, mdAmountReal, when = mdOpenLong)
strategy.close("mdLong", when = mdCloseLong)
strategy.close("mdLong2", when = mdCloseLong2)
alertcondition(mdOpenLong, "MD Buy {{ticker}}", "{{ticker}}, price = {{close}}")
alertcondition(mdCloseLong, "MD Sell 1 {{ticker}}", "{{ticker}}, price = {{close}}")
alertcondition(mdCloseLong2, "MD Sell 2 {{ticker}}", "{{ticker}}, price = {{close}}")

strategy.order("lgLong", strategy.long, lgAmountReal, when = lgOpenLong)
strategy.order("lgLong2", strategy.long, lgAmountReal, when = lgOpenLong)
strategy.close("lgLong", when = lgCloseLong)
strategy.close("lgLong2", when = lgCloseLong2)
alertcondition(lgOpenLong, "LG Buy {{ticker}}", "{{ticker}}, price = {{close}}")
alertcondition(lgCloseLong, "MD Sell 1 {{ticker}}", "{{ticker}}, price = {{close}}")
alertcondition(lgCloseLong2, "MD Sell 2 {{ticker}}", "{{ticker}}, price = {{close}}")

    
//strategy.exit("TP1", "smLong", profit = smLongPercent/10 * p1, qty_percent = 50)
//strategy.exit("TP2", "smLong", profit = volPercent/10 * p1, qty_percent = 50)

//strategy.exit("TP1.0", "mdLong", profit = mdLongPercent/10 * p1, qty_percent = 50)
//strategy.exit("TP2.0", "mdLong", profit = volPercent/10 * p1, qty_percent = 50)

//strategy.exit("TP1.00", "lgLong", profit = mdLongPercent/10 * p1, qty_percent = 50)
//strategy.exit("TP2.00", "lgLong", profit = volPercent/10 * p1, qty_percent = 50)