Templates

# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""
{FILENAME}
Created: {TIMESTAMP}

{DESCRIPTION}

================================================================================
HOW TO CREATE AN INDICATOR - A BEGINNER'S GUIDE
================================================================================

This template shows you how to create indicators for Quant Charts.
It's designed to be super easy - if you know basic Python, you're ready!

STEP 1: Import what you need
STEP 2: Add the @indicator decorator
STEP 3: Define parameters as class attributes
STEP 4: Write your calculation in calculate(self, df)
STEP 5: Plot the result

Let's go through each step below...

NOTE ON OPTIMIZATION SWEEPS:
Indicators used inside a strategy are also called once per param per day during
a sweep. When an indicator does param-independent work (e.g. rolling-window on
`close` with a literal period, heavy mask building), the same `_DAY_CACHE[id(df)]`
hoisting pattern from `templates/strategy_template.py` applies here too. Lines
that reference `self.*` belong in `calculate()`; lines that don't belong in
`_prepare_day(df)` at module level.
"""

# =============================================================================
# STEP 1: IMPORT WHAT YOU NEED
# =============================================================================
# These are the building blocks for your indicator.
#
# - indicator: The decorator that makes your class into an indicator
# - input: Create adjustable parameters (period, color, etc.)
# - plot: Draw lines on the chart
# - close: Access closing prices (this is a pandas Series!)
# - hline: Draw horizontal reference lines (optional)
# - fill: Fill area between two lines (optional)

from quant_charts import indicator, input, plot, close


# =============================================================================
# STEP 2: ADD THE @indicator DECORATOR
# =============================================================================
# The decorator tells Quant Charts this is an indicator.
#
# Parameters:
#   - First arg: The name shown in the UI (e.g., "SMA", "RSI")
#   - overlay=True: Draw ON the price chart (like moving averages)
#   - overlay=False: Draw in a SEPARATE pane (like RSI, MACD)
#
# Example for an oscillator that needs its own pane:
#   @indicator("RSI", overlay=False)

@indicator("{NAME}", overlay=True, data_mode="both")  # data_mode: "tick", "ohlc", or "both"
class {CLASS_NAME}:
    # =========================================================================
    # STEP 3: DEFINE PARAMETERS
    # =========================================================================
    # Each parameter becomes a slider/input in the settings panel.
    # Users can adjust these without editing your code!
    #
    # Format: name = input.type(default, "Label", options...)
    #
    # Available types:
    #   input.int()    - Whole numbers (periods, lookbacks)
    #   input.float()  - Decimals (multipliers, thresholds)
    #   input.bool()   - True/False toggle
    #   input.color()  - Color picker
    #   input.string() - Text or dropdown menu

    period = input.int(20, "Period", min=1, max=500)
    color = input.color("#2962FF", "Line Color")

    def calculate(self, df):
        """
        {NAME} Indicator

        This is your indicator's description.
        Write a brief explanation of what it does.
        """

        # =====================================================================
        # STEP 4: WRITE YOUR CALCULATION
        # =====================================================================
        # The 'close' variable is a pandas Series containing all closing prices.
        # Use 'self.period' and 'self.color' to access your parameters.
        #
        # You can use ANY pandas operations on it:
        #
        #   close.rolling(20).mean()     - Simple moving average
        #   close.ewm(span=20).mean()    - Exponential moving average
        #   close.diff()                  - Price change from previous bar
        #   close.pct_change()            - Percentage change
        #   close.rolling(20).std()       - Standard deviation (volatility)
        #   close.shift(1)                - Previous bar's value
        #   close > close.shift(1)        - True if price went up
        #
        # Example: Simple Moving Average
        result = close.rolling(self.period).mean()

        # =====================================================================
        # STEP 5: PLOT THE RESULT
        # =====================================================================
        # Use plot() to draw your indicator on the chart.
        #
        # Parameters:
        #   - series: Your calculated data (pandas Series)
        #   - name: Label shown in the legend
        #   - color: Hex color (e.g., "#2962FF" is blue)
        #   - linewidth: Line thickness (1-5, default is 2)

        plot(result, f"{NAME}({self.period})", color=self.color, linewidth=2)


# =============================================================================
# THAT'S IT! Your indicator is ready.
# =============================================================================
# Save this file and it will automatically appear in your indicator list.
# The period and color can be adjusted in the settings panel.


# =============================================================================
# BONUS: MORE EXAMPLES
# =============================================================================
#
# --- Example: RSI with tags (overbought/oversold) ---
# from quant_charts import indicator, input, plot, hline, close, define_tag
#
# @indicator("RSI", overlay=False)
# class RSI:
#     period = input.int(14, "Period", min=2, max=100)
#     overbought = input.int(70, "Overbought", min=50, max=100)
#     oversold = input.int(30, "Oversold", min=0, max=50)
#
#     def calculate(self, df):
#         delta = close.diff()
#         gain = delta.where(delta > 0, 0).rolling(self.period).mean()
#         loss = (-delta.where(delta < 0, 0)).rolling(self.period).mean()
#         rs = gain / loss
#         rsi_value = 100 - (100 / (1 + rs))
#
#         plot(rsi_value, "RSI", color="#9C27B0")
#         hline(self.overbought, "Overbought", color="#EF5350", linestyle="dashed")
#         hline(self.oversold, "Oversold", color="#26A69A", linestyle="dashed")
#
#         define_tag("overbought", f"RSI > {self.overbought}", color="#DC2626")
#         define_tag("oversold", f"RSI < {self.oversold}", color="#16A34A")
#
#         return {
#             "overbought": rsi_value > self.overbought,
#             "oversold": rsi_value < self.oversold,
#         }
#
#
# --- Example: Bollinger Bands with fill ---
# from quant_charts import indicator, input, plot, fill, close
#
# @indicator("Bollinger Bands", overlay=True)
# class BollingerBands:
#     period = input.int(20, "Period")
#     std_dev = input.float(2.0, "Std Dev", min=0.5, max=5.0)
#     color = input.color("#2962FF", "Color")
#
#     def calculate(self, df):
#         middle = close.rolling(self.period).mean()
#         std = close.rolling(self.period).std()
#         upper = middle + (std * self.std_dev)
#         lower = middle - (std * self.std_dev)
#
#         plot(middle, "Middle", color=self.color)
#         plot(upper, "Upper", color=self.color, linewidth=1)
#         plot(lower, "Lower", color=self.color, linewidth=1)
#         fill("Upper", "Lower", color=self.color, opacity=10)
#
#
# --- Example: Two-line crossover (Fast/Slow MA) ---
# from quant_charts import indicator, input, plot, close
#
# @indicator("MA Crossover", overlay=True)
# class MACrossover:
#     fast = input.int(10, "Fast Period", min=1, max=100)
#     slow = input.int(20, "Slow Period", min=1, max=200)
#
#     def calculate(self, df):
#         fast_ma = close.rolling(self.fast).mean()
#         slow_ma = close.rolling(self.slow).mean()
#
#         plot(fast_ma, f"Fast({self.fast})", color="#26A69A")
#         plot(slow_ma, f"Slow({self.slow})", color="#EF5350")


# =============================================================================
# QUICK REFERENCE CHEAT SHEET
# =============================================================================
#
# PRICE DATA (all are pandas Series):
#   close      - Closing prices
#   open       - Opening prices
#   high       - Highest prices
#   low        - Lowest prices
#   volume     - Trading volume
#   hl2        - (High + Low) / 2
#   hlc3       - (High + Low + Close) / 3
#   ohlc4      - (Open + High + Low + Close) / 4
#
# INPUT TYPES:
#   input.int(default, "Label", min=X, max=Y, step=Z)
#   input.float(default, "Label", min=X, max=Y, step=Z)
#   input.bool(default, "Label")
#   input.color("#RRGGBB", "Label")
#   input.string("default", "Label", options=["A", "B", "C"])
#   input.source(Source.CLOSE, "Label")
#   input.timeframe("tick", "Label")
#
# PLOTTING:
#   plot(series, "Name", color="#HEX", linewidth=2)
#   hline(value, "Name", color="#HEX", linestyle="dashed")
#   fill("Series1 Name", "Series2 Name", color="#HEX", opacity=20)
#
# COMMON COLORS:
#   #2962FF - Blue (default)
#   #26A69A - Green (bullish)
#   #EF5350 - Red (bearish)
#   #FF9800 - Orange
#   #9C27B0 - Purple
#   #787B86 - Gray
#
# PANDAS OPERATIONS (use on close, open, high, low, volume):
#   .rolling(N).mean()  - Simple moving average over N bars
#   .ewm(span=N).mean() - Exponential moving average
#   .rolling(N).std()   - Standard deviation
#   .rolling(N).max()   - Highest value in N bars
#   .rolling(N).min()   - Lowest value in N bars
#   .diff()             - Change from previous bar
#   .pct_change()       - Percentage change
#   .shift(1)           - Previous bar's value
#   .abs()              - Absolute value

"""
{FILENAME}
Created: {TIMESTAMP}

{DESCRIPTION}
"""

from quant_charts import script, input


@script(
    name="{NAME}",
    description="Enter description here",
)
class {CLASS_NAME}:
    """
    Your generic script class

    Use scripts for data processing, analysis, exports, or any custom logic
    that doesn't fit the indicator or strategy paradigm.
    """

    # Define your parameters here
    output_file = input.string(
        default="output.csv",
        label="Output File",
        tooltip="Name of the output file"
    )

    threshold = input.float(
        default=1.0,
        label="Threshold",
        min=0.0,
        max=100.0,
        tooltip="Threshold value for processing"
    )

    def run(self, df):
        """
        Main entry point for the script

        Args:
            df: pandas DataFrame with OHLCV data (if available)

        Returns:
            Any value or None
        """
        # Your script logic here
        print(f"Running {self.__class__.__name__}")
        print(f"Output file: {self.output_file}")
        print(f"Threshold: {self.threshold}")

        # Example: Process data
        if df is not None:
            print(f"DataFrame shape: {df.shape}")
            # Do something with df...

        return None

# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""
{FILENAME}
Created: {TIMESTAMP}

{DESCRIPTION}
"""

import numpy as np
from quant_charts import strategy, day_start, input, ta, cross_above, cross_below, Timeframe


# When calculate() has param-independent work (raw_ticks filtering, argsort,
# reduceat, literal-period ta.* calls), use @day_start instead of writing your
# own module-level _DAY_CACHE. The framework calls the @day_start method ONCE
# per day in the main process, packs the returned dict into shared memory, and
# ships it to every worker — so a 6-worker × 50-day sweep runs the prep 50
# times instead of 300 times. The return value is exposed as `self._day` inside
# calculate(). See the commented example inside the class below.
#
# Contract for @day_start return value:
#   - Must be a dict.
#   - Values must be np.ndarray, int, float, bool, or str.
#   - pd.Series, lists, tuples, etc. are NOT shipped through SHM. Convert to
#     ndarray here and rebuild any Series locally inside calculate() if needed.


# SL/TP emit contract (optional, defaults to 'per_tick'):
#   emit_sltp='per_tick'   - sl/tp arrays carry a value on every row. Engine
#                            ratchets the active stop on each non-NaN sample.
#                            Use this for trailing or bar-by-bar adjusted stops.
#   emit_sltp='entry_only' - sl/tp arrays must be NaN except on entry rows
#                            (and on modify rows for opt-in trail strategies).
#                            Engine reads the value once at entry and holds it
#                            until exit. Sweep bundles drop from O(n) to O(entries)
#                            per combo; required to scale to 50d x 700p TBBO sweeps.
@strategy(
    name="{NAME}",
    description="Enter description here",
    overlay=True,
    timeframe=Timeframe.M1,
    data_mode="ohlc",
    # emit_sltp='entry_only',  # opt in when sl/tp values do not change after entry
)
class {CLASS_NAME}:
    """
    Before reading anything beyond open/high/low/close/volume, consult the
    Column Availability Matrix in the Claude system prompt. A missing column
    under your (data_mode, timeframe, source_file_type) silently resolves to an
    empty Series and your signal dict will crash at DataFrame construction.
    """

    fast_period = input.int(10, "Fast Period", min=2, max=100)
    slow_period = input.int(20, "Slow Period", min=2, max=200)

    # Uncomment when calculate() repeats the same param-independent work for
    # every parameter set on the same day:
    #
    # @day_start
    # def prep(self, df):
    #     return {
    #         "close_arr": np.array(df["close"]).astype(np.float64),
    #         "atr14": ta.atr(np.array(df["high"]), np.array(df["low"]), np.array(df["close"]), 14).astype(np.float64),
    #     }
    #
    # def calculate(self, df):
    #     close_arr = self._day["close_arr"]
    #     atr14 = self._day["atr14"]
    #     ...

    def calculate(self, df):
        close_arr = np.array(df["close"])
        fast = ta.sma(close_arr, self.fast_period)
        slow = ta.sma(close_arr, self.slow_period)

        return {
            "entry_long": cross_above(fast, slow),
            "exit_long": cross_below(fast, slow),
            "entry_short": cross_below(fast, slow),
            "exit_short": cross_above(fast, slow),
        }

// DISCLAIMER: This software is for educational and informational purposes only and does not constitute
// financial advice, investment advice, or trading advice. Past performance is not indicative of future
// results. Trading futures and other financial instruments involves substantial risk of loss. You are
// solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
// losses incurred. All rights reserved. (c) Quant Charts LLC

use qc_strategy_api::prelude::*;

/// [YOUR STRATEGY NAME]
///
/// Rust TBBO strategies run per-tick across every parameter combination in parallel.
/// You have full access to bid/ask/mid/spread/bid_size/ask_size on every tick, plus
/// any extra columns the parquet emitted via `data.col("name")`. Missing columns return
/// `None` so your strategy stays robust even on files that lack optional fields.
///
/// - `columns = [...]` (optional): a hint for the UI + loader. Undeclared columns still
///   work via `data.col("name")`; declaring them just surfaces the list in the inspector.
/// - `#[tag(...)]`  (optional): per-tag label/color metadata. Undeclared tag names still
///   emit; they just get auto-generated labels.
#[strategy(
    name = "My Strategy",
    description = "Strategy description",
    columns = ["volume", "delta"],
)]
#[tag(name = "trend_up", label = "Trend Up Entry", color = "#26A69A")]
#[tag(name = "trend_dn", label = "Trend Down Entry", color = "#EF5350")]
#[derive(Default)]
pub struct MyStrategy {
    // Declare each parameter with its range and default. The optimizer sweeps these
    // across the combinations you configure in the UI. Only fields annotated with
    // `#[param(...)]` are filled from the UI; any other field on this struct is
    // initialized via Default::default() so you can keep per-combo caches or state.
    #[param(default = 20, min = 5, max = 100, label = "Period")]
    pub period: usize,

    #[param(default = 2.0, min = 0.5, max = 5.0, step = 0.25, label = "Multiplier")]
    pub multiplier: f64,

    // Custom state (non-param): seed it in Default or compute it lazily in calculate().
    // It is re-built per combo, so treat it as scratch memory.
    #[allow(dead_code)]
    pub scratch: Vec<f64>,
}

impl Strategy for MyStrategy {
    // Optional per-day precomputation. Runs ONCE per day, before the combo sweep.
    // Cache heavy parameter-independent work here (ATR, bucket aggregations, etc.).
    fn prepare(data: &TickData) -> DayPrep {
        let mut prep = DayPrep::empty();
        let atr = ta::atr_bid_ask(&data.bid, &data.ask, 30);
        prep.insert_f64("atr", atr);
        prep
    }

    fn calculate(&self, data: &TickData, prep: &DayPrep) -> SignalOutput {
        let n = data.len();

        // Column access is free-form — any string the parquet has works.
        //   let vol   = data.col_or("volume", &[]);
        //   let delta = data.col_or("delta", &[]);
        //   let custom = data.col("my_custom_col");  // Option<&[f64]>
        // qc_log! writes to the Rust worker's stderr, which surfaces in the VSC output:
        //   qc_log!("loaded {} ticks, has_volume={}", n, data.has_volume());

        let (upper, middle, lower) = ta::bollinger(&data.mid, self.period, self.multiplier);
        let atr = prep.f64("atr").unwrap_or(&[]);

        let mut entry_long = vec![false; n];
        let mut exit_long = vec![false; n];
        let mut entry_short = vec![false; n];
        let mut exit_short = vec![false; n];
        let mut sl_long = vec![f64::NAN; n];
        let mut sl_short = vec![f64::NAN; n];
        // Tag arrays: same length as ticks, true when the condition holds.
        let mut trend_up = vec![false; n];
        let mut trend_dn = vec![false; n];

        for i in self.period..n {
            if data.mid[i] < lower[i] {
                entry_long[i] = true;
                if let Some(a) = atr.get(i) {
                    sl_long[i] = data.mid[i] - a * 2.0;
                }
                trend_up[i] = true;
            }
            if data.mid[i] > upper[i] {
                entry_short[i] = true;
                if let Some(a) = atr.get(i) {
                    sl_short[i] = data.mid[i] + a * 2.0;
                }
                trend_dn[i] = true;
            }
            if middle[i].is_finite() {
                exit_long[i] = data.mid[i] >= middle[i];
                exit_short[i] = data.mid[i] <= middle[i];
            }
        }

        SignalOutput::new(entry_long, exit_long, entry_short, exit_short)
            .with_sl_long(sl_long)
            .with_sl_short(sl_short)
            .with_entry_only_sltp()
            // Free-form tags: any name works. Declare them via #[tag(...)] above
            // for UI label/color, or leave them undeclared and the system will auto-assign.
            .with_tag("trend_up", trend_up)
            .with_tag("trend_dn", trend_dn)
    }
}

# qc-api: 1.0.7
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""ATR: Average True Range with regime tags (Python / OHLC).

Required columns: high, low, close.
Data mode: OHLC.

Baseline indicator. Plots ATR as a line and emits three regime tags
(low_atr / medium_atr / high_atr) defined relative to the day's median ATR.
Use these tags as filter / record sources on any strategy.

Default thresholds (multipliers of the day's median ATR):
  low_atr    : ATR < 0.7 * median
  medium_atr : 0.7 * median <= ATR <= 1.4 * median
  high_atr   : ATR > 1.4 * median
"""

import numpy as np
from quant_charts import indicator, input, plot, define_tag, ta


@indicator(
    name="ATR",
    description="ATR line + low/medium/high regime tags relative to day's median",
    overlay=False,
    data_mode="ohlc",
    required_columns=["high", "low", "close"],
)
class Atr:
    period = input.int(14, "ATR Period", min=2, max=500,
                       tooltip="ATR lookback in bars.")
    low_mult = input.float(0.7, "Low Threshold (x median)", min=0.0, max=10.0, step=0.05,
                           tooltip="ATR below this many medians = low_atr.")
    high_mult = input.float(1.4, "High Threshold (x median)", min=0.0, max=10.0, step=0.05,
                            tooltip="ATR above this many medians = high_atr.")
    line_color = input.color("#E0AF68", "Line Color")

    def calculate(self, df):
        high_arr = np.asarray(df["high"], dtype=np.float64)
        low_arr = np.asarray(df["low"], dtype=np.float64)
        close_arr = np.asarray(df["close"], dtype=np.float64)

        atr = ta.atr(high_arr, low_arr, close_arr, self.period)

        finite = atr[np.isfinite(atr)]
        median_atr = float(np.median(finite)) if finite.size else float("nan")
        low_thresh = median_atr * self.low_mult if np.isfinite(median_atr) else float("nan")
        high_thresh = median_atr * self.high_mult if np.isfinite(median_atr) else float("nan")

        plot(atr, "ATR", color=self.line_color, linewidth=2)

        finite_atr = np.isfinite(atr)
        low_atr = (atr < low_thresh) & finite_atr
        high_atr = (atr > high_thresh) & finite_atr
        medium_atr = finite_atr & ~low_atr & ~high_atr

        define_tag("low_atr", f"ATR(<{self.low_mult:.2f}x median)", color="#7AA2F7")
        define_tag("medium_atr", f"{self.low_mult:.2f}x .. {self.high_mult:.2f}x median", color="#A1A1AA")
        define_tag("high_atr", f"ATR(>{self.high_mult:.2f}x median)", color="#F7768E")

        return {
            "low_atr": low_atr,
            "medium_atr": medium_atr,
            "high_atr": high_atr,
        }

# qc-api: 1.0.7
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""Bands: EMA + ATR-band regime classifier (Python / OHLC).

Required columns: high, low, close.
Data mode: OHLC.

Demonstrates:
- ta.ema + ta.atr literal-period hoisting in @day_start
- Multiple plotted bands and fill() between them
- define_tag() for three regime states (trending, ranging, volatile)
- required_columns declared so SHM ships only OHLC (not order-flow extras)
- Conditional styling: bgcolor() per regime state
"""

import numpy as np
from quant_charts import (
    indicator, input, plot, fill, bgcolor, define_tag,
    ta, above, below, between,
)


@indicator(
    name="Bands",
    description="EMA + ATR-band regime classifier with three regime tags",
    overlay=True,
    data_mode="ohlc",
    required_columns=["high", "low", "close"],
)
class Bands:
    ema_period = input.int(50, "EMA Period", min=2, max=10000)
    atr_mult = input.float(2.0, "ATR Band Multiplier", min=0.05, max=100.0, step=0.05)
    vol_ratio = input.float(1.5, "High-Vol Ratio (atr20 / atr200)", min=0.0, max=100.0, step=0.05)
    trend_color = input.color("#7AA2F7", "Trend Band Color")
    range_color = input.color("#A1A1AA", "Range Band Color")

    def calculate(self, df):
        close_arr = np.asarray(df["close"], dtype=np.float64)
        high_arr = np.asarray(df["high"], dtype=np.float64)
        low_arr = np.asarray(df["low"], dtype=np.float64)
        atr20 = ta.atr(high_arr, low_arr, close_arr, 20)
        atr200 = ta.atr(high_arr, low_arr, close_arr, 200)

        # Param-dependent EMA: has to live here, not in @day_start.
        # alt: hoist a fixed-period EMA (e.g., 50) and skip sweeping ema_period
        ema = ta.ema(close_arr, self.ema_period)

        upper = ema + atr20 * self.atr_mult
        lower = ema - atr20 * self.atr_mult

        plot(ema, "EMA", color=self.trend_color, linewidth=2)
        plot(upper, "Upper Band", color=self.trend_color, linewidth=1, opacity=60)
        plot(lower, "Lower Band", color=self.trend_color, linewidth=1, opacity=60)
        fill("Upper Band", "Lower Band", color=self.trend_color, opacity=8)

        # alt: add a dashed midline reference at the daily VWAP equivalent
        # hline(0.0, "Zero", color="#63636e", linestyle="dotted")

        # Regime classification.
        # Trending: close outside the band AND price persistently in that direction.
        # Ranging: close within the band.
        # Volatile: short-term ATR materially above long-run baseline.
        trending_up = above(close_arr, upper)
        trending_dn = below(close_arr, lower)
        ranging = between(close_arr, lower, upper)
        high_vol = (atr20 > atr200 * self.vol_ratio) & np.isfinite(atr200)

        # Visualize regime via background highlights.
        bgcolor(trending_up, color="#26A69A", opacity=8)
        bgcolor(trending_dn, color="#EF5350", opacity=8)
        bgcolor(high_vol, color="#E0AF68", opacity=6)

        define_tag("trend_up", "Close above upper ATR band", color="#22C55E")
        define_tag("trend_down", "Close below lower ATR band", color="#EF4444")
        define_tag("ranging", "Close inside ATR band envelope", color="#A1A1AA")
        define_tag("high_volatility", f"ATR(20) > {self.vol_ratio:.2f} x ATR(200)", color="#E0AF68")

        return {
            "trend_up": trending_up,
            "trend_down": trending_dn,
            "ranging": ranging,
            "high_volatility": high_vol,
        }

# qc-api: 1.0.7
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""Order-flow: per-bar delta histogram + cumulative volume delta (Python / OHLC).

Required columns: high, low, close.
Optional columns: open, volume, delta, bid_vol, ask_vol, tickCount.
Data mode: OHLC. Designed for TBBO-aggregated bars carrying order-flow extras
but degrades gracefully when those columns are absent.

Why this is a separate pane (not on the price chart): delta and CVD are signed
volume counts, on a totally different scale from price. Mixing them with a
~$20k VWAP line in one pane collapses the y-axis and one of them becomes
invisible. Use the dedicated `vwap.py` overlay if you want VWAP on the price
pane alongside this.

Demonstrates:
- delta_series fallback chain (delta -> ask_vol-bid_vol -> sign(close-open)).
- cvd() helper (cumulative volume delta) on a separate normalized pane.
- plot_histogram_colored() with positive-vs-negative coloring on the delta pane.
- imbalance() helper applied to bid_vol / ask_vol when present, used for the
  heavy_buy / heavy_sell tags (no plotted output - the imbalance line and the
  delta line live on incompatible scales, so we surface the signal as tags).
"""

import numpy as np
from quant_charts import (
    indicator, input, plot, plot_histogram_colored, hline, define_tag,
    cvd, imbalance, delta_series, df_col_or,
    PlotType,
)


@indicator(
    name="Order-Flow",
    description="Per-bar delta histogram + CVD line, with bid/ask imbalance tags",
    overlay=False,
    data_mode="ohlc",
    required_columns=["high", "low", "close"],
)
class OrderFlow:
    imbalance_threshold = input.float(0.65, "Imbalance Threshold", min=0.5, max=1.0, step=0.01)
    pos_color = input.color("#26A69A", "Buy Pressure Color")
    neg_color = input.color("#EF5350", "Sell Pressure Color")

    def calculate(self, df):
        close_arr = np.asarray(df["close"], dtype=np.float64)
        n = len(close_arr)

        # delta_series resolves: delta -> (ask_vol-bid_vol) -> sign(close-open).
        delta_arr = delta_series(df)
        cvd_arr = cvd(delta_arr)

        # Per-bar delta histogram colored by direction. Sits on the same axis
        # as cvd: both are signed volume counts, scales are commensurate.
        delta_colors = np.where(delta_arr >= 0, self.pos_color, self.neg_color)
        plot_histogram_colored(delta_arr, "Delta", color=self.pos_color, colors=delta_colors)
        hline(0.0, "Zero", color="#63636e", linestyle="dashed")
        plot(cvd_arr, "CVD", color="#7AA2F7", linewidth=2, plot_type=PlotType.LINE)

        # bid/ask imbalance from TBBO-aggregated sizes per bar. Reported as
        # tags only - the imbalance ratio sits in [0, 1] and would dominate
        # the delta histogram if plotted on the same axis.
        bid_vol_arr = df_col_or(df, "bid_vol")
        ask_vol_arr = df_col_or(df, "ask_vol")
        if bid_vol_arr is not None and ask_vol_arr is not None:
            imb = imbalance(bid_vol_arr, ask_vol_arr)
            heavy_buy = imb > self.imbalance_threshold
            heavy_sell = imb < (1.0 - self.imbalance_threshold)
        else:
            heavy_buy = np.zeros(n, dtype=bool)
            heavy_sell = np.zeros(n, dtype=bool)

        define_tag("delta_positive", "Per-bar buy-side delta", color=self.pos_color)
        define_tag("delta_negative", "Per-bar sell-side delta", color=self.neg_color)
        define_tag("heavy_buy_pressure", f"Bid imbalance > {self.imbalance_threshold:.2f}", color=self.pos_color)
        define_tag("heavy_sell_pressure", f"Ask imbalance > {self.imbalance_threshold:.2f}", color=self.neg_color)

        return {
            "delta_positive": delta_arr > 0,
            "delta_negative": delta_arr < 0,
            "heavy_buy_pressure": heavy_buy,
            "heavy_sell_pressure": heavy_sell,
        }

# qc-api: 1.0.7
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""Volume Profile (Python / OHLC) - anchored profile with POC, VA, HVN/LVN.

Required columns: high, low, close, timestamp. Optional: volume.
Data mode: OHLC (use vp.rs / vp_orderflow.rs for tick-fidelity TBBO profiles).

Builds one horizontal volume histogram per anchor period (session or wall-clock
ET alignment) by binning each bar's typical price into fixed-width rows and
accumulating volume into the touched row. Computes:
  - POC (point of control)  : row with max volume
  - VAH / VAL               : edges of the value area (default 70% of total volume)
  - HVN levels              : local maxima above hvn_threshold of POC
  - LVN levels              : local minima below lvn_threshold of POC

Tags emitted (per-bar bool):
  at_poc            : close within proximity_ticks of POC
  inside_value_area : close between VAL and VAH
  above_vah         : close above VAH (price discovery up)
  below_val         : close below VAL (price discovery down)
  near_hvn          : close near any HVN level
  near_lvn          : close near any LVN level

With use_completed_vp on (default), tags for bar i reference the LAST FULLY
COMPLETED anchor period's VP, not the in-progress one. Bars in the first
anchor period of the session emit no tags. Mirrors the Rust vp.rs flag and
the strategy-side VpZoneRules.use_completed_vp semantics.

aligned_hour / aligned_30m / aligned_15m bucket on UTC milliseconds. ET is a
whole-hour offset from UTC for futures sessions, so these alignments are
identical between UTC and ET. Finer-than-15m alignments would require ET
conversion - not exposed here. For tick fidelity (every print binned, not just
bar typical price), use the Rust `vp.rs` indicator.
"""

import numpy as np
from quant_charts import (
    indicator, input, plot, hline, define_tag, volume_series, vp_visual,
)


@indicator(
    name="Volume Profile",
    description="Anchored volume profile with POC, value area, and HVN/LVN tags",
    overlay=True,
    data_mode="ohlc",
    required_columns=["high", "low", "close"],
)
class VolumeProfile:
    anchor_kind = input.string("aligned_hour", "Anchor",
                               options=["session", "aligned_hour", "aligned_30m", "aligned_15m"],
                               tooltip="When a fresh VP starts. session = one VP per trading day; "
                                       "aligned_* = wall-clock boundaries.")
    use_completed_vp = input.bool(True, "Use Completed VP",
                                  tooltip="When on, tags and lines reflect the LAST FULLY COMPLETED "
                                          "anchor period (the previous hour with aligned_hour) "
                                          "instead of the live in-progress profile. Strict "
                                          "anti-lookahead: no fires until the first period has "
                                          "archived (e.g. 1 hour into the session with aligned_hour).")
    row_size = input.float(0.25, "Row Size", min=0.01, max=100.0, step=0.01,
                           tooltip="Vertical bin size in price units. 0.25 = one MNQ tick. "
                                   "Smaller = finer detail, slower; larger = coarser zones.")
    value_area_pct = input.float(0.70, "Value Area %", min=0.10, max=0.99, step=0.01,
                                 tooltip="Cumulative share of period volume between VAL and VAH.")
    hvn_threshold = input.float(0.85, "HVN Threshold", min=0.30, max=1.00, step=0.05,
                                tooltip="Row volume must exceed this fraction of POC to qualify as an HVN.")
    lvn_threshold = input.float(0.20, "LVN Threshold", min=0.01, max=0.50, step=0.01,
                                tooltip="Row volume must be below this fraction of POC to qualify as an LVN.")
    proximity_ticks = input.int(2, "Proximity (ticks)", min=0, max=100,
                                tooltip="How close 'near' tags fire. Measured in row_size units.")
    poc_color = input.color("#E0AF68", "POC Color")
    va_color = input.color("#73DACA", "Value Area Color")
    render_histogram = input.bool(True, "Render Histogram",
                                  tooltip="Emit one horizontal histogram per anchor period. When off, "
                                          "only the last completed period's POC/VAH/VAL hlines are drawn.")
    histogram_color = input.color("#7AA2F7", "Histogram Color")
    histogram_align = input.string("right_of_range", "Histogram Align",
                                   options=["right_of_range", "left_of_range", "over_range", "pinned_right", "pinned_left"],
                                   tooltip="Where to anchor each period's histogram. pinned_* glues it to the chart edge regardless of pan.")
    histogram_width_px = input.int(80, "Histogram Width (px)", min=20, max=400, step=5)

    _ANCHOR_MS = {
        "aligned_hour": 3_600_000,
        "aligned_30m": 1_800_000,
        "aligned_15m": 900_000,
    }

    def _build_period_vp(self, high, low, close, vol):
        """Run the single-period POC / value-area / HVN / LVN computation.
        Returns None for empty / degenerate periods so the caller can skip them.

        Each bar's volume is spread uniformly across every price row its
        [low, high] range covers (difference-array + cumsum, O(n)). This is
        the standard OHLC volume-profile approximation. The old method charged
        the whole bar to one row at its typical price, which collapsed a wide
        bar's volume onto a single tick and produced a sparse, misleading
        profile. For true per-print fidelity use the Rust vp.rs / vp_orderflow.rs.
        """
        finite = (np.isfinite(high) & np.isfinite(low) & np.isfinite(close)
                  & np.isfinite(vol) & (vol > 0.0))
        if not finite.any():
            return None
        h = high[finite]
        l = low[finite]
        v = vol[finite]
        lo = float(np.min(l))
        hi = float(np.max(h))
        if not (np.isfinite(lo) and np.isfinite(hi)) or hi <= lo:
            return None

        bin_count = max(1, int(np.ceil((hi - lo) / self.row_size)) + 1)
        b_lo = np.clip(((l - lo) / self.row_size).astype(np.int64), 0, bin_count - 1)
        b_hi = np.clip(((h - lo) / self.row_size).astype(np.int64), 0, bin_count - 1)
        # uniform share per touched row; difference array then cumsum so each
        # bar contributes to its whole range in O(1) regardless of width
        share = v / (b_hi - b_lo + 1).astype(np.float64)
        diff = np.zeros(bin_count + 1, dtype=np.float64)
        np.add.at(diff, b_lo, share)
        np.add.at(diff, b_hi + 1, -share)
        rows = np.cumsum(diff[:-1])
        total = float(rows.sum())
        if total <= 0.0:
            return None

        poc_bin = int(np.argmax(rows))
        poc_price = lo + (poc_bin + 0.5) * self.row_size
        poc_vol = float(rows[poc_bin])

        target = total * self.value_area_pct
        cum = poc_vol
        lo_b = hi_b = poc_bin
        while cum < target and (lo_b > 0 or hi_b < bin_count - 1):
            left = rows[lo_b - 1] if lo_b > 0 else -1.0
            right = rows[hi_b + 1] if hi_b < bin_count - 1 else -1.0
            if right >= left:
                hi_b += 1
                cum += rows[hi_b]
            else:
                lo_b -= 1
                cum += rows[lo_b]
        val_p = lo + (lo_b + 0.5) * self.row_size
        vah_p = lo + (hi_b + 0.5) * self.row_size

        hvn_levels = []
        lvn_levels = []
        for i in range(1, bin_count - 1):
            if i == poc_bin:
                continue
            r = rows[i]
            if r >= self.hvn_threshold * poc_vol and r >= rows[i - 1] and r >= rows[i + 1]:
                hvn_levels.append(lo + (i + 0.5) * self.row_size)
            elif r <= self.lvn_threshold * poc_vol and r <= rows[i - 1] and r <= rows[i + 1] and r > 0:
                lvn_levels.append(lo + (i + 0.5) * self.row_size)

        return {
            "poc_price": poc_price,
            "vah": vah_p,
            "val": val_p,
            "hvn_levels": hvn_levels,
            "lvn_levels": lvn_levels,
            "bins": rows,
            "price_min": lo,
            "total_volume": total,
        }

    def calculate(self, df):
        high = np.asarray(df["high"], dtype=np.float64)
        low = np.asarray(df["low"], dtype=np.float64)
        close = np.asarray(df["close"], dtype=np.float64)
        vol = volume_series(df)
        n = len(close)
        if n == 0:
            return {}

        ts = np.asarray(df["timestamp"], dtype=np.int64) if "timestamp" in df.columns else None

        # Group bars into anchor periods. UTC ms alignment is correct for hour /
        # 30m / 15m because ET is a whole-hour offset (EST=-5, EDT=-4); those
        # boundaries land on the same instants in UTC.
        if self.anchor_kind == "session" or ts is None:
            anchor_idx = np.zeros(n, dtype=np.int64)
            bucket_starts = np.array([int(ts[0]) if ts is not None and ts.size > 0 else 0], dtype=np.int64)
        else:
            period_ms = self._ANCHOR_MS.get(self.anchor_kind, 3_600_000)
            bucket = (ts // period_ms) * period_ms
            bucket_starts, anchor_idx = np.unique(bucket, return_inverse=True)

        num_periods = int(bucket_starts.size)

        period_vps = [None] * num_periods
        period_anchor_ts = [int(bucket_starts[p]) for p in range(num_periods)]
        period_last_ts = [0] * num_periods
        for p in range(num_periods):
            mask = anchor_idx == p
            if not mask.any():
                continue
            res = self._build_period_vp(high[mask], low[mask], close[mask], vol[mask])
            if res is None:
                continue
            period_vps[p] = res
            if ts is not None:
                p_ts = ts[mask]
                if p_ts.size > 0:
                    period_last_ts[p] = int(p_ts[-1])

        # Per-bar tag reference. use_completed_vp: walk back from anchor_idx-1
        # to find the first non-empty completed period. Plain mode: use the
        # bar's own period (in-progress allowed). Bars in the first period get
        # no tags when use_completed_vp is on - matches the Rust warmup gate.
        prox = self.proximity_ticks * self.row_size
        at_poc = np.zeros(n, dtype=bool)
        inside_va = np.zeros(n, dtype=bool)
        above_vah = np.zeros(n, dtype=bool)
        below_val = np.zeros(n, dtype=bool)
        near_hvn_arr = np.zeros(n, dtype=bool)
        near_lvn_arr = np.zeros(n, dtype=bool)

        ref_for_period = [None] * num_periods
        for p in range(num_periods):
            base = p - 1 if self.use_completed_vp else p
            while base >= 0 and period_vps[base] is None:
                base -= 1
            ref_for_period[p] = period_vps[base] if base >= 0 else None

        for i in range(n):
            ref = ref_for_period[int(anchor_idx[i])]
            if ref is None:
                continue
            c = close[i]
            if abs(c - ref["poc_price"]) <= prox:
                at_poc[i] = True
            if c >= ref["val"] and c <= ref["vah"]:
                inside_va[i] = True
            if c > ref["vah"]:
                above_vah[i] = True
            if c < ref["val"]:
                below_val[i] = True
            for lvl in ref["hvn_levels"]:
                if abs(c - lvl) <= prox:
                    near_hvn_arr[i] = True
                    break
            for lvl in ref["lvn_levels"]:
                if abs(c - lvl) <= prox:
                    near_lvn_arr[i] = True
                    break

        # hline fallback: when not rendering histograms, draw POC / VAH / VAL
        # for the most recent COMPLETED period. With use_completed_vp on this
        # excludes the in-progress final period; without it, last non-empty.
        last_completed = num_periods - 1
        if self.use_completed_vp:
            last_completed -= 1
        while last_completed >= 0 and period_vps[last_completed] is None:
            last_completed -= 1
        if last_completed >= 0:
            r = period_vps[last_completed]
            hline(r["poc_price"], "POC", color=self.poc_color, linestyle="solid")
            hline(r["vah"], "VAH", color=self.va_color, linestyle="dashed")
            hline(r["val"], "VAL", color=self.va_color, linestyle="dashed")

        # One histogram per completed period. With use_completed_vp we skip the
        # in-progress final period so its bars do not render. Level lines
        # forward-project to the NEXT period (when this completed VP is driving
        # tags), mirroring vp.rs.
        if self.render_histogram and ts is not None:
            max_visual = num_periods - 1 if self.use_completed_vp else num_periods
            for p in range(max_visual):
                v = period_vps[p]
                if v is None:
                    continue
                anchor_ts = period_anchor_ts[p]
                # next period's anchor or this period's last bar ts
                end_ts = period_anchor_ts[p + 1] if p + 1 < num_periods else period_last_ts[p]
                if self.use_completed_vp:
                    line_anchor = end_ts
                    line_end = period_anchor_ts[p + 2] if p + 2 < num_periods else int(ts[-1])
                    if line_end < line_anchor:
                        line_end = line_anchor
                else:
                    line_anchor = anchor_ts
                    line_end = end_ts
                vp_visual(
                    anchor_ts=int(anchor_ts),
                    end_ts=int(end_ts),
                    price_min=float(v["price_min"]),
                    price_step=float(self.row_size),
                    bins=v["bins"],
                    poc_price=float(v["poc_price"]),
                    vah=float(v["vah"]),
                    val=float(v["val"]),
                    color=self.histogram_color,
                    poc_color=self.poc_color,
                    value_area_color=self.va_color,
                    opacity=60,
                    width_px=int(self.histogram_width_px),
                    align=self.histogram_align,
                    style="bars",
                    hvn_levels=v["hvn_levels"] if v["hvn_levels"] else None,
                    lvn_levels=v["lvn_levels"] if v["lvn_levels"] else None,
                    draw_level_lines=True,
                    level_lines_anchor_ts=int(line_anchor),
                    level_lines_end_ts=int(line_end),
                )

        define_tag("at_poc", "Close near POC", color="#E0AF68")
        define_tag("inside_value_area", "Close between VAL and VAH", color="#73DACA")
        define_tag("above_vah", "Close above VAH", color="#26A69A")
        define_tag("below_val", "Close below VAL", color="#EF5350")
        define_tag("near_hvn", "Close near a high-volume node", color="#7AA2F7")
        define_tag("near_lvn", "Close near a low-volume node", color="#F7768E")

        return {
            "at_poc": at_poc,
            "inside_value_area": inside_va,
            "above_vah": above_vah,
            "below_val": below_val,
            "near_hvn": near_hvn_arr,
            "near_lvn": near_lvn_arr,
        }

# qc-api: 1.0.7
# DISCLAIMER: This software is for educational and informational purposes only and does not constitute
# financial advice, investment advice, or trading advice. Past performance is not indicative of future
# results. Trading futures and other financial instruments involves substantial risk of loss. You are
# solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
# losses incurred. All rights reserved. (c) Quant Charts LLC

"""VWAP: session VWAP with deviation bands and tags (Python / OHLC).

Required columns: high, low, close.
Optional columns: vwap (precomputed by upstream), volume (improves accuracy).
Data mode: OHLC.

Baseline indicator. Builds VWAP from typical price * volume, draws +/- band_mult
sigma deviation bands, and emits three tags. Falls back to the parquet's `vwap`
column when present; otherwise computes session VWAP from typical price + volume.
On parquets that ship neither volume nor a precomputed vwap, falls back to a
simple typical-price cumulative average so the line still renders.

Tags:
  above_vwap_band  : close above VWAP + band_mult*sigma
  below_vwap_band  : close below VWAP - band_mult*sigma
  inside_vwap_band : close within +/- band_mult*sigma of VWAP
"""

import numpy as np
from quant_charts import indicator, input, plot, fill, define_tag, vwap_series, volume_series


@indicator(
    name="VWAP",
    description="Session VWAP with deviation bands and above/inside/below tags",
    overlay=True,
    data_mode="ohlc",
    required_columns=["high", "low", "close"],
)
class Vwap:
    band_mult = input.float(2.0, "Band Multiplier (x sigma)", min=0.0, max=10.0, step=0.05,
                            tooltip="Deviation-band width as a multiple of session-cumulative VWAP sigma.")
    line_color = input.color("#7AA2F7", "VWAP Color")
    band_color = input.color("#73DACA", "Band Color")

    def calculate(self, df):
        close_arr = np.asarray(df["close"], dtype=np.float64)

        # vwap_series handles the column-priority fallback: precomputed `vwap`
        # column when present, else session-cumulative VWAP from typical price
        # * volume_series(df). Works on every parquet shape.
        vwap = vwap_series(df)
        vol_safe = volume_series(df)

        # Deviation: cumulative variance of (close - VWAP) weighted by volume.
        diff = close_arr - vwap
        cum_var_num = np.cumsum((diff * diff) * vol_safe)
        cum_vol = np.cumsum(vol_safe)
        var = cum_var_num / np.where(cum_vol > 0.0, cum_vol, np.nan)
        sigma = np.sqrt(np.maximum(var, 0.0))

        upper = vwap + self.band_mult * sigma
        lower = vwap - self.band_mult * sigma

        plot(vwap, "VWAP", color=self.line_color, linewidth=2)
        plot(upper, "VWAP Upper", color=self.band_color, linewidth=1, opacity=60)
        plot(lower, "VWAP Lower", color=self.band_color, linewidth=1, opacity=60)
        fill("VWAP Upper", "VWAP Lower", color=self.band_color, opacity=8)

        finite_band = np.isfinite(upper) & np.isfinite(lower)
        above_band = (close_arr > upper) & finite_band
        below_band = (close_arr < lower) & finite_band
        inside_band = finite_band & ~above_band & ~below_band

        define_tag("above_vwap_band", f"Close > VWAP + {self.band_mult:.2f}x sigma", color="#26A69A")
        define_tag("below_vwap_band", f"Close < VWAP - {self.band_mult:.2f}x sigma", color="#EF5350")
        define_tag("inside_vwap_band", f"Close within +/- {self.band_mult:.2f}x sigma of VWAP", color="#A1A1AA")

        return {
            "above_vwap_band": above_band,
            "below_vwap_band": below_band,
            "inside_vwap_band": inside_band,
        }

//! qc-api: 1.0.7
// DISCLAIMER: This software is for educational and informational purposes only and does not constitute
// financial advice, investment advice, or trading advice. Past performance is not indicative of future
// results. Trading futures and other financial instruments involves substantial risk of loss. You are
// solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
// losses incurred. All rights reserved. (c) Quant Charts LLC

//! ATR (Rust / OHLC bars).
//!
//! Required columns: high, low, close. Data mode: OHLC bars.
//!
//! Wilder ATR over `period` bars. The chart timeframe pill picks the bar
//! cadence (1m, 5m, ...). Three regime tags fire based on ATR vs the day's
//! median bar-ATR. Renders only in OHLC chart views.

use qc_strategy_api::prelude::*;

#[indicator(
    name = "ATR (Rust)",
    description = "Wilder ATR with low/medium/high regime tags. OHLC-mode.",
    overlay = false,
    data_mode = "ohlc",
    timeframe = "1m"
)]
#[tag(name = "low_atr",    label = "Low ATR",    color = "#7AA2F7", description = "Bar ATR below low_mult x median")]
#[tag(name = "medium_atr", label = "Medium ATR", color = "#A1A1AA", description = "Bar ATR between low_mult and high_mult x median")]
#[tag(name = "high_atr",   label = "High ATR",   color = "#F7768E", description = "Bar ATR above high_mult x median")]
#[derive(Default)]
pub struct Atr {
    #[param(default = 14, min = 2, max = 500, label = "ATR Period (bars)",
            tooltip = "ATR lookback in bars at the indicator's declared timeframe.")]
    pub period: usize,

    #[param(default = 0.7, min = 0.0, max = 10.0, step = 0.05, label = "Low Threshold (x median)",
            tooltip = "Bar ATR below this many medians = low_atr.")]
    pub low_mult: f64,

    #[param(default = 1.4, min = 0.0, max = 10.0, step = 0.05, label = "High Threshold (x median)",
            tooltip = "Bar ATR above this many medians = high_atr.")]
    pub high_mult: f64,
}

impl OhlcIndicator for Atr {
    fn calculate(&self, data: &BarData, _prep: &DayPrep) -> IndicatorOutput {
        let n = data.len();
        if n == 0 || self.period < 2 {
            return IndicatorOutput::new().with_overlay(false);
        }

        // Wilder ATR over bar high/low/close.
        let mut atr = vec![f64::NAN; n];
        if n > self.period {
            let mut tr = vec![0.0; n];
            tr[0] = (data.high[0] - data.low[0]).max(0.0);
            for i in 1..n {
                let h = data.high[i];
                let l = data.low[i];
                let pc = data.close[i - 1];
                tr[i] = (h - l).max((h - pc).abs()).max((l - pc).abs());
            }
            let p = self.period as f64;
            let seed: f64 = tr[..self.period].iter().sum::<f64>() / p;
            atr[self.period - 1] = seed;
            for i in self.period..n {
                atr[i] = (atr[i - 1] * (p - 1.0) + tr[i]) / p;
            }
        }

        // Regime thresholds from the day's median bar ATR.
        let mut finite: Vec<f64> = atr.iter().copied().filter(|v| v.is_finite()).collect();
        let median_atr = if finite.is_empty() {
            f64::NAN
        } else {
            finite.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
            finite[finite.len() / 2]
        };
        let low_thresh = median_atr * self.low_mult;
        let high_thresh = median_atr * self.high_mult;

        let mut low_atr = vec![false; n];
        let mut medium_atr = vec![false; n];
        let mut high_atr = vec![false; n];
        for i in 0..n {
            let v = atr[i];
            if !v.is_finite() {
                continue;
            }
            if v < low_thresh {
                low_atr[i] = true;
            } else if v > high_thresh {
                high_atr[i] = true;
            } else {
                medium_atr[i] = true;
            }
        }

        IndicatorOutput::new()
            .with_overlay(false)
            .plot_line("ATR", atr, "#E0AF68")
            .with_tag("low_atr", low_atr)
            .with_tag("medium_atr", medium_atr)
            .with_tag("high_atr", high_atr)
    }
}

//! qc-api: 1.0.7
// DISCLAIMER: This software is for educational and informational purposes only and does not constitute
// financial advice, investment advice, or trading advice. Past performance is not indicative of future
// results. Trading futures and other financial instruments involves substantial risk of loss. You are
// solely responsible for your own trading decisions. Quant Charts LLC assumes no liability for any
// losses incurred. All rights reserved. (c) Quant Charts LLC

//! Order-Flow (Rust / TBBO).
//!
//! Required columns: bid, ask, bid_size, ask_size (TBBO native).
//! Optional columns: delta (used by CVD; falls back to ask-bid sign if absent).
//! Data mode: TBBO (tick).
//!
//! Pure imbalance + CVD across the day. Tags fire from the smoothed
//! imbalance (bid_dominant / ask_dominant) and from the CVD slope vs
//! `cvd_lookback` ticks ago (cvd_rising / cvd_falling). Use these as
//! filter / record tags on a TBBO strategy or for analyzer membership
//! filters.
//!
//! Pair with `vp_orderflow.rs` for zone-conditioned dominance tags.
//!
//! Note: this indicator runs on a separate normalized pane (overlay = false),
//! so it intentionally does NOT plot price-scale series. Mixing a [0, 1]
//! imbalance histogram with a ~$20,000 price line collapses the y-axis.

use qc_strategy_api::prelude::*;

#[indicator(
    name = "Order-Flow",
    description = "CVD + bid/ask dominance tags from TBBO sizes",
    overlay = false,
    data_mode = "tick",
    // Per-tick output (smoothed CVD over raw ticks). In OHLC view the chart
    // can't align ~700k tick points to ~390 bars meaningfully, so the UI
    // hides this indicator there. Switch to tick view to render it.
    cross_view = false
)]
#[tag(name = "bid_dominant",  label = "Bid Dominant",  color = "#26A69A", description = "Imbalance > 0.5 + threshold (heavy bids)")]
#[tag(name = "ask_dominant",  label = "Ask Dominant",  color = "#EF5350", description = "Imbalance < 0.5 - threshold (heavy asks)")]
#[tag(name = "cvd_rising",    label = "CVD Rising",    color = "#73DACA", description = "Smoothed CVD higher than `cvd_lookback` ticks ago")]
#[tag(name = "cvd_falling",   label = "CVD Falling",   color = "#F7768E", description = "Smoothed CVD lower than `cvd_lookback` ticks ago")]
#[derive(Default)]
pub struct OrderFlow {
    #[param(default = 0.20, min = 0.0, max = 0.49, step = 0.01, label = "Imbalance Threshold",
            tooltip = "Distance from 0.5 that qualifies as 'dominant' pressure. 0 = always-on; \
                       0.45 = only the most extreme one-sided ticks.")]
    pub imbalance_threshold: f64,

    #[param(default = 500, min = 1, max = 200000, label = "Smoothing Window (ticks)",
            tooltip = "Rolling-mean window applied to the imbalance histogram, in ticks. \
                       ~500 ticks ~ 15s on MNQ TBBO; 1 = no smoothing.")]
    pub smoothing: usize,

    #[param(default = 5000, min = 2, max = 1000000, label = "CVD Lookback (ticks)",
            tooltip = "Window for the CVD-rising / CVD-falling direction tags. \
                       ~5000 ticks ~ 2.5min on MNQ; tighter = noisier flips.")]
    pub cvd_lookback: usize,
}

impl Indicator for OrderFlow {
    fn prepare(data: &TickData) -> DayPrep {
        let mut prep = DayPrep::empty();
        // CVD is param-independent; compute once per day.
        if let Some(delta) = data.col("delta") {
            prep.insert_f64("cvd", cvd(delta));
        }
        prep
    }

    fn calculate(&self, data: &TickData, prep: &DayPrep) -> IndicatorOutput {
        let n = data.len();

        // Imbalance + smoothed. This pane is normalized [0, 1] - keep all
        // plotted series in that range so the y-axis isn't blown out by a
        // price-scale value bleeding into the chart.
        let raw_imb = imbalance(&data.bid_size, &data.ask_size);
        let imb_smooth = if self.smoothing > 1 {
            rolling_mean(&raw_imb, self.smoothing)
        } else {
            raw_imb.clone()
        };

        // Tag arrays.
        let upper = 0.5 + self.imbalance_threshold;
        let lower = 0.5 - self.imbalance_threshold;
        let mut bid_dominant = vec![false; n];
        let mut ask_dominant = vec![false; n];
        for i in 0..n {
            let v = imb_smooth[i];
            if !v.is_finite() { continue; }
            if v > upper { bid_dominant[i] = true; }
            else if v < lower { ask_dominant[i] = true; }
        }

        // CVD direction tags. CVD itself is hoisted in prepare(); only the
        // rising/falling comparison runs here (param-dependent on cvd_lookback).
        // Take an owned Vec from either path so the borrow checker stays happy.
        let mut cvd_rising = vec![false; n];
        let mut cvd_falling = vec![false; n];
        let cvd_owned: Option<Vec<f64>> = if let Some(c) = prep.f64("cvd") {
            Some(c.to_vec())
        } else {
            data.col("delta").map(|d| cvd(d))
        };
        if let Some(cv) = cvd_owned.as_ref() {
            let lk = self.cvd_lookback.min(n.saturating_sub(1));
            for i in lk..n {
                let now = cv[i];
                let then = cv[i - lk];
                if now.is_finite() && then.is_finite() {
                    if now > then { cvd_rising[i] = true; }
                    else if now < then { cvd_falling[i] = true; }
                }
            }
        }

        // Per-bar coloring on the imbalance histogram: green when bid-dominant,
        // red when ask-dominant, default cyan otherwise. Single pass; the
        // dominance booleans are reused below for the tag arrays so this is
        // free.
        let mut bar_colors: Vec<Option<String>> = Vec::with_capacity(n);
        for i in 0..n {
            if bid_dominant[i] { bar_colors.push(Some("#26A69A".to_string())); }
            else if ask_dominant[i] { bar_colors.push(Some("#EF5350".to_string())); }
            else { bar_colors.push(None); }
        }

        // Output: imbalance histogram + threshold hlines, all on [0, 1] scale.
        // Tags fire the dominance + CVD-direction signals downstream into the
        // analyzer's tag filter expression and per-tag stats.
        IndicatorOutput::new()
            .with_overlay(false)
            .plot_histogram_colored("Imbalance", imb_smooth, "#73DACA", bar_colors)
            .hline("Balanced", 0.5, "#63636e")
            .hline("Bid Threshold", upper, "#26A69A")
            .hline("Ask Threshold", lower, "#EF5350")
            .with_tag("bid_dominant", bid_dominant)
            .with_tag("ask_dominant", ask_dominant)
            .with_tag("cvd_rising", cvd_rising)
            .with_tag("cvd_falling", cvd_falling)
    }
}