// Design notes.

//

// NG stands for "Non-Garbage"

//

// !Design notes end

sclass NGSStrategy2 extends G22CandleBasedStrategyWithTrailingStop is IntegrityCheckable {

  settable int period1 = 100; // the "slow" MA

  settable int period2 = 5;   // the fast MA (for opening)

  settable double maMinMove = 0.07; // MA trend threshold

  settable double maMoveHysteresis = 0.01; // MA trend non-oscillation threshold

  settable Side longSide = new(1);

  settable Side shortSide = new(-1);

    // false = only manual openLong() and openShort(),

  // not based on indicators.

  // true = auto-open positions indefinitely depending on

  // indicators.

  settable bool autoPositions = true;

  // temporal fields follow

  S fieldsToReset() {

    ret lineCombine(super.fieldsToReset(), [[

      ma1 ma2 lastMA1 maMove movingAverage1_cache movingAverage2_cache

      maMoveHistory maDirection maDirectionHistory

    ]]);

  }

  settable double ma1;

  settable double ma2;

  settable double lastMA1 = Double.NaN;

  settable double maMove;

  settable int maDirection;

  // Too big, disabling this by default now

  gettable TickerSequence maMoveHistory/* = new TickerSequence("maMove")*/;

  gettable TickerSequence maDirectionHistory = new TickerSequence("maDirection");

  settable transient O visualizer;

  selfType emptyClone() {

    selfType clone = cast super.emptyClone();

    clone.longSide(longSide.emptyClone(clone));

    clone.shortSide(shortSide.emptyClone(clone));

    ret clone;

  }

  // Side = logic for one side (long/short = direction 1/-1)

  record noeq Side(int direction) {

    // Our condition is:

    // Price has to be in a band close to the MA first (band 1)

    // and then move into a band further away from the MA (band 2)

    // Are we allowed to open positions in this direction at all?

    settable bool enabled = true;

    // First band (close to MA)

    settable DoubleRange band1 = new(0.2, 0.6);

    // Second band

    settable DoubleRange band2 = new(0.6, 1.0);

    // Percentage to close the position at (below band/above band)

    settable double closeLevel = 0;

    // Do we require the MA to go in our direction?

    // (If no, we just require it to not go the other direction.)

    settable bool needMADirection = true;

    // temporal fields follow

    selfType emptyClone(NGSStrategy2 stratClone) {

      ret copyFields(this, stratClone.new Side(),

        identifiers("direction enabled band1 band2 closeLevel"));

    }

    // Has price visited band1 recently?

    settable bool wasInBand1;

    // convert percent band to current price range

    DoubleRange instantiateBand(DoubleRange band, double ma1 default ma1) {

      ret doubleRange(

        maPlusPercent(ma1, direction*band.start),

        maPlusPercent(ma1, direction*band.end)).sort();

    }

    double priceToPercent(double price, double ma1 default ma1) {

      ret (price/ma1-1)*direction*100;

    }

    double relativePrice() {

      ret priceToPercent(currentPrice());

    }

    void step {

      var relativePrice = relativePrice();

      // close if too close to band/beyond band

      if (relativePrice < closeLevel && sign(drift()) == direction) {

        closeAllPositions(direction > 0 ? "Below band" : "Above band");

      }

      // price on wrong side => reset

      if (relativePrice < 0) wasInBand1(false);

      // Above band2 => reset

      if (relativePrice > band2.end) wasInBand1(false);

      // We hit band 1

      if (band1.contains(relativePrice)) wasInBand1(true);

      if (autoPositions && enabled && wasInBand1 && band2.contains(relativePrice)

        && ma2*direction < currentPrice()*direction

        && (needMADirection ? maDirection == direction : maDirection != -direction)) {

        log("Trigger " + this);

        wasInBand1(false);

        if (drift() == 0 && !inCooldown())

          openPosition(direction);

      }

    }

    // "short" or "long"   

    toString { ret trading_directionToPositionType(direction); }

    LS status() {

      ret listCombine(

        enabled ? null : "disabled",

        "Relative price: "+ formatDouble1(relativePrice()),

        !wasInBand1 ? null : "Was in band 1",

        "Band 1: " + band1,

        "Band 2: " + band2,

        "Close level: " + closeLevel

      );

    }

  } // end of Side

  void ngsStep aka ngsLogic() {

    //double close = currentPrice();

    //double drift = drift();

    for (side : sides())

      side.step();

    change();

  }

  simplyCached MAIndicator movingAverage1() {

    ret new MAIndicator(period1);

  }

  simplyCached MAIndicator movingAverage2() {

    ret new MAIndicator(period2);

  }

  L<CandleBasedIndicator> indicators() {

    ret ll(movingAverage1(), movingAverage2());

  }

  bool maRising() { ret maDirection > 0; }

  bool maFalling() { ret maDirection < 0; }

  double moveSignal() { ret maMove/maMinMove*100; }

  double maPlusPercent(dbl ma1 default ma1, double percent) { ret ma1*(1+percent/100); }

  double maMinusPercent(dbl ma1 default ma1, double percent) { ret ma1*(1-percent/100); }

  {

    granularity(30);

    onNewPrice(price -> ngsStep());

    onCandleCompleted(candle -> {

      lastMA1(ma1);

      ma1(movingAverage1()!);

      ma2(movingAverage2()!);

      maMove((ma1/lastMA1-1)*100);

      maMoveHistory?.addIfPriceChanged(maMove, currentTime());

      if (maMove >= maMinMove)

        maDirection(1);

      else if (maMove <= -maMinMove)

        maDirection(-1);

      else if (maDirection < 0 && maMove >= -maMinMove2()

        || maDirection > 0 && maMove <= maMinMove2())

        maDirection(0);

      maDirectionHistory?.addIfPriceChanged(maDirection, currentTime());

      ngsStep();

    });

  }

  double maMinMove2() { ret maMinMove-maMoveHysteresis; }

  LS status() {

    ret listCombine(

      "Min distance, MA min move: " + maMinMove + " (current move: " + formatDouble(maMove, 4) + ", direction: " + maDirection + ")",

      "MA periods: " + period1 + " " + period2,

      "Do: " + (!autoPositions ? "Only manual positions" : commaCombine(stringIf(doLongs(), "Longs"), stringIf(doShorts(), "Shorts"))),

      "Moving averages: " + formatDouble_significant(ma1, 4) + ", " + formatDouble_significant(ma2, 4),

      map(sides(), side -> firstToUpper(str(side)) + " side: " + commaCombine(side.status())),

      super.status()

    );

  }

  void afterStep :: before {

  }

  bool doShorts() { ret shortSide.enabled; }

  bool doLongs() { ret longSide.enabled; }

  L<Side> sides() {

    ret ll(longSide, shortSide);

  }

  int candlesNeededBeforeOperational() { ret period1; }

  bool usingCells() { false; }

  public void integrityCheck {

    movingAverage1().integrityCheck();

    movingAverage2().integrityCheck();

  }

}