//@version=6
indicator("Mentor — Auto Levels v1.3", overlay = true, max_lines_count = 20, max_labels_count = 30)

// Own-chart levels only. MNQ/MES/MYM/MGC stay on the micro ticker.
// ES/NQ/YM/GC stay on the mini ticker. BTCUSDT.P uses the perp ticker.
// Mini levels are never painted onto a micro chart, and vice versa.

const string GRP_SOURCE = "1. Contract and sessions"
const string GRP_LEVELS = "2. Level groups"
const string GRP_DISPLAY = "3. Display"

string sessionTz = input.string("America/New_York", "Session timezone", group = GRP_SOURCE,
     tooltip = "IANA timezone so US daylight-saving changes are automatic.")
string overnightSession = input.session("1800-0930", "Overnight session", group = GRP_SOURCE,
     tooltip = "NY time. CME Globex through US cash open. BTC: same window as NY overnight vs US cash.")

bool showOvernight = input.bool(true, "Overnight high / low", group = GRP_LEVELS)
bool showPriorDay = input.bool(true, "Prior-day high / low", group = GRP_LEVELS)
bool showPriorWeek = input.bool(true, "Prior-week high / low", group = GRP_LEVELS)
bool showMidpoints = input.bool(true, "Session midpoints", group = GRP_LEVELS)
bool showOpenClose = input.bool(true, "Overnight open and prior closes", group = GRP_LEVELS)

bool showLabels = input.bool(true, "Show right-side labels", group = GRP_DISPLAY)
bool showDashboard = input.bool(true, "Show compact level table", group = GRP_DISPLAY)
bool shadeOvernight = input.bool(false, "Shade active overnight session", group = GRP_DISPLAY)
int lineTransparency = input.int(15, "Line transparency", minval = 0, maxval = 90, group = GRP_DISPLAY)

string root = str.upper(syminfo.root)
string tick = str.upper(syminfo.ticker)
bool isNq = root == "NQ" or root == "MNQ"
bool isEs = root == "ES" or root == "MES"
bool isYm = root == "YM" or root == "MYM"
bool isGc = root == "GC" or root == "MGC"
bool isBtc = str.contains(tick, "BTC")
bool supported = isNq or isEs or isYm or isGc or isBtc

string family = isNq ? "NQ family" : isEs ? "ES family" : isYm ? "YM family" : isGc ? "GC family" : isBtc ? "BTC" : "unsupported"

f_roundToTick(float value) =>
    na(value) ? na : math.round(value / syminfo.mintick) * syminfo.mintick

f_fmt(float value) =>
    na(value) ? "—" : str.tostring(value, format.mintick)

[pdhRaw, pdlRaw, pdcRaw] = request.security(syminfo.tickerid, "D", [high[1], low[1], close[1]],
     gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_on)
[pwhRaw, pwlRaw, pwcRaw] = request.security(syminfo.tickerid, "W", [high[1], low[1], close[1]],
     gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_on)

float pdh = f_roundToTick(pdhRaw)
float pdl = f_roundToTick(pdlRaw)
float pdc = f_roundToTick(pdcRaw)
float pdm = f_roundToTick((pdhRaw + pdlRaw) * 0.5)
float pwh = f_roundToTick(pwhRaw)
float pwl = f_roundToTick(pwlRaw)
float pwc = f_roundToTick(pwcRaw)
float pwm = f_roundToTick((pwhRaw + pwlRaw) * 0.5)

bool inOvernight = timeframe.isintraday and not na(time(timeframe.period, overnightSession, sessionTz))
bool overnightStart = inOvernight and not inOvernight[1]

var float overnightOpenRaw = na
var float overnightHighRaw = na
var float overnightLowRaw = na

if overnightStart
    overnightOpenRaw := open
    overnightHighRaw := high
    overnightLowRaw := low
else if inOvernight
    overnightHighRaw := math.max(nz(overnightHighRaw, high), high)
    overnightLowRaw := math.min(nz(overnightLowRaw, low), low)

float ono = f_roundToTick(overnightOpenRaw)
float onh = f_roundToTick(overnightHighRaw)
float onl = f_roundToTick(overnightLowRaw)
float onm = f_roundToTick((overnightHighRaw + overnightLowRaw) * 0.5)

bgcolor(shadeOvernight and inOvernight ? color.new(color.blue, 93) : na, title = "Active overnight session")

color overnightColor = color.rgb(54, 162, 235)
color priorDayColor = color.rgb(255, 159, 64)
color priorWeekColor = color.rgb(153, 102, 255)

array<float> levelPrices = array.from(onh, onm, ono, onl, pdh, pdm, pdc, pdl, pwh, pwm, pwc, pwl)
array<string> levelNames = array.from("ONH", "ON MID", "ON OPEN", "ONL", "PDH", "PD MID", "PDC", "PDL", "PWH", "PW MID", "PWC", "PWL")
array<color> levelColors = array.from(overnightColor, overnightColor, overnightColor, overnightColor,
     priorDayColor, priorDayColor, priorDayColor, priorDayColor,
     priorWeekColor, priorWeekColor, priorWeekColor, priorWeekColor)
array<bool> levelVisible = array.from(
     supported and timeframe.isintraday and showOvernight,
     supported and timeframe.isintraday and showOvernight and showMidpoints,
     supported and timeframe.isintraday and showOvernight and showOpenClose,
     supported and timeframe.isintraday and showOvernight,
     supported and showPriorDay,
     supported and showPriorDay and showMidpoints,
     supported and showPriorDay and showOpenClose,
     supported and showPriorDay,
     supported and showPriorWeek,
     supported and showPriorWeek and showMidpoints,
     supported and showPriorWeek and showOpenClose,
     supported and showPriorWeek)
array<bool> levelDashed = array.from(false, true, false, false, false, true, false, false, false, true, false, false)
array<bool> levelDotted = array.from(false, false, true, false, false, false, true, false, false, false, true, false)
array<int> labelOffsets = array.from(4, 4, 4, 4, 12, 12, 12, 12, 20, 20, 20, 20)

var array<line> levelLines = array.new_line(12)
var array<label> levelLabels = array.new_label(12)

if barstate.islast
    for i = 0 to 11
        float level = array.get(levelPrices, i)
        string levelName = array.get(levelNames, i)
        color levelColor = array.get(levelColors, i)
        bool visible = array.get(levelVisible, i) and not na(level)
        bool dashed = array.get(levelDashed, i)
        bool dotted = array.get(levelDotted, i)
        string lineStyle = dotted ? line.style_dotted : dashed ? line.style_dashed : line.style_solid
        int lineWidth = dashed or dotted ? 1 : 2

        line levelLine = array.get(levelLines, i)
        if visible
            if na(levelLine)
                levelLine := line.new(bar_index, level, bar_index + 1, level, xloc = xloc.bar_index,
                     extend = extend.both, color = color.new(levelColor, lineTransparency),
                     style = lineStyle, width = lineWidth)
                array.set(levelLines, i, levelLine)
            else
                line.set_xy1(levelLine, bar_index, level)
                line.set_xy2(levelLine, bar_index + 1, level)
                line.set_extend(levelLine, extend.both)
                line.set_color(levelLine, color.new(levelColor, lineTransparency))
                line.set_style(levelLine, lineStyle)
                line.set_width(levelLine, lineWidth)
        else if not na(levelLine)
            line.delete(levelLine)
            array.set(levelLines, i, na)

        label levelLabel = array.get(levelLabels, i)
        if visible and showLabels
            int labelX = bar_index + array.get(labelOffsets, i)
            if na(levelLabel)
                levelLabel := label.new(labelX, level, levelName, xloc = xloc.bar_index,
                     style = label.style_label_left, color = color.new(levelColor, 45),
                     textcolor = color.white, size = size.small)
                array.set(levelLabels, i, levelLabel)
            else
                label.set_xy(levelLabel, labelX, level)
                label.set_text(levelLabel, levelName)
                label.set_color(levelLabel, color.new(levelColor, 45))
                label.set_textcolor(levelLabel, color.white)
                label.set_size(levelLabel, size.small)
        else if not na(levelLabel)
            label.delete(levelLabel)
            array.set(levelLabels, i, na)

var table dash = table.new(position.top_left, 4, 6, border_width = 1)
if barstate.isfirst
    table.merge_cells(dash, 1, 5, 3, 5)

if barstate.islast and showDashboard
    color header = color.rgb(22, 33, 49)
    color panel = color.rgb(31, 45, 62)
    color muted = color.rgb(173, 184, 198)
    string status = not supported ? "Use NQ ES GC BTC (or micros)" : not timeframe.isintraday ? "Use intraday TF" : syminfo.ticker + " · " + family
    color statusColor = supported and timeframe.isintraday ? color.lime : color.orange

    table.cell(dash, 0, 0, "LEVELS", text_color = color.white, bgcolor = header)
    table.cell(dash, 1, 0, "ON", text_color = overnightColor, bgcolor = header)
    table.cell(dash, 2, 0, "PRIOR DAY", text_color = priorDayColor, bgcolor = header)
    table.cell(dash, 3, 0, "PRIOR WEEK", text_color = priorWeekColor, bgcolor = header)

    table.cell(dash, 0, 1, "High", text_color = muted, bgcolor = panel)
    table.cell(dash, 1, 1, f_fmt(onh), text_color = color.white, bgcolor = panel)
    table.cell(dash, 2, 1, f_fmt(pdh), text_color = color.white, bgcolor = panel)
    table.cell(dash, 3, 1, f_fmt(pwh), text_color = color.white, bgcolor = panel)

    table.cell(dash, 0, 2, "Mid", text_color = muted, bgcolor = panel)
    table.cell(dash, 1, 2, f_fmt(onm), text_color = color.white, bgcolor = panel)
    table.cell(dash, 2, 2, f_fmt(pdm), text_color = color.white, bgcolor = panel)
    table.cell(dash, 3, 2, f_fmt(pwm), text_color = color.white, bgcolor = panel)

    table.cell(dash, 0, 3, "Open / close", text_color = muted, bgcolor = panel)
    table.cell(dash, 1, 3, f_fmt(ono), text_color = color.white, bgcolor = panel)
    table.cell(dash, 2, 3, f_fmt(pdc), text_color = color.white, bgcolor = panel)
    table.cell(dash, 3, 3, f_fmt(pwc), text_color = color.white, bgcolor = panel)

    table.cell(dash, 0, 4, "Low", text_color = muted, bgcolor = panel)
    table.cell(dash, 1, 4, f_fmt(onl), text_color = color.white, bgcolor = panel)
    table.cell(dash, 2, 4, f_fmt(pdl), text_color = color.white, bgcolor = panel)
    table.cell(dash, 3, 4, f_fmt(pwl), text_color = color.white, bgcolor = panel)

    table.cell(dash, 0, 5, "Chart", text_color = muted, bgcolor = panel)
    table.cell(dash, 1, 5, status, text_color = statusColor, bgcolor = panel)

if barstate.islast and not showDashboard
    table.clear(dash, 0, 0, 3, 5)