(() => {
  const BB_PERIOD = 20;
  const PAC_PERIOD = 10;
  const FLAT_BAND_SMOOTH_PERIOD = 6; // smoothing for BB bands in flat calc
  const FLAT_MID_PCT = 0.0007; // 0.07% midline change threshold
  const TOL = 1e-8;
  const isNum = Number.isFinite;

  const series = [open, high, low, close].map((arr) =>
    Array.isArray(arr) ? arr : []
  );
  const total = Math.min(...series.map((arr) => arr.length));
  if (!Number.isFinite(total) || total <= 1) return null;

  const closed = total - 1;
  const last = closed - 1; // last closed candle
  const minBars = Math.max(BB_PERIOD + FLAT_BAND_SMOOTH_PERIOD, PAC_PERIOD);
  if (last < minBars - 1) return null;

  const sanitize = (arr) =>
    arr.slice(0, closed).map((value) => {
      const num = Number(value);
      return isNum(num) ? num : null;
    });

  const O = sanitize(series[0]);
  const H = sanitize(series[1]);
  const L = sanitize(series[2]);
  const C = sanitize(series[3]);

  const sma = (arr, period) => {
    const n = arr.length;
    const out = new Array(n).fill(null);
    if (period <= 0 || n < period) return out;
    for (let i = period - 1; i < n; i++) {
      let sum = 0;
      let count = 0;
      for (let j = i - period + 1; j <= i; j++) {
        const v = arr[j];
        if (!isNum(v)) {
          count = 0;
          break;
        }
        sum += v;
        count++;
      }
      if (count === period) out[i] = sum / period;
    }
    return out;
  };

  const ema = (arr, period) => {
    const n = arr.length;
    const out = new Array(n).fill(null);
    if (period <= 0 || n < period) return out;
    let seed = 0;
    for (let i = 0; i < period; i++) {
      const v = arr[i];
      if (!isNum(v)) return out;
      seed += v;
    }
    seed /= period;
    out[period - 1] = seed;
    let emaVal = seed;
    const alpha = 2 / (period + 1);
    for (let i = period; i < n; i++) {
      const v = arr[i];
      if (!isNum(v)) {
        out[i] = emaVal;
        continue;
      }
      emaVal = alpha * v + (1 - alpha) * emaVal;
      out[i] = emaVal;
    }
    return out;
  };

  const stdev = (arr, period) => {
    const n = arr.length;
    const out = new Array(n).fill(null);
    if (period <= 0 || n < period) return out;
    for (let i = period - 1; i < n; i++) {
      let sum = 0;
      let sumSq = 0;
      let count = 0;
      for (let j = i - period + 1; j <= i; j++) {
        const v = arr[j];
        if (!isNum(v)) {
          count = 0;
          break;
        }
        sum += v;
        sumSq += v * v;
        count++;
      }
      if (count !== period) continue;
      const mean = sum / period;
      const variance = Math.max(0, sumSq / period - mean * mean);
      out[i] = Math.sqrt(variance);
    }
    return out;
  };

  const midline = sma(C, BB_PERIOD);
  const dev = stdev(C, BB_PERIOD);
  const bbUpper = midline.map((mid, idx) =>
    isNum(mid) && isNum(dev[idx]) ? mid + 2 * dev[idx] : null
  );
  const bbLower = midline.map((mid, idx) =>
    isNum(mid) && isNum(dev[idx]) ? mid - 2 * dev[idx] : null
  );
  const bbUpperSmooth = sma(bbUpper, FLAT_BAND_SMOOTH_PERIOD);
  const bbLowerSmooth = sma(bbLower, FLAT_BAND_SMOOTH_PERIOD);
  const bandWidthSmooth = bbUpperSmooth.map((upper, idx) =>
    isNum(upper) && isNum(bbLowerSmooth[idx]) ? upper - bbLowerSmooth[idx] : null
  );

  const upperPac = ema(H, PAC_PERIOD);
  const lowerPac = ema(L, PAC_PERIOD);

  const isBandNarrowing = (idx) => {
    const prevIdx = idx - 1;
    if (prevIdx < 0) return false;
    const currWidth = bandWidthSmooth[idx];
    const prevWidth = bandWidthSmooth[prevIdx];
    if (![currWidth, prevWidth].every(isNum)) return false;
    return currWidth < prevWidth - TOL;
  };

  const isFlat = (idx) => {
    const prevIdx = idx - 1;
    if (prevIdx < 0) return false;
    const currMid = midline[idx];
    const prevMid = midline[prevIdx];
    if (![currMid, prevMid].every(isNum)) return false;
    const denom = Math.abs(prevMid);
    if (denom <= TOL) return false;
    const pct = Math.abs(currMid - prevMid) / denom;
    if (pct <= FLAT_MID_PCT + TOL) return true;
    return isBandNarrowing(idx);
  };

  if (isFlat(last)) return null;

  const colorAt = (idx) => {
    const closeVal = C[idx];
    const upper = upperPac[idx];
    const lower = lowerPac[idx];
    if (![closeVal, upper, lower].every(isNum)) return 'NEUTRAL';
    if (closeVal >= upper - TOL) return 'BLUE';
    if (closeVal <= lower + TOL) return 'RED';
    return 'NEUTRAL';
  };

  const isDoji = (idx) => {
    const openVal = O[idx];
    const closeVal = C[idx];
    return isNum(openVal) && isNum(closeVal) && Math.abs(closeVal - openVal) <= TOL;
  };

  const hasTwoDojiBefore = (idx) => {
    const prev = idx - 1;
    if (prev < 0) return false;
    return isDoji(idx) && isDoji(prev);
  };

  const standardColorAt = (idx) => {
    const openVal = O[idx];
    const closeVal = C[idx];
    if (![openVal, closeVal].every(isNum)) return 'NEUTRAL';
    if (closeVal > openVal + TOL) return 'BULL';
    if (closeVal < openVal - TOL) return 'BEAR';
    return 'DOJI';
  };

  const midlineSupports = (idx) => {
    const prevIdx = idx - 1;
    if (prevIdx < 0) return false;
    const currMid = midline[idx];
    const prevMid = midline[prevIdx];
    if (![currMid, prevMid].every(isNum)) return false;
    const denom = Math.abs(prevMid);
    if (denom <= TOL) return false;
    const pct = Math.abs(currMid - prevMid) / denom;
    if (pct <= FLAT_MID_PCT + TOL) return false;
    if (isBandNarrowing(idx)) return false;
    return true;
  };

  const signalFrom = (idx) => {
    if (idx < 0) return null;
    let signal = null;

    for (let i = 0; i <= idx; i++) {
      const closeVal = C[i];
      const midVal = midline[i];
      if (![closeVal, midVal].every(isNum)) {
        signal = null;
        continue;
      }

      if (hasTwoDojiBefore(i)) {
        signal = null;
        continue;
      }

      if (!midlineSupports(i)) {
        signal = null;
        continue;
      }

      if (isDoji(i)) {
        if (signal) {
          continue;
        }
        const prevIdx = i - 1;
        if (prevIdx < 0) {
          signal = null;
          continue;
        }
        const prevClose = C[prevIdx];
        const prevMid = midline[prevIdx];
        const prevColor = colorAt(prevIdx);
        if (![prevClose, prevMid].every(isNum)) {
          signal = null;
          continue;
        }
        if (prevColor === 'BLUE' && prevClose > prevMid + TOL) {
          signal = 'BUY';
        } else if (prevColor === 'RED' && prevClose < prevMid - TOL) {
          signal = 'SELL';
        } else {
          signal = null;
        }
        continue;
      }

      const standardColor = standardColorAt(i);
      const color = colorAt(i);
      const buyStart = color === 'BLUE' && closeVal > midVal + TOL;
      const sellStart = color === 'RED' && closeVal < midVal - TOL;

      if (signal === 'BUY' && !buyStart) {
        signal = null;
      } else if (signal === 'SELL' && !sellStart) {
        signal = null;
      } else if (signal === 'BUY' && standardColor === 'BEAR') {
        // Priority 2 (midline change) supports, so ignore standard color.
      } else if (signal === 'SELL' && standardColor === 'BULL') {
        // Priority 2 (midline change) supports, so ignore standard color.
      }

      if (!signal) {
        if (buyStart) {
          signal = 'BUY';
        } else if (sellStart) {
          signal = 'SELL';
        }
      }
    }

    return signal;
  };

  return signalFrom(last);
})();