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

//@version=5
strategy("Ionut MTF V2", overlay = true, max_bars_back = 5000, max_boxes_count = 5000, max_labels_count = 500)

htf = input.timeframe(defval = "1", title = "HTF")
show_snd = input.bool(defval = true, title = "Show HTF SnDs")
show_ltf = input.bool(defval = true, title = "Show LTF Levels")
show_htf = input.bool(defval = true, title = "Show HTF Levels")
show_market_structure = input.bool(defval = true, title = "Show HTF Market Structure")

type SND
    int   index1
    int   index2
    float price1
    float price2
    bool bearish
    int break_index
    int time1
    int time2

//******************    High and Low Levels Formation       ******************    
opposite_level_low(open_, high_, low_, close_, bar_index_) =>
    bi = 0
    s = array.size(open_)
    for i = 0 to s-2
        if (array.get(open_,i) < array.get(low_, i+1)) or (array.get(close_,i) < array.get(low_, i+1))
            bi := array.get(bar_index_, i)
            break
    if array.get(bar_index_, 0) > 5
        lowest = 999999.0
        lowest_barindex = 0
        for i = 0 to (array.get(bar_index_, 0) - bi)
            lowest := math.min(lowest, array.get(low_, i))
            if array.get(low_, i) <= lowest
                lowest_barindex := array.get(bar_index_, i)
        [lowest, lowest_barindex]
    else 
        [0, array.get(bar_index_, 0)]
opposite_level_high(open_, high_, low_, close_, bar_index_) =>
    bi = 0
    s = array.size(open_)
    for i = 0 to s-2
        if (array.get(open_,i) > array.get(high_, i+1)) or (array.get(close_,i) > array.get(high_, i+1))
            bi := array.get(bar_index_, i)
            break
    
    if array.get(bar_index_, 0) > 5
        highest = 0.0
        highest_barindex = 0
        for i = 0 to (array.get(bar_index_, 0) - bi)
            highest := math.max(highest,array.get(high_, i))
            if array.get(high_, i) >= highest
                highest_barindex := array.get(bar_index_, i)
        [highest, highest_barindex]
    else 
        [0, array.get(bar_index_, 0)]

mitigation_bullish(open_, high_, low_, close_, bar_index_, index) =>
    found = false 
    found_index = index
    if index < array.get(bar_index_, 0) - 1
        for j = index  to (array.get(bar_index_, 0))
            if array.get(bar_index_, 0) - j < 0 
                break
            if not found
                snd_high = array.get(high_ , array.get(bar_index_, 0) - j)
                snd_low = array.get(low_, array.get(bar_index_, 0) - j)
                for i = j + 1  to (array.get(bar_index_, 0))
                    if array.get(bar_index_, 0) - i - 1 < 0 
                        break
                    if array.get(high_, array.get(bar_index_, 0) - i) <= snd_high and array.get(low_, array.get(bar_index_, 0) -i) >= snd_low 
                        continue
                    if array.get(close_, array.get(bar_index_, 0) -i) > snd_high and array.get(low_, array.get(bar_index_, 0) - i -1) > snd_high
                        cond = true
                        for k = i + 2 to array.get(bar_index_, 0)
                            if array.get(bar_index_, 0) - k >= 0 
                                if array.get(low_, array.get(bar_index_, 0) - k)<= snd_high 
                                    cond := false
                        if cond
                            found := true 
                            found_index := j
                    break
    [found_index, found]

mitigation_bearish(open_, high_, low_, close_, bar_index_, index) =>
    found = false 
    found_index = index
    if index < array.get(bar_index_, 0) - 1
        for j = index to (array.get(bar_index_, 0))
            if array.get(bar_index_, 0) - j < 0 
                break
            if not found
                snd_high = array.get(high_, array.get(bar_index_, 0) - j)
                snd_low = array.get(low_,array.get(bar_index_, 0) - j)
                for i = j + 1  to (array.get(bar_index_, 0))
                    if array.get(bar_index_, 0) - i - 1 < 0 
                        break
                    if array.get(high_,array.get(bar_index_, 0) - i) <= snd_high and array.get(low_,array.get(bar_index_, 0) -i) >= snd_low 
                        continue
                    if array.get(close_,array.get(bar_index_, 0) -i) < snd_low and array.get(high_,array.get(bar_index_, 0) - i -1) < snd_low
                        cond = true 
                        for k = i + 2 to array.get(bar_index_, 0)
                            if array.get(bar_index_, 0) - k >= 0 
                                if array.get(high_,array.get(bar_index_, 0) - k) >= snd_low 
                                    cond := false 
                        if cond
                            found := true 
                            found_index := j
                    break
    [found_index, found]


main(show, open_array, high_array, low_array, close_array, barindex_array, time_array, update) =>
    open_ = array.get(open_array, 0)
    low_ = array.get(low_array, 0)
    high_ = array.get(high_array, 0)
    close_ = array.get(close_array, 0)
    bar_index_ = array.get(barindex_array, 0)
    if array.size(close_array) > 100
        
        var state = "bearish"
        var l = low_ 
        var h = high_ 
        [opposite_high, opposite_high_index] = opposite_level_high(open_array, high_array, low_array, close_array, barindex_array)
        [opposite_low, opposite_low_index] = opposite_level_low(open_array, high_array, low_array, close_array, barindex_array)
        if state == "bearish" and bar_index_ > 5
            if close_ < l or open_ < l
                h := opposite_high
                l := math.min(l, low_) 
            if array.get(low_array, 1) != array.get(low_array, 2)
                l := math.min(l, low_) 
            if close_ > h or open_ > h 
                h := high_
                state := "bullish"
                l := opposite_low
        if state == "bullish" and bar_index_ > 10
            if close_ > h or open_ > h
                l := opposite_low
                h := math.max(h, high_) 
            if array.get(high_array, 1) != array.get(high_array, 2)
                h := math.max(h, high_) 
            if close_ < l or open_ < l 
                l := low_
                state := "bearish"
                h := opposite_high

        // Boxes Labelling 
        var boxes_labels = array.new<label>(0)

        var market_state = "none" // can be bullish or bearish or none 
        var bullish_snd_count = 0 
        var bearish_snd_count = 0
        bullish_trade = false 
        bearish_trade = false 

        var snds = array.new<SND>(0)
        var unique_snds = array.new<SND>(0)
        var snds_boxes = array.new<box>(0)
        [bullish_index, bullish_found] = mitigation_bullish(open_array, high_array, low_array, close_array, barindex_array, opposite_low_index)
        [bearish_index, bearish_found] = mitigation_bearish(open_array, high_array, low_array, close_array, barindex_array, opposite_high_index)
        if bar_index_ > 10
            if ((l[0] != l[1]) or (h[0] != h[1])) 
                snd = SND.new(index1= bar_index_, index2 = bar_index_+3, price1 = low_, price2 = high_, bearish = state=="bearish", break_index = bar_index_, time1=time, time2=time)
                if state == "bearish"
                    snd.index1 := bearish_index
                    snd.index2 := bar_index_
                    snd.time1 := array.get(time_array,bar_index_ - bearish_index)
                    snd.time2 := array.get(time_array, 0)
                    if bearish_found
                        snd.price1 := array.get(low_array, bar_index_ - bearish_index)
                        snd.price2 := array.get(high_array, bar_index_ - bearish_index)
                    else 
                        snd.price1 := math.max(array.get(close_array ,bar_index_ - bearish_index), array.get(open_array,bar_index_ - bearish_index))
                        snd.price2 := array.get(high_array, bar_index_ - bearish_index)
                else
                    snd.index1 := bullish_index
                    snd.index2 := bar_index_
                    snd.time1 := array.get(time_array, bar_index_ - bullish_index)
                    snd.time2 := array.get(time_array, 0)
                    if bullish_found
                        snd.price1 := array.get(low_array, bar_index_ - bullish_index)
                        snd.price2 := array.get(high_array, bar_index_ - bullish_index)
                    else 
                        snd.price1 := array.get(low_array ,bar_index_ - bullish_index)
                        snd.price2 := math.min(array.get(close_array ,bar_index_ - bullish_index), array.get(open_array, bar_index_ - bullish_index))

                // we need to log two infromation here, the index of the SND and last bar that caused change in snd in same direction 
                if array.size(snds) > 0
                    last_snd = array.get(snds, array.size(snds) -1)
                    if snd.index1 < last_snd.break_index
                        array.pop(snds)
                
                if snd.time1 != array.get(time_array, 0)
                    array.push(snds, snd)
                

            if array.size(snds) > 0 
                snd_last = array.get(snds, array.size(snds) - 1)
                snd_last.index2 := bar_index_
                snd_last.time2 := time

            while snds.size() > 100
                array.remove(snds, 0)

            while unique_snds.size() > 100
                array.remove(unique_snds, 0)

            while not (snds_boxes.size() == 0)
                snd_box = snds_boxes.pop()
                box.delete(snd_box)

            if snds.size() > 0 
                for i = 1 to snds.size()
                    snd = array.get(snds, i-1)
                    box_color = snd.bearish ? color.new(color.red, 90) : color.new(color.green, 90)
                    if show
                        snd_box = box.new(snd.time1, snd.price1, snd.time2, snd.price2, xloc=xloc.bar_time, bgcolor = box_color, border_style=line.style_solid, border_color = color.black)
                        array.push(snds_boxes, snd_box)
            

            // Analyze SNDS and Market Strucutre 
            if array.size(snds) > 0 
                last_snd = array.get(snds, array.size(snds) - 1)
                new_unique = false 
                if array.size(unique_snds) == 0 
                    unique_snds.push(last_snd)
                    new_unique := true 
                else 
                    last_unique_snd = array.get(unique_snds, array.size(unique_snds)-1)
                    if not(last_unique_snd.price1 == last_snd.price1 and last_unique_snd.price2 == last_snd.price2) 
                        if math.abs(last_snd.index1 - last_unique_snd.index1) > 2
                            array.push(unique_snds, last_snd)
                            new_unique := true 
                        else 
                            array.pop(unique_snds)
                            array.push(unique_snds, last_snd)

                if new_unique
                    bool previous_bearish = na 
                    if array.size(unique_snds) > 1
                        prev_snd = array.get(unique_snds, array.size(unique_snds) -2)
                        previous_bearish := prev_snd.bearish
                    if array.size(unique_snds) > 0
                        l_snd = array.get(unique_snds, array.size(unique_snds) -1)
                        if na(previous_bearish) and l_snd.bearish
                            bearish_snd_count := 1 
                            bullish_snd_count := 0 
                        else if na(previous_bearish) and not l_snd.bearish
                            bullish_snd_count := 1 
                            bearish_snd_count := 0
                        else if l_snd.bearish and previous_bearish
                            bearish_snd_count += 1 
                            bullish_snd_count := 0
                        else if not l_snd.bearish and not previous_bearish
                            bullish_snd_count += 1
                            bearish_snd_count := 0
                        else if l_snd.bearish and not previous_bearish
                            bullish_snd_count := 0
                            bearish_snd_count := 1 
                        else if not l_snd.bearish and previous_bearish
                            bullish_snd_count := 1
                            bearish_snd_count := 0


                        if array.size(unique_snds) >= 3
                            snd1 = array.get(unique_snds, array.size(unique_snds) - 3)
                            snd2 = array.get(unique_snds, array.size(unique_snds) - 2)
                            snd3 = array.get(unique_snds, array.size(unique_snds) - 1)
                            if snd1.bearish and not snd2.bearish and snd3.bearish and market_state == "bullish"
                                market_state := "none"
                            if not snd1.bearish and snd2.bearish and not snd3.bearish and market_state == "bearish"
                                market_state := "none"
                        
                        if array.size(unique_snds) >= 4
                            snd1 = array.get(unique_snds, array.size(unique_snds) - 4)
                            snd2 = array.get(unique_snds, array.size(unique_snds) - 3)
                            snd3 = array.get(unique_snds, array.size(unique_snds) - 2)
                            snd4 = array.get(unique_snds, array.size(unique_snds) - 1)
                            if snd1.bearish and not snd2.bearish and not snd3.bearish and snd4.bearish and market_state == "bullish"
                                market_state := "none"
                            if not snd1.bearish and snd2.bearish and snd3.bearish and not snd4.bearish and market_state == "bearish"
                                market_state := "none"

                        if market_state == "none" and bullish_snd_count >= 3
                            market_state := "bullish"
                        if market_state == "bearish" and bullish_snd_count >= 4 
                            market_state := "bullish"
                        if market_state == "none" and bearish_snd_count >= 3
                            market_state := "bearish"
                        if market_state == "bullish" and bearish_snd_count >= 4 
                            market_state := "bearish"
        [l, h , market_state, unique_snds, bearish_snd_count, bullish_snd_count]
    else
        [na, na , "", na, na, na]
// ****************
l_ht = 0.0
h_ht = 0.0
market_state_ht = ""
var snds_htf = array.new<SND>()
bearish_snd_count_htf = 0.0
bullish_snd_count_htf = 0.0

l_lt = 0.0
h_lt = 0.0
market_state_lt = ""
var snds_ltf = array.new<SND>()
bearish_snd_count_ltf = 0.0 
bullish_snd_count_ltf = 0.0

close_htf = request.security(syminfo.tickerid, htf, close[1], gaps = barmerge.gaps_on)
open_htf = request.security(syminfo.tickerid, htf, open[1], gaps = barmerge.gaps_on)
high_htf = request.security(syminfo.tickerid, htf, high[1], gaps = barmerge.gaps_on)
low_htf =  request.security(syminfo.tickerid, htf, low[1], gaps = barmerge.gaps_on)
barindex_htf = request.security(syminfo.tickerid, htf, bar_index[1], gaps = barmerge.gaps_on)
time_htf = request.security(syminfo.tickerid, htf, time[1], gaps = barmerge.gaps_on)

if barstate.isconfirmed
    // prepare higher TF Data
    var htf_bar_time = 0
    var close_array_htf = array.new<float>(0)
    var open_array_htf = array.new<float>(0)
    var high_array_htf = array.new<float>(0)
    var low_array_htf = array.new<float>(0)
    var barindex_array_htf = array.new<int>(0)
    var time_array_htf = array.new<int>(0)

    if array.size(time_array_htf) > 1 
        htf_bar_time := math.abs(array.get(time_array_htf, 0 ) - array.get(time_array_htf, 1 ))
    update = false
    if not na(close_htf)
        array.insert(close_array_htf, 0, close_htf)
        array.insert(open_array_htf, 0, open_htf)
        array.insert(high_array_htf, 0, high_htf)
        array.insert(low_array_htf, 0, low_htf)
        array.insert(barindex_array_htf, 0, barindex_htf)
        array.insert(time_array_htf, 0, time_htf)
        update := true
    htf_size = array.size(time_array_htf)
    if array.size(close_array_htf) > 1000
        array.pop(close_array_htf)
    if array.size(open_array_htf) > 1000
        array.pop(open_array_htf)
    if array.size(high_array_htf) > 1000
        array.pop(high_array_htf)
    if array.size(low_array_htf) > 1000
        array.pop(low_array_htf)
    if array.size(barindex_array_htf) > 1000
        array.pop(barindex_array_htf)
    if array.size(time_array_htf) > 1000 
        array.pop(time_array_htf)


    [l_ht2, h_ht2, market_state_ht2, snds_htf2, bearish_snd_count_htf2, bullish_snd_count_htf2] = main(show_snd, open_array_htf, high_array_htf, low_array_htf, close_array_htf, barindex_array_htf, time_array_htf, update)
    
    if update
        l_ht := l_ht2
        h_ht := h_ht2
        market_state_ht := market_state_ht2
        snds_htf := snds_htf2
        bearish_snd_count_htf := bearish_snd_count_htf2
        bullish_snd_count_htf := bullish_snd_count_htf2
        //alert("bars")
        //alert(str.tostring(array.get(open_array_htf, 0)), alert.freq_all)
        //alert(str.tostring(array.get(high_array_htf, 0)), alert.freq_all)
        //alert(str.tostring(array.get(low_array_htf, 0)), alert.freq_all)
        //alert(str.tostring(array.get(close_array_htf, 0)), alert.freq_all)
    else 
        
        l_ht := l_ht[1]
        h_ht := h_ht[1]
        market_state_ht := market_state_ht[1]
        bearish_snd_count_htf := bearish_snd_count_htf[1]
        bullish_snd_count_htf := bullish_snd_count_htf[1]

   


    // prepare lower TF Data
    var close_array_ltf = array.new<float>(0)
    var open_array_ltf = array.new<float>(0)
    var high_array_ltf = array.new<float>(0)
    var low_array_ltf = array.new<float>(0)
    var barindex_array_ltf = array.new<int>(0)
    var time_array_ltf = array.new<int>(0)
    array.insert(close_array_ltf, 0, close)
    array.insert(open_array_ltf, 0, open)
    array.insert(high_array_ltf, 0, high)
    array.insert(low_array_ltf, 0, low)
    array.insert(barindex_array_ltf, 0, bar_index)
    array.insert(time_array_ltf, 0, time)
    if array.size(close_array_ltf) > 1000
        array.pop(close_array_ltf)
    if array.size(open_array_ltf) > 1000
        array.pop(open_array_ltf)
    if array.size(high_array_ltf) > 1000
        array.pop(high_array_ltf)
    if array.size(low_array_ltf) > 1000
        array.pop(low_array_ltf)
    if array.size(barindex_array_ltf) > 1000
        array.pop(barindex_array_ltf)
    if array.size(time_array_ltf) > 1000 
        array.pop(time_array_ltf)
    [l_lt2, h_lt2, market_state_lt2, snds_ltf2, bearish_snd_count_ltf2, bullish_snd_count_ltf2] = main(false, open_array_ltf, high_array_ltf, low_array_ltf, close_array_ltf, barindex_array_ltf, time_array_ltf, true)
    l_lt := l_lt2
    h_lt := h_lt2
    market_state_lt := market_state_lt2
    snds_ltf := snds_ltf2
    bearish_snd_count_ltf := bearish_snd_count_ltf2
    bullish_snd_count_ltf := bullish_snd_count_ltf2



    // Strategy Logic 
    // fetch the latest snds to check for
    var last_tp = 0.0
    SND last_bullish_snd = na
    SND last_bearish_snd = na
    var state_bearish = 0 
    var state_bullish = 0 
    var last_snd_bullish_p = 0.0
    var last_snd_bearish_p = 0.0
    var black_list = map.new<int, bool>()
    var trade_breakeven = false 
    var last_entry_time = 0
    if not na(snds_htf) and not na(snds_ltf)
        if array.size(snds_htf) > 0 and array.size(snds_ltf) > 0
            for i = 0 to array.size(snds_htf) - 1
                snd = array.get(snds_htf, array.size(snds_htf) - 1 - i)
                if map.contains(black_list, snd.time1) and snd.bearish
                    break
                if na(last_bearish_snd) and snd.bearish 
                    last_bearish_snd := snd 
                    break
            for i = 0 to array.size(snds_htf) - 1
                snd = array.get(snds_htf, array.size(snds_htf) - 1 - i)
                if map.contains(black_list, snd.time1) and not snd.bearish
                    break
                if na(last_bullish_snd) and not snd.bearish 
                    last_bullish_snd := snd 
                    break

            // bullish trade 
            if na(last_bullish_snd) or market_state_ht != "bullish"
                state_bullish := 0
            if state_bullish == 0 
                strategy.cancel("long")
            if state_bullish == 0 and not na(last_bullish_snd)
                if close >= last_bullish_snd.price1 and close <= last_bullish_snd.price2 and last_bullish_snd.time2 >= array.get(time_array_htf, array.size(time_array_htf) - 1) and bullish_snd_count_htf <= 5 and market_state_ht == "bullish"  and time <= last_bullish_snd.time2
                    state_bullish := 1
            if state_bullish == 1 and h_lt[1] > h_lt[2] and high < h_lt[0] and not na(last_bullish_snd)
                mid_snd = (last_bullish_snd.price1 + last_bullish_snd.price2) / 2.0 
                stop_loss_price = h_lt - 0.00015 - 0.00001
                take_profit_price = h_lt + 4 * 0.00015 + 0.00001
                if stop_loss_price <= mid_snd and strategy.position_size == 0
                    trade_breakeven := false 
                    last_entry_time := last_bullish_snd.time1
                    strategy.entry("long", strategy.long, stop = h_lt+ 0.00001) 
                    strategy.exit("exit2", "long", limit = take_profit_price, stop =stop_loss_price)
                    last_tp := take_profit_price
            if close < l_lt[1]
                state_bullish := 1
                strategy.cancel("long")
            if (state_bullish == 1 or state_bullish == 2) and htf_size != htf_size[1] and not na(last_bullish_snd)
                bar_close = array.get(close_array_htf, 0)
                if  bar_close < last_bullish_snd.price1
                    state_bullish := 0 
                    map.put(black_list, last_bullish_snd.time1 , true)




            // bearish trade 
            if na(last_bearish_snd) or market_state_ht != "bearish"
                state_bearish := 0
            if state_bearish == 0 
                strategy.cancel("short")
            if state_bearish == 0 and not na(last_bearish_snd)
                if close >= last_bearish_snd.price1 and close <= last_bearish_snd.price2 and last_bearish_snd.time2 >= array.get(time_array_htf, array.size(time_array_htf) - 1) and bearish_snd_count_htf <= 5 and market_state_ht == "bearish" and time <= last_bearish_snd.time2
                    state_bearish := 1
            if state_bearish == 1 and l_lt[1] < l_lt[2] and low > l_lt[0] and not na(last_bearish_snd)
                mid_snd = (last_bearish_snd.price1 + last_bearish_snd.price2) / 2.0 
                stop_loss_price = l_lt + 0.00015+ 0.00001
                take_profit_price = l_lt - 4 * 0.00015- 0.00001
                if stop_loss_price >= mid_snd and strategy.position_size == 0
                    last_tp := take_profit_price
                    trade_breakeven := false 
                    last_entry_time := last_bearish_snd.time1
                    strategy.entry("short", strategy.short, stop = l_lt - 0.00001)
                    strategy.exit("exit", "short", limit = take_profit_price, stop = stop_loss_price)
            if close > h_lt[1]
                state_bearish := 1
                strategy.cancel("short")
            if (state_bearish == 1 or state_bearish == 2) and htf_size != htf_size[1] and not na(last_bearish_snd)
                bar_close = array.get(close_array_htf, 0)
                if bar_close > last_bearish_snd.price2 
                    state_bearish := 0 
                    map.put(black_list, last_bearish_snd.time1 , true)

            // limit SnD Trades 
            var snds_be = map.new<int, int>()

            if strategy.losstrades > strategy.losstrades[1] and not trade_breakeven
                map.put(black_list, last_entry_time , true)

            if strategy.closedtrades > strategy.closedtrades[1] and trade_breakeven
                if map.contains(snds_be,last_entry_time)
                    num = map.get(snds_be,last_entry_time)
                    map.put(snds_be,last_entry_time,num+1)
                else 
                    map.put(snds_be,last_entry_time, 1)
                num = map.get(snds_be,last_entry_time)
                if num >= 2
                    map.put(black_list, last_entry_time , true)

            // Breakeven Handling
            if strategy.position_size < 0 and h_lt <= strategy.position_avg_price
                trade_breakeven := true
                strategy.exit("exit", "short", limit = last_tp , stop = strategy.position_avg_price, comment="Short BE")

            if strategy.position_size > 0 and l_lt >= strategy.position_avg_price
                trade_breakeven := true
                strategy.exit("exit2", "long", limit = last_tp , stop = strategy.position_avg_price, comment="Long BE")



// Plotting
l_tf_color = show_ltf ? color.new(color.green, 50) : color.new(color.green, 100)
h_tf_color = show_ltf ? color.new(color.red, 50) : color.new(color.red, 100)
plot(l_lt, color =l_tf_color)
plot(h_lt, color=h_tf_color)
l_htf_color = show_htf ? color.new(color.green, 0) : color.new(color.green, 100)
h_htf_color = show_htf ? color.new(color.red, 0) : color.new(color.red, 100)
plot(l_ht, color =l_htf_color)
plot(h_ht, color=h_htf_color)
market_state_color = color.new(color.black, 100)
if market_state_ht == "bullish" and show_market_structure
    market_state_color := color.new(color.green, 90)
if market_state_ht == "bearish" and show_market_structure
    market_state_color := color.new(color.red, 90)
bgcolor(market_state_color)

if minute(time) != minute(time[1])
    alert(str.tostring(l_ht), alert.freq_once_per_bar_close)