// This Pine Script(R) code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// (c) FirmTape
//
// FirmTape Levels
//
// Draws FirmTape's dealer-gamma levels on your chart: the zero-gamma flip, call resistance,
// put support, the open-interest flip and walls, and gamma by strike as bars at the right edge.
//
// These are MEASUREMENTS of dealer positioning, not trade signals. Nothing here tells you to
// buy or sell.
//
// TradingView scripts cannot fetch data, so the levels come in as a text string. Get it from
// the FirmTape terminal (LIVE plan): press "Copy levels" and paste the string into this
// script's settings, "Levels string". One paste can hold ES, NQ, SPX, QQQ and more; the
// script picks the block for the chart you are on:
//   ES1!, MES1!, ESZ2026 ... read ES      NQ1!, MNQ1! ... read NQ
//   anything else reads the block with the same ticker (SPX on SPX, QQQ on QQQ).
// "Symbol block" forces one. The table shows when the levels were taken and warns when they
// are older than today: a pasted string is a snapshot and does not move by itself.
//
// String format FT1 (docs/levels-string.md in the integrations repository):
//   FT1;ES;ESZ26;2026-09-30T15:17;px=...;flip=...;cr=...;ps=...;oflip=...;ocr=...;ops=...;
//   ng=...;u=pt;s=o;b=...;gm=...;n=20;g=7700.25:-12,7705.25:4,...   blocks joined by "|"

//@version=6
indicator("FirmTape Levels", shorttitle = "FirmTape", overlay = true, max_lines_count = 20, max_labels_count = 20, max_boxes_count = 40)

// ---------------------------------------------------------------- inputs
const string G_SRC = "Levels"
string i_str = input.text_area("", "Levels string", group = G_SRC, tooltip = "Paste the string from the FirmTape terminal, Copy levels (LIVE plan). It starts with FT1.")
string i_sym = input.string("Auto", "Symbol block", group = G_SRC, tooltip = "Auto: ES1!/MES1! read ES, NQ1!/MNQ1! read NQ, other charts the block with the same ticker. Type a symbol (ES, NQ, SPX, QQQ) to force that block.")

const string G_LVL = "Lines"
color  i_cFlip  = input.color(color.new(#e0b000, 0), "Flip", group = G_LVL, inline = "f")
color  i_cCall  = input.color(color.new(#26a69a, 0), "Call resistance", group = G_LVL, inline = "c")
color  i_cPut   = input.color(color.new(#ef5350, 0), "Put support", group = G_LVL, inline = "p")
int    i_width  = input.int(2, "Width", minval = 1, maxval = 4, group = G_LVL)
string i_style  = input.string("Solid", "Style", options = ["Solid", "Dashed", "Dotted"], group = G_LVL)
bool   i_oi     = input.bool(false, "Show the open-interest book (dashed, lighter)", group = G_LVL)
bool   i_labels = input.bool(true, "Labels at the right", group = G_LVL)

const string G_GAM = "Gamma by strike"
bool   i_gam    = input.bool(true, "Show gamma by strike", group = G_GAM)
int    i_gOff   = input.int(3, "Bars from the last bar", minval = 1, maxval = 200, group = G_GAM)
int    i_gWidth = input.int(30, "Longest bar, in bars", minval = 5, maxval = 250, group = G_GAM)
color  i_gPos   = input.color(color.new(#26a69a, 45), "Positive", group = G_GAM, inline = "g")
color  i_gNeg   = input.color(color.new(#ef5350, 45), "Negative", group = G_GAM, inline = "g")
bool   i_gText  = input.bool(false, "Values on the bars", group = G_GAM)

const string G_TAB = "Table"
bool   i_tab    = input.bool(true, "Show the table", group = G_TAB)
string i_tabPos = input.string("Top right", "Position", options = ["Top right", "Top left", "Bottom right", "Bottom left"], group = G_TAB)

// ---------------------------------------------------------------- the parsed block
type Block
    string sym = ""
    string contract = ""
    string asof = ""
    string err = ""
    float px = na
    float flip = na
    float cr = na
    float ps = na
    float oflip = na
    float ocr = na
    float ops = na
    float ng = na
    string unit = ""
    string sess = ""
    float basis = na
    string grade = ""
    float gm = na
    int n = -1
    array<float> gk
    array<float> gv
    bool gbad = false
    string problem = ""

// Remove the spaces and newlines a paste may pick up.
clean(string s) =>
    str.replace_all(str.replace_all(s, " ", ""), "\n", "")

// One "FT1;..." block into a Block. Mirrors parseBlock() in test/levels_string.js.
parseBlock(string raw) =>
    Block b = Block.new(gk = array.new<float>(), gv = array.new<float>())
    array<string> parts = str.split(raw, ";")
    if array.size(parts) < 4
        b.problem := "too short"
    else if array.get(parts, 0) != "FT1"
        b.problem := "unknown version " + array.get(parts, 0) + ": update the script"
    else
        b.sym := str.upper(array.get(parts, 1))
        b.contract := array.get(parts, 2) == "-" ? "" : array.get(parts, 2)
        b.asof := array.get(parts, 3) == "-" ? "" : array.get(parts, 3)
        for [i, p] in parts
            if i >= 4
                int eq = str.pos(p, "=")
                if not na(eq) and eq >= 1
                    string k = str.substring(p, 0, eq)
                    string v = str.substring(p, eq + 1)
                    if k == "px"
                        b.px := str.tonumber(v)
                    else if k == "flip"
                        b.flip := str.tonumber(v)
                    else if k == "cr"
                        b.cr := str.tonumber(v)
                    else if k == "ps"
                        b.ps := str.tonumber(v)
                    else if k == "oflip"
                        b.oflip := str.tonumber(v)
                    else if k == "ocr"
                        b.ocr := str.tonumber(v)
                    else if k == "ops"
                        b.ops := str.tonumber(v)
                    else if k == "ng"
                        b.ng := str.tonumber(v)
                    else if k == "u"
                        b.unit := v
                    else if k == "s"
                        b.sess := v
                    else if k == "b"
                        b.basis := str.tonumber(v)
                    else if k == "gr"
                        b.grade := v
                    else if k == "gm"
                        b.gm := str.tonumber(v)
                    else if k == "err"
                        b.err := v
                    else if k == "n"
                        float nn = str.tonumber(v)
                        b.n := na(nn) ? -1 : int(nn)
                    else if k == "g" and v != ""
                        for pr in str.split(v, ",")
                            array<string> kv = str.split(pr, ":")
                            float sk = array.size(kv) == 2 ? str.tonumber(array.get(kv, 0)) : na
                            float sv = array.size(kv) == 2 ? str.tonumber(array.get(kv, 1)) : na
                            if not na(sk) and not na(sv)
                                array.push(b.gk, sk)
                                array.push(b.gv, sv)
                            else
                                b.gbad := true
        if b.err == ""
            if b.n < 0
                b.problem := "block is cut off: copy the whole string again"
            else if b.gbad or b.n != array.size(b.gk)
                b.problem := "gamma list is cut off: copy the whole string again"
                array.clear(b.gk)
                array.clear(b.gv)
    b

// The block this chart wants: override, then futures root, then the exact ticker.
wantedSym() =>
    string o = str.upper(clean(i_sym))
    string r = str.upper(syminfo.root)
    string w = str.upper(syminfo.ticker)
    if o != "" and o != "AUTO"
        w := o
    else if syminfo.type == "futures"
        w := r == "ES" or r == "MES" ? "ES" : r == "NQ" or r == "MNQ" ? "NQ" : r
    else if w == "ES" or w == "NQ"
        // ES and NQ blocks are futures levels; a stock with that ticker (ES is Eversource) must not read them.
        w := ""
    w

// The chart's dated contract as the API names it: ESH2027 or MESH2027 -> "ESH27" (micro
// contracts read the full-size view). "" for a continuous chart (ES1!) and anything else.
chartContract() =>
    string t = str.upper(syminfo.ticker)
    string r = str.upper(syminfo.root)
    string v = r == "ES" or r == "MES" ? "ES" : r == "NQ" or r == "MNQ" ? "NQ" : ""
    string c = ""
    if syminfo.type == "futures" and v != "" and not str.endswith(t, "!") and str.length(t) >= str.length(r) + 3
        string letter = str.substring(t, str.length(r), str.length(r) + 1)
        string yy = str.substring(t, str.length(t) - 2)
        if str.contains("FGHJKMNQUVXZ", letter) and not na(str.tonumber(yy))
            c := v + letter + yy
    c

// First day the API measures a contract: 22 days before its expiry, the third Friday of its
// month. "ESH27" -> 2027-02-25 (UTC milliseconds).
rollWindowStart(string c) =>
    int m = str.pos("FGHJKMNQUVXZ", str.substring(c, 2, 3)) + 1
    int y = 2000 + int(str.tonumber(str.substring(c, 3)))
    int first = timestamp("UTC", y, m, 1, 0, 0)
    // dayofweek: 1 is Sunday, 6 is Friday.
    int toFri = (7 + 6 - dayofweek(first, "UTC")) % 7
    first + (toFri + 14 - 22) * 86400000

// The warning when the pasted block's contract is not the chart's (ESZ26 levels on an ESH2027
// chart are off by the calendar spread): before the chart's contract is measured, when it will
// be; after, which symbol to pick in the terminal's Copy levels box. "" when they match or the
// chart is continuous (ES1!), SPX or a stock.
contractWarning(string contract) =>
    string c = chartContract()
    string w = ""
    if c != "" and contract != "" and c != contract
        int start = rollWindowStart(c)
        w := timenow < start ? "levels are for " + contract + "; " + c + " is measured from " + str.format_time(start, "MMM d", "UTC") : "levels are for " + contract + "; for " + c + " pick " + c + " in Copy levels"
    w

lineStyle() =>
    i_style == "Dashed" ? line.style_dashed : i_style == "Dotted" ? line.style_dotted : line.style_solid

tablePos() =>
    i_tabPos == "Top left" ? position.top_left : i_tabPos == "Bottom right" ? position.bottom_right : i_tabPos == "Bottom left" ? position.bottom_left : position.top_right

fmtLevel(float v) =>
    str.tostring(v, "#.##")

fmtAmount(float v, string unit) =>
    str.tostring(v, "#.#") + (unit == "pct" ? "M$ per 1%" : unit == "pt" ? "M$ per pt" : "M$")

// ---------------------------------------------------------------- drawing state
var array<line>  gLines  = array.new<line>()
var array<label> gLabels = array.new<label>()
var array<box>   gBoxes  = array.new<box>()
var table        gTab    = na

wipe() =>
    for l in gLines
        line.delete(l)
    array.clear(gLines)
    for lb in gLabels
        label.delete(lb)
    array.clear(gLabels)
    for bx in gBoxes
        box.delete(bx)
    array.clear(gBoxes)

drawLevel(float y, string name, color c, string st, int lblX) =>
    if not na(y)
        array.push(gLines, line.new(bar_index - 1, y, bar_index, y, xloc = xloc.bar_index, extend = extend.both, color = c, width = i_width, style = st))
        if i_labels
            array.push(gLabels, label.new(lblX, y, name + " " + fmtLevel(y), xloc = xloc.bar_index, style = label.style_label_left, color = color.new(c, 80), textcolor = c, size = size.small))

setRow(int row, string k, string v, color c) =>
    table.cell(gTab, 0, row, k, text_color = color.gray, text_size = size.small, text_halign = text.align_left)
    table.cell(gTab, 1, row, v, text_color = c, text_size = size.small, text_halign = text.align_left)

// ---------------------------------------------------------------- once, on the last bar
if barstate.islast
    wipe()

    // Parse every block, keep the one this chart wants.
    string s = clean(i_str)
    string want = wantedSym()
    string have = ""
    string vprob = ""
    Block sel = na
    if s != ""
        for raw in str.split(s, "|")
            Block b = parseBlock(raw)
            have := have + (have == "" ? "" : ", ") + (b.sym == "" ? "?" : b.sym)
            if b.sym == "" and b.problem != "" and vprob == ""
                vprob := b.problem
            if na(sel) and want != "" and b.sym == want
                sel := b

    // What the table says, and in which colour.
    string status = ""
    color stColor = color.gray
    bool canDraw = false
    if s == ""
        status := "Paste the levels string from the FirmTape terminal (LIVE), Copy levels, into this script's settings."
    else if na(sel) and vprob != ""
        status := vprob
        stColor := color.red
    else if na(sel)
        status := "No " + want + " block in the string (it has " + have + "). Set Symbol block to pick one."
        stColor := color.orange
    else if sel.err == "contract_not_live"
        status := want + ": that contract is not measured today; copy plain " + want + " (the front contract)"
    else if sel.err != ""
        status := want + ": " + sel.err
        stColor := color.orange
    else if sel.problem != "" and sel.n < 0
        status := sel.problem
        stColor := color.red
    else
        canDraw := true
        stColor := color.green
        status := sel.sess == "o" ? "session open" : sel.sess == "c" ? "session closed" : sel.sess == "s" ? "book stale at copy time" : "ok"

    // Freshness: the block's ET date against today's ET date.
    string ageText = ""
    color ageColor = color.gray
    if canDraw and str.length(sel.asof) >= 16
        int y  = int(str.tonumber(str.substring(sel.asof, 0, 4)))
        int mo = int(str.tonumber(str.substring(sel.asof, 5, 7)))
        int d  = int(str.tonumber(str.substring(sel.asof, 8, 10)))
        int hh = int(str.tonumber(str.substring(sel.asof, 11, 13)))
        int mi = int(str.tonumber(str.substring(sel.asof, 14, 16)))
        int blockDay = y * 10000 + mo * 100 + d
        int today = year(timenow, "America/New_York") * 10000 + month(timenow, "America/New_York") * 100 + dayofmonth(timenow, "America/New_York")
        if blockDay < today
            ageText := "OLDER THAN TODAY: copy fresh levels"
            ageColor := color.red
        else
            int mins = int(math.round((timenow - timestamp("America/New_York", y, mo, d, hh, mi)) / 60000))
            ageText := str.tostring(math.max(mins, 0)) + " min old"
            ageColor := mins > 60 ? color.orange : color.gray

    // Warnings that still draw.
    string warn = ""
    if canDraw
        if sel.problem != ""
            warn := sel.problem
        if not na(sel.px) and sel.px > 0 and math.abs(close / sel.px - 1) > 0.05
            warn := warn + (warn == "" ? "" : " / ") + "levels do not fit this chart's price"
        string cw = contractWarning(sel.contract)
        if cw != ""
            warn := warn + (warn == "" ? "" : " / ") + cw

    if canDraw
        // Gamma by strike: bars at the right edge, length by |gamma|, height from the strike spacing.
        int n = array.size(sel.gk)
        int lblX = bar_index + 2
        if i_gam and n > 0
            float gap = na
            if n > 1
                for i = 1 to n - 1
                    float dd = array.get(sel.gk, i) - array.get(sel.gk, i - 1)
                    if dd > 0 and (na(gap) or dd < gap)
                        gap := dd
            float h = na(gap) ? syminfo.mintick * 4 : gap * 0.4
            int left = bar_index + i_gOff
            for i = 0 to n - 1
                float k = array.get(sel.gk, i)
                float rel = array.get(sel.gv, i)
                int len = math.max(1, int(math.round(math.abs(rel) / 100 * i_gWidth)))
                string txt = i_gText and not na(sel.gm) ? str.tostring(rel / 100 * sel.gm, "#.#") : ""
                array.push(gBoxes, box.new(left, k + h, left + len, k - h, xloc = xloc.bar_index, border_width = 0, bgcolor = rel >= 0 ? i_gPos : i_gNeg, text = txt, text_size = size.tiny, text_color = color.gray, text_halign = text.align_left))
            lblX := left + i_gWidth + 2

        string st = lineStyle()
        drawLevel(sel.flip, "Flip", i_cFlip, st, lblX)
        drawLevel(sel.cr, "Call res", i_cCall, st, lblX)
        drawLevel(sel.ps, "Put sup", i_cPut, st, lblX)
        if i_oi
            drawLevel(sel.oflip, "OI flip", color.new(i_cFlip, 50), line.style_dashed, lblX)
            drawLevel(sel.ocr, "OI call", color.new(i_cCall, 50), line.style_dashed, lblX)
            drawLevel(sel.ops, "OI put", color.new(i_cPut, 50), line.style_dashed, lblX)

    // The table.
    if i_tab
        if na(gTab)
            gTab := table.new(tablePos(), 2, 6, bgcolor = color.new(color.black, 20), border_width = 0)
        table.clear(gTab, 0, 0, 1, 5)
        string title = canDraw ? sel.sym + (sel.contract != "" ? " " + sel.contract : "") : want
        setRow(0, "FirmTape", title, color.silver)
        if canDraw
            setRow(1, "As of", str.replace(sel.asof, "T", " ") + " ET", color.silver)
            setRow(2, "Age", ageText, ageColor)
            setRow(3, "Net gamma", na(sel.ng) ? "n/a" : fmtAmount(sel.ng, sel.unit), na(sel.ng) ? color.gray : sel.ng >= 0 ? i_cCall : i_cPut)
            setRow(4, "Status", status + (sel.grade != "" ? ", grade " + sel.grade : ""), stColor)
            if warn != ""
                setRow(5, "Warning", warn, color.orange)
        else
            setRow(1, "Status", status, stColor)