// "Mystery Strategy Mark II" / "Holy Grail for ETH"
//
// Preconfigured for ETH 30m on Bitget
// Works on: ETH since 2022-12, AVAX since 2023-3
//
// (c) Stefan Reich
//@version=5

strategy(shorttitle="Stefan Reich's Mystery Strategy Mark II v15", title="Stefan Reich's Mystery Strategy Mark II", 
  overlay=true, 
  commission_type=strategy.commission.percent, commission_value=0.07,
  initial_capital = 100, default_qty_type=strategy.cash, default_qty_value=1000,
  calc_on_every_tick = true,
  max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500)

// commission_value is an approximately correct estimate for fees+spread on ETH on typical exchanges (Bitget, Bybit)
// This strategy opens few positions though, so fees+spread are not a big deal anyway.

startingDate = input.time(timestamp("8 Dec 2022"))
useEndDate = input.bool(false, tooltip="Activate the end date below")
endDate = input.time(timestamp("31 Dec 2023"), tooltip="When to end the backtest or execution (if checkbox above is set)")

enabledHoldSides = input.string(title="Hold side",  defval="Longs + Shorts", options=["Longs", "Shorts", "Longs + Shorts"])
doLongs=str.contains(enabledHoldSides, "Longs")
doShorts=str.contains(enabledHoldSides, "Shorts")

positionSize = input.float(1000, "Position size in $", tooltip="After leverage")
intraCandleOperation = input.bool(false, tooltip="Open or close trades within a candle")

hotSwitchOkay = input.bool(true, tooltip="Can we kill a long by opening a short and vice versa?")
macdType = input.string(title="MACD type", options=["Relative", "Absolute"], defval="Relative", tooltip="Relative=MACD normalized to asset price, Absolute=Normal MACD")
useRelativeMACD = macdType == "Relative"

switchOnLongsAbove = input.float(5, step=1, tooltip="Allow longs only if MACD is above this level")
switchOnShortsBelow = input.float(-5, step=1, tooltip="Allow shorts only if MACD is below this level")

enterThresholdLong = input.float(1, step=0.1, tooltip="MACD histogram value to enter a long at")
exitThresholdLong = input.float(-1, step=0.1, tooltip="MACD histogram value to exit a long at")
enterThresholdShort = input.float(-1, step=0.1, tooltip="MACD histogram value to enter a short at")
exitThresholdShort = input.float(1, step=0.1, tooltip="MACD histogram value to exit a short at")

// Layout options

arrowOffset = input.float(10, group="Layout")
initialOffset = input.float(10, group="Layout")
equityOffset = input.float(10, group="Layout")
topOffset = input.float(1, step=0.25, group="Layout")
filesSlanted = input.bool(true, group="Layout")
equityXOffset = input.int(10, tooltip="Move equity box to the right using this value", group="Layout")
equityShort = input.bool(true, tooltip="Show only the new equity, no text", group="Layout")
ieBoxColor = input.color(color.black, group="Layout")
ieTextColor = input.color(color.blue, group="Layout")

// UTILITY FUNCTIONS

drift() =>
    sumDrift = 0.0
    for tradeNo = 0 to strategy.opentrades - 1
        sumDrift += strategy.opentrades.size(tradeNo)
    result = sumDrift

// macro logFloat(value, title) { plotchar(value, title, "", location.top) }
    
// MACD inputs
fast_length = input(title="Fast Length", defval=25)
slow_length = input(title="Slow Length", defval=100)
macd_src = input(title="Source", defval=close)
signal_length = input.int(title="Signal Smoothing",  minval = 1, defval = 9)
sma_source = input.string(title="Oscillator MA Type",  defval="EMA", options=["SMA", "EMA"])
sma_signal = input.string(title="Signal Line MA Type", defval="EMA", options=["SMA", "EMA"])

// Add more inputs down here to not mess up configurations of older versions

// MACD calculation

fast_ma = sma_source == "SMA" ? ta.sma(macd_src, fast_length) : ta.ema(macd_src, fast_length)
slow_ma = sma_source == "SMA" ? ta.sma(macd_src, slow_length) : ta.ema(macd_src, slow_length)
macd = fast_ma - slow_ma
signal = sma_signal == "SMA" ? ta.sma(macd, signal_length) : ta.ema(macd, signal_length)
hist = macd - signal

// Plot MACD
plot(fast_ma, title="MACD Fast MA", color=color.yellow)
plot(slow_ma, title="MACD Slow MA", color=color.blue)
plotchar(macd, "MACD", "", location.top)

// Relative MACD values (in preparation for Mark II strategy)
factor = 1000 / slow_ma
relMACD = macd * factor
relSignal = signal * factor
relHist = (macd - signal) * factor

plotchar(relMACD, "Relative MACD", "", location.top) // logFloat
plotchar(hist, "MACD Histogram", "", location.top) // logFloat
plotchar(relHist, "Relative MACD Histogram", "", location.top) // logFloat

macdToUse = useRelativeMACD ? relMACD : macd
histToUse = useRelativeMACD ? relHist : hist

if time >= startingDate and (not useEndDate or time <= endDate) and (intraCandleOperation or barstate.isconfirmed)
    qty = positionSize/close

    if drift() < 0.0 and histToUse >= exitThresholdShort
        strategy.close_all("MACD Green")
    else if drift() > 0.0 and histToUse <= exitThresholdLong
        strategy.close_all("MACD Red")

    if hotSwitchOkay or drift() == 0.0
        if doLongs and histToUse >= enterThresholdLong and macdToUse >= switchOnLongsAbove
            strategy.entry("Long", strategy.long, qty=qty)
        else if doShorts and histToUse <= enterThresholdShort and macdToUse <= switchOnShortsBelow
            strategy.entry("Short", strategy.short, qty=qty)

// PAINT TRADES & INITIAL EQUITY

plusMinusFix(s) =>
    currency = " $"
    str.startswith(s, "-") ? "-" + currency + str.substring(s, 1) : "+" + currency + s

formatProfit(profit) =>
    plusMinusFix(str.tostring(profit, "#,##0.00"))

var int tradesPainted = 0
var label initialEquityLabel = na

if na(initialEquityLabel) and time >= startingDate
    ieText = "⬆\nWe invest\n$" + str.tostring(strategy.initial_capital, "#,##0") + "\nand start\nthe strategy!"
    ieTime = startingDate-2*24*60*60*1000 // 2 days back
    //ieY = close*(1-arrowOffset/100) // for style_label_center
    //style=label.style_label_center
    ieY = close*(1-initialOffset/100) // for style_label_up
    //boxColor = color.black
    //textColor = color.white
    style = label.style_label_up
    //style = label.style_triangleup
    initialEquityLabel := label.new(ieTime, ieY, ieText, xloc=xloc.bar_time, color=ieBoxColor, textcolor=ieTextColor, tooltip="Initial equity", size=size.huge, style=style)

type PaintedTrade
    array<line> lines
    array<label> labels

drawTrade(bar1, bar2, price1, price2, profit, open, long) =>
    t = PaintedTrade.new()
    t.lines := array.new<line>()
    t.labels := array.new<label>()
    totalProfit = strategy.equity // -strategy.initial_capital
    //line.new(bar1, price1, bar2, price2, xloc=xloc.bar_index, width = 10, color=color.black, style=line.style_arrow_right)
    float y1 = price1*(1-arrowOffset/100)
    float y2 = price2*(1-arrowOffset/100)
    float top1 = price1*(1-topOffset/100)
    float top2 = (open ? math.min(price2, low) : price2)*(1-topOffset/100)
    color_solid = profit > 0 ? color.lime : color.red
    color = color.new(color_solid, 50)

    if not filesSlanted
        y1 := math.min(y1, y2)
        y2 := y1

    array.push(t.lines, line.new(bar1, top1, bar1, y1, color=color, width=3))
    array.push(t.lines, line.new(bar2, top2, bar2, y2, color=color, width=3))
    array.push(t.lines, line.new(bar1, y1, bar2, y2, xloc=xloc.bar_index, width = 10, color=color)) //, style=line.style_arrow_right)

    ypos = 0.6
    string profitText = formatProfit(profit)
    yPrice = (price1+price2)/2
    yBottom = (y1+y2)/2
    yText = yPrice*(1-ypos)+yBottom*ypos
    priceTooltip = "This " + (long ? "long" : "short") + " trade " + (str.startswith(profitText, "+") ? "made" : "lost") + " " + profitText
    if open
        profitText := "OPEN TRADE. " + str.replace(profitText, " $", "$")
    array.push(t.labels, label.new((bar1+bar2)/2, yText, profitText, textcolor=color.new(color_solid, 25), color=color.black, style=label.style_text_outline, size=size.huge, tooltip=priceTooltip))

    // TODO: Show current equity even if there is no open trade
    if not na(totalProfit)
        //totalProfitText = "Total: " + formatProfit(totalProfit)
        //totalProfitText = plusMinusFix(str.tostring(math.round(totalProfit)))
        amount = "$" + str.tostring(totalProfit, "#,##0")
        //totalProfitText = "⇒ " + amount
        string format = na
        if open
            format := "Current\nequity:\n\n*"
        else if equityShort
            format := "*"
        else if profit <= 0
            format := "*\nleft"
        else if tradesPainted > 1
            format := "Now we\nhave\n*"
        else
            format := "Now we\nhave\n*."
        totalProfitText = str.replace(format, "*", amount)
        totalColor = totalProfit > 0 ? color.lime : color.orange
        //yTotal = yBottom+(yBottom-yText)*4
        float yTotal = y2
        //xTotal = (bar1+bar2)/2
        int xTotal = bar2+(open ? equityXOffset : 4)
        days = math.round((time-startingDate)/1000.0/60/60/24+1)
        tooltip = "New total equity (started with $" + str.tostring(strategy.initial_capital, "#,##0") + " - " + str.tostring(days) + " " + (days == 1 ? "day" : "days") + " ago)"
        string style = label.style_label_left
        string size = size.large
        if open
            style := label.style_label_center
            xTotal := xTotal+15
            yTotal := price2*(1-equityOffset/100)
            size := size.huge
        array.push(t.labels, label.new(xTotal, yTotal, totalProfitText, textcolor=color.new(totalColor, 25), style=style, color=color.black, size=size, tooltip=tooltip))

    t

method delete(PaintedTrade this) =>
    for line in this.lines
        line.delete(line)
    for lbl in this.labels
        label.delete(lbl)

while tradesPainted < strategy.closedtrades
    bar1 = strategy.closedtrades.entry_bar_index(tradesPainted)
    bar2 = strategy.closedtrades.exit_bar_index(tradesPainted)
    price1 = strategy.closedtrades.entry_price(tradesPainted)
    price2 = strategy.closedtrades.exit_price(tradesPainted)
    //direction = strategy.closedtrades.size(tradesPainted)
    profit = strategy.closedtrades.profit(tradesPainted)
    long = strategy.closedtrades.size(tradesPainted) > 0
    drawTrade(bar1, bar2, price1, price2, profit, false, long)
    tradesPainted := tradesPainted+1

var PaintedTrade openTrade = na
var label macdLabel = na

if not barstate.ishistory
    if not na(openTrade)
        openTrade.delete()

    if strategy.opentrades != 0
        bar1 = strategy.opentrades.entry_bar_index(0)
        bar2 = bar_index
        price1 = strategy.opentrades.entry_price(0)
        price2 = close
        profit = strategy.opentrades.profit(0)
        long = strategy.opentrades.size(0) > 0
        openTrade := drawTrade(bar1, bar2, price1, price2, profit, true, long)

    // Show/update floating MACD value

    if not na(macdLabel)
        label.delete(macdLabel)
    macdValue = str.tostring(histToUse, "0.0#")
    lowerBound = enterThresholdShort
    upperBound = enterThresholdLong
    macdPercent = (histToUse-lowerBound)/(upperBound-lowerBound)*100
    percentText = str.tostring(macdPercent, "0") + "%"
    tooltip = "MACD value: " + macdValue + " (" + percentText + " between close and open)"
    macdColor = macdPercent >= 0 and macdPercent <= 100 ? color.blue : color.yellow
    macdLabel := label.new(bar_index, close, percentText, tooltip=tooltip, yloc=yloc.abovebar, textcolor=macdColor, color=color.black, style=label.style_text_outline, size=size.large)

// Show unrealized P&L in data window

unrealizedPnL = strategy.opentrades == 0 ? na : strategy.opentrades.profit(0)
plotchar(unrealizedPnL, "Unrealized P&L", "")

// Record max drawdown of winning trades

var float drawdownInTrade = 0
var int tradesClosed = 0
var float maxDrawdown = 0
if not na(unrealizedPnL)
    drawdownInTrade := math.max(0, -unrealizedPnL, drawdownInTrade)

if tradesClosed < strategy.closedtrades
    profit = strategy.closedtrades.profit(tradesClosed)
    if profit > 0
        maxDrawdown := math.max(maxDrawdown, drawdownInTrade)
    drawdownInTrade := 0
    tradesClosed := strategy.closedtrades

plotchar(maxDrawdown, "Max drawdown in a winning trade", "")