Backtesting Absorption

const ABSORPTION_SIZE = 20
const NEARBY_TICKS = 5
const NEARBY_MULTIPLE = 3
const NEARBY_TIME_MS = 60_000

function median(values: number[]): number {
  if (values.length === 0) return 0
  const sorted = [...values].sort((a, b) => a - b)
  const mid = Math.floor(sorted.length / 2)
  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid]
}

interface RowEntry { candleTime: number; price: number; buys: number; sells: number }

function buildAllEntries(): RowEntry[] {
  const entries: RowEntry[] = []
  for (const c of candles) {
    for (const level of c.levels) {
      entries.push({ candleTime: c.time, price: level.price, buys: level.buys, sells: level.sells })
    }
  }
  return entries
}

chart.frame((view, draw) => {
  const allEntries = buildAllEntries()
  const globalMedianTotalVolume = median(allEntries.map(r => r.buys + r.sells))
  const nearbyThreshold = globalMedianTotalVolume * NEARBY_MULTIPLE

  let sellBoxCount = 0
  let buyBoxCount = 0

  for (const c of view.candles) {
    const half = c.interval / 2
    const rowEntries = Object.entries(c.rows).map(([price, level]) => ({
      price: Number(price),
      buys: level.buys,
      sells: level.sells,
    }))
    const tickRange = NEARBY_TICKS * c.increment

    const nearbyEntries = (p: number) =>
      allEntries.filter(
        r => !(r.candleTime === c.time && r.price === p) &&
          Math.abs(r.candleTime - c.time) <= NEARBY_TIME_MS &&
          Math.abs(r.price - p) <= tickRange
      )

    const suppressSellAt = new Set<number>()
    const suppressBuyAt = new Set<number>()

    for (const { price: p, sells } of rowEntries) {
      if (sells <= ABSORPTION_SIZE) continue
      for (const r of nearbyEntries(p)) {
        if (r.buys > nearbyThreshold) {
          suppressSellAt.add(p)
          if (r.candleTime === c.time) suppressBuyAt.add(r.price)
        }
      }
    }
    for (const { price: p, buys } of rowEntries) {
      if (buys <= ABSORPTION_SIZE) continue
      for (const r of nearbyEntries(p)) {
        if (r.sells > nearbyThreshold) {
          suppressBuyAt.add(p)
          if (r.candleTime === c.time) suppressSellAt.add(r.price)
        }
      }
    }

    for (const { price: p, buys, sells } of rowEntries) {
      const top = p + c.increment / 2
      const bottom = p - c.increment / 2

      if (sells > ABSORPTION_SIZE && !suppressSellAt.has(p)) {
        sellBoxCount++
        draw.rectangle({
          price1: bottom, price2: top,
          time1: c.time, time2: c.time + half,
          color: 'transparent', borderColor: '#ffe600', borderWidth: 2,
        })
      }
      if (buys > ABSORPTION_SIZE && !suppressBuyAt.has(p)) {
        buyBoxCount++
        draw.rectangle({
          price1: bottom, price2: top,
          time1: c.time + half, time2: c.time + c.interval,
          color: 'transparent', borderColor: '#ffe600', borderWidth: 2,
        })
      }
    }
  }

  const last = view.candles[view.candles.length - 1]
  if (last) {
    draw.text({
      time: view.endTime,
      price: view.maxPrice,
      text: `Absorption boxes (visible): ${sellBoxCount + buyBoxCount} (sell ${sellBoxCount} / buy ${buyBoxCount})`,
      color: '#ffe600',
      size: 12,
      align: 'right',
    })
  }
})