Price and Date Forecast V3 Debug

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © congacindy

//@version=5
indicator('Price and Date Forecast (2024 V3 DEBUG)', overlay=true,max_bars_back=5000)


// Input parameters
length1 = input.int(68, title='Dominant Cycle Length #1', minval=1)
length2 = input.int(34, title='Dominant Cycle Length #2', minval=1)
length3 = input.int(17, title='Dominant Cycle Length #3', minval=1)
leftBars = input.int(8, "Left Bars to get Pivot High/Low", minval=1)
rightBars = input.int(8, "Right Bars to get Pivot High/Low", minval=1)
kp = input(5, title="Candlestick Matching Pattern Length")
td = input.bool(false, title="TD demark flip setup? (if not contineous bar patten in kp length)")
td_trend = input.bool(false, title="TD demark trend flip setup? (all firs bars vs last bar logic)")
lookback = input.int(4, "TD Demark Lookback Flip Bars", minval=4)
y = input.int(5000, title='Lookback Bars', maxval=5000)
forecast_periods = input.int(10, title='Number of Periods to Forecast', minval=1)
_debug = input.bool(true, title="Show debug information?")

price = input.source(hl2)

bb_length = input.int(20, title='Bollinger Bands Length', minval=1)
bb_stddev = input.float(2.0, title='Bollinger Bands Standard Deviation', minval=0.1, step=0.1)
kc_length = input.int(20, title='Keltner Channel Length', minval=1)
kc_mult = input.float(1.0, title='Keltner Channel Multiplier', minval=0.1, step=0.1)
volatility_length = input.int(20, title="Volatility Length") // Adjust the length as needed


// Calculate the dominant cycle using time series analysis
//price = close
//cycle = ta.sma(price, cycle_length)

txt_col_price = input.color(color.rgb(208, 227, 62), 'Text/Frame Color', group='Dashboard')
txt_col_price_adj = input.color(color.rgb(231, 37, 237), 'Text/Frame Color', group='Dashboard')
txt_col_date = input.color(color.rgb(48, 228, 241), 'Text/Frame Color', group='Dashboard')
txt_col_pattern = input.color(color.rgb(238, 232, 166), 'Text/Frame Color', group='Dashboard')
txt_col = input.color(color.rgb(182, 186, 200), 'Text/Frame Color', group='Dashboard')
dash_loc = input.string('Mid Right', 'Dashboard Location', options=['Top Right', 'Bottom Right', 'Top Left', 'Mid Left', 'Mid Right'], group='Dashboard')
text_size = input.string('Tiny', 'Dashboard Size', options=['Tiny', 'Small', 'Normal', 'Large'], group='Dashboard')
debugtext_size = input.string('Tiny', 'Debug Dashboard Size', options=['Tiny', 'Small', 'Normal', 'Large'], group='Dashboard')
debugdash_loc = input.string('Bottom Center', 'Debug Dashboard Location', options=['Top Left', 'Top Center', 'Top Right', 'Mid Left', 'Mid Center', ' Mid Right', 'Bottom Left', 'Bottom Center', 'Bottom Right'], group='Dashboard')

// ****************************************************

// Goertzel algorithm to detect the dominant cycle
goertzel(price, length) =>
    k = 0.0
    w = 2 * math.pi / length
    cosine = math.cos(w)
    sine = math.sin(w)
    coeff = 2 * cosine
    q0 = 0.0
    q1 = 0.0
    q2 = 0.0
    for i = 0 to length - 1
        q0 := coeff * q1 - q2 + price[i]
        q2 := q1
        q1 := q0
    real = (q1 - q2 * cosine)
    imag = (q2 * sine)
    magnitude = math.sqrt(real * real + imag * imag)
    [real, imag, magnitude]

//goertzel(price, length) =>
//    k = 0.0
//    w = 2 * math.pi / length
//    cosine = math.cos(w)
//    sine = math.sin(w)
//    coeff = 2 * cosine
//    q0 = 0.0
//    q1 = 0.0
//    q2 = 0.0
//    for i = 0 to length - 1
//        q0 := coeff * q1 - q2 + price[i]
//        q2 := q1
//        q1 := q0
//    real = (q1 - q2 * cosine)
//    imag = (q2 * sine)
//    magnitude = math.sqrt(real * real + imag * imag)
//    
//    // Calculate the phase adjustment based on the current price position
//    price_position = ta.barssince(price == ta.lowest(price, length)) / length
//    phase_adjustment = 2 * math.pi * price_position
//    
//    // Adjust the phase by adding the phase adjustment
//    phase = math.atan(imag / real) + phase_adjustment
//    
//    [real, imag, magnitude, phase]


// Calculate the dominant cycle using Goertzel algorithm
//[real, imag, cycle] = goertzel(price, cycle_length)

// ****************************************************

// Find Matching Pattern based on k last bar 

get_bar_direction(i) =>
    ret=""
    if (close[i] >  close[i + 1])
        ret := 'U'
    else
        ret := 'D'
    ret

get_bar_color(i) =>
    ret = ""
    if (close[i] - open[i] > 0)
        ret := 'G'
    else
        ret := 'R'
    ret

// *********************** POPULATE ARRAY*****************************

last_j_bars = array.new_string(kp)
last_j_dates = array.new_string(kp)
last_jud_bars = array.new_string(kp)
last_jud_dates = array.new_string(kp)

for i = 0 to kp - 1
    array.set(last_j_bars, i, get_bar_color(i))
    array.set(last_j_dates, i, str.format("{0,date,yyyy-MM-dd}", time[i]))
    array.set(last_jud_bars, i, get_bar_direction(i))
    array.set(last_jud_dates, i, str.format("{0,date,yyyy-MM-dd}", time[i]))

match_found = false
match_dates = array.new_string(forecast_periods)
match_prices = array.new_float(forecast_periods)
var match_bar_index = 0

// ********************** TD Count ******************************

// Function to check for Bullish TD Price Flip


bullishFlip(i,match) =>
    bool isBullish = true
    if match
        //isBullish := (open [i+2] > close[i+2])  and (open [i+3] > close[i+3]) and (open [i+4] > close[i+4]) and (open [i+5] > close[i+5]) and close[i+2] > close[i+3] and close[i+3] > close[i+4] and close[i+4] > close[i+5] and close[i] > close[i+1+lookback] and close[i+1] < close[i+lookback]
        //isBullish := close[i+2] > close[i+3] and close[i+3] > close[i+4] and close[i+4] > close[i+5] and close[i] > close[i+1+lookback] and close[i+1] < close[i+lookback]
        isBullish := (high [i+5] > low[i+2]) and close[i+2] > close[i+3] and close[i+3] > close[i+4] and close[i+4] > close[i+5] and close[i] > close[i+1+lookback] and close[i+1] < close[i+lookback]
    else
        isBullish := close[i] > close[i+1+lookback] and close[i+1] < close[i+lookback]

    [isBullish,i]

// Function to check for Bearish TD Price Flip (AI Generated ??????)

bearishFlip(i,match) =>
    bool isBearish = true
    if match
        //isBearish :=  (open [i+2] < close[i+2])  and (open [i+3] < close[i+3]) and (open [i+4] < close[i+4]) and (open [i+5] < close[i+5]) and close[i+2] < close[i+3] and close[i+3] < close[i+4] and close[i+4] < close[i+5] and close[i] < close[i+lookback] and close[i+1] > close[i+lookback+1]
        //isBearish :=  close[i+2] < close[i+3] and close[i+3] < close[i+4] and close[i+4] < close[i+5] and close[i] < close[i+lookback] and close[i+1] > close[i+lookback+1]
        isBearish :=  (high [i+5] < low[i+2])  and close[i+2] < close[i+3] and close[i+3] < close[i+4] and close[i+4] < close[i+5] and close[i] < close[i+lookback] and close[i+1] > close[i+lookback+1]
    else
        isBearish := close[i] < close[i+lookback] and close[i+1] > close[i+lookback+1]
    [isBearish,i]

tdPriceFlip(length = 4, source = close) =>
    flip = array.new_bool(length)
    for i = 0 to length - 1
        if i >= length - 1
            array.push(flip, source[i] > source[i - length])
        else
            array.push(flip, na)
    flip

// Usage:
// Bearish TD Price Flip
//bearishFlip = tdPriceFlip()[0] and not tdPriceFlip()[1]

// Bullish TD Price Flip
//bullishFlip = not tdPriceFlip()[0] and tdPriceFlip()[1]

// *********************** FIND PATTERN *****************************


_found1 = false
_found2 = false

if barstate.islast
    if not td
        for i = kp to y
            match = true
            for j = 0 to kp - 1
                if get_bar_color(i + j) != array.get(last_j_bars, j) 
                    match := false
                    break

            for j = 0 to kp - 1
                if get_bar_direction(i + j) != array.get(last_jud_bars, j) 
                    match := false
                    break

            if match
                match_found := true
                match_bar_index := i
                for m = 0 to kp - 1
                    array.set(match_dates, m, str.format("{0,date,yyyy-MM-dd}", time[i + m]))
                    array.set(match_prices, m, close[i + m - kp])
                break
    else
        for i = kp+lookback to y
            match = true
            for j = 0 to 0
            //for j = 0 to kp - 1
                //if get_bar_color(i + j) != array.get(last_j_bars, j)
                [_res1, _pos1] = bullishFlip(i,true)
                [_res2, _pos2] = bearishFlip(i,true) 
                [_res3, _pos3] = bullishFlip(i,false) 
                [_res4, _pos4] = bearishFlip(i,false)  


                //var table myTable = table.new(position = position.bottom_right, columns = 4, rows = 1, bgcolor = color.gray, border_width = 1)

                // Adding headers to the table
                //table.cell(table_id = myTable, column = 0, row = 0, text = str.tostring(_pos1), bgcolor = color.blue, text_color = color.white)
                //table.cell(table_id = myTable, column = 1, row = 0, text = str.tostring(_pos2), bgcolor = color.blue, text_color = color.white)
                //table.cell(table_id = myTable, column = 2, row = 0, text = str.tostring(_pos3), bgcolor = color.blue, text_color = color.white)
                //table.cell(table_id = myTable, column = 3, row = 0, text = str.tostring(_pos4), bgcolor = color.blue, text_color = color.white)

                if td_trend 
                    // if it return y (i.e 2000) then there is no match
                    if not _res1 
                        match := false
                        if (_pos1 > kp+ lookback) and (_pos1 < y)
                            //found a position
                            _found1 := true
                        break
                    else if not _res2 and not _found1
                        // bullish pattern not found
                        match := false
                        break
                else
                    if not _res3 
                        match := false
                        if (_pos2 > kp+ lookback) and (_pos1 < y)
                            _found2 := true
                        break
                    else if not _res4 and not _found2
                        match := false
                        break
            if match
                match_found := true
                match_bar_index := i
                for m = 0 to kp - 1
                    array.set(match_dates, m, str.format("{0,date,yyyy-MM-dd}", time[i + m]))
                    array.set(match_prices, m, close[i + m - kp])
                break


if match_bar_index == 0
    match_bar_index := kp

// ******************** DEBUG ********************************

if _debug
    var debugtable_position = debugdash_loc == 'Top Left' ? position.top_left : debugdash_loc == 'Top Center' ? position.top_center : debugdash_loc == 'Top Right' ? position.top_right : debugdash_loc == 'Mid Left' ? position.middle_left : debugdash_loc == 'Mid Center' ? position.middle_center : debugdash_loc == 'Mid Right' ? position.middle_right : debugdash_loc == 'Bottom Left' ? position.bottom_left: debugdash_loc == 'Bottom Center' ? position.bottom_center : position.bottom_right
    var debugtable_text_size = debugtext_size == 'Tiny' ? size.tiny : debugtext_size == 'Small' ? size.small : debugtext_size == 'Normal' ? size.normal : size.large

    // Display table
    if barstate.islast
        table_id = table.new(debugtable_position, rows=3, columns = kp + 1)
        table.cell(table_id, 0, 0, "Date {" + str.tostring(match_bar_index) + "}", bgcolor=color.gray, text_color=color.white,text_size=debugtable_text_size)
        table.cell(table_id, 0, 1, "Candlestick", bgcolor=color.gray, text_color=color.white,text_size=debugtable_text_size)
        table.cell(table_id, 0, 2, "Pattern", bgcolor=color.gray, text_color=color.white,text_size=debugtable_text_size)
    
        for i = 0 to kp - 1
            table.cell(table_id,i + 1, 0, array.get(last_j_dates, i), text_color=txt_col, text_size=debugtable_text_size)
            table.cell(table_id,i + 1, 1, array.get(last_j_bars, i), text_color=txt_col, text_size=debugtable_text_size, bgcolor=color.new(array.get(last_j_bars, i) == 'G' ? color.green : color.red, 90))
            table.cell(table_id,i + 1, 2, array.get(last_jud_bars, i), text_color=txt_col, text_size=debugtable_text_size, bgcolor=color.new(array.get(last_jud_bars, i) == 'U' ? color.rgb(13, 144, 225) : color.rgb(202, 68, 222), 90))