var config = {
  dontLoseThan: { type: "balance", label: "StopLoss", value: 500000 },
  TargetProfit: { type: "balance", label: "StopProfit", value: 3000000 },
  ResetBetAtWin: { type: "checkbox", label: "Reset bet after hitting bet", value: true },
  autoStop: { type: "checkbox", label: "Auto stopping", value: true },
  //CONFIG 1(fast profit): bet max 3, target base 3 max 31, boost bet 5.4 boost target 7.9 place static 10
  //CONFIG 2(safer): bet max 7, target base 5 max 20, boost bet 0.2 boost target 0.75 place static 1

  increasePercent: { label: "Multiplier", type: "multiplier", value: 1.13 },
  percentAfterBet: { type: "number", label: "When bet above start multiply", value: 0 },
  increasePercentStop: { label: "If above, stop multiplier", type: "number", value: 340 },

  resetBetAtX: { label: "Bet Maximal (bm)", type: "balance", value: 33000 },

  baseTarget: { type: "multiplier", label: "Target Base (tb)", value: 20 },
  targetMax: { type: "multiplier", label: "Target Maximal (tm)", value: 5 },

  increaseOnAmount: { type: "balance", label: "Boost Bet (bb)", value: 20 },
  targetIncrease: { type: "multiplier", label: "Boost Target (bt)", value: -1 },

  increaseMaxWager: { type: "checkbox", label: "After win, increase max wager", value: false },
  resetMaxWager: { type: "checkbox", label: "After cycle end, reset max wager", value: false },
  increaseMaxBetAtWin: { type: "checkbox", label: "Increase Bet on win", value: false },

  increaseOnBetWith: { label: "Place static bet", type: "balance", value: 100 },

  baseBet: { label: "Base bet", type: "balance", value: 100 },
  resetBetTo: { label: "Bet Reset To", type: "balance", value: 300 },
  increaseTargetEveryX: { type: "multiplier", label: "increaseTargetEveryX", value: 5 },
  multiplierTargetX: { type: "multiplier", label: "multiplierTargetX", value: 0 },
  increaseBaseTargetAtWin: { type: "checkbox", label: "Increase Target after you have won", value: false },


  increaseBaseBetAtWin: { type: "checkbox", label: "After win, increase baseBet on 1 bit", value: false },

  increaseAfterX: { type: "number", label: "Increase after 14 times of placed bet (in total iteration, not more than baseTarget)", value: 14 },

  onWinVariationAdd: { type: "number", label: "Power of variation add", value: 1 },

};

/* AntiScript Evolved! 2.0v  */
/* Author of this script Ruzli#7111, my email is ruzli999@gmail.com */

/*      SECTOR - 1 - Betting             */
const baseBet = config.baseBet.value;                              // Starting Bet, in satoshi. 100 = 1 BITS
const increaseOnBetWith = config.increaseOnBetWith.value;          // Also in satoshi to specified on how much add bits (100 satoshi = 1 bits), after reach increaseAfterX iteration.

const increasePercent = config.increasePercent.value;              // Increase by multiply bet * increasePercent after reach maximum value specified in percentAfterBet.
var resetBetAtX = config.resetBetAtX.value;                      // Limit Wager and bet (in BITS), divisions multiplier apply to resetBetAtX too
if (config.increaseOnBetWith.value > config.resetBetAtX.value){
  resetBetAtX = config.increaseOnBetWith.value
}
const increasePercentStop = config.increasePercentStop.value;      // After what bet should percent stop increase next bet

var resetBetTo = config.resetBetTo.value;                        // After skipping and resetting bet, set bet in satoshi(100 = 1 bits)

if (config.resetBetTo.value == 100 && config.baseBet.value == 100){
  if (resetBetTo == config.baseBet.value){  resetBetTo = baseBet }
}

/*      SECTOR - 2 - Target               */

var baseTarget = config.baseTarget.value;               // Target multiplier
var targetMax = config.targetMax.value

if (config.baseTarget.value > config.targetMax.value){
  //targetMax = config.baseTarget.value;
  //baseTarget = config.targetMax.value
}

const increaseAfterX = config.increaseAfterX.value;       // Increase after 14 times of placed bet (in total iteration, not more than baseTarget)
const percentAfterBet = config.percentAfterBet.value;     // Start multiply percent after reach bet
const targetIncrease = config.targetIncrease.value;       // Increase multiplier at loss conditions, can be set to 0 to disable feature

/*      SECTOR - 3 - Mods                 */

const pausePerBetMilliseconds = 1

const increaseBaseBetAtWin = config.increaseBaseBetAtWin.value;         // After win, increase baseBet on 1 bit
const increaseBaseTargetAtWin = config.increaseBaseTargetAtWin.value;   // Increase Target after you have won
const dividerWinTarget = 1                                              // Divide multiplier for target after win conditions
const divisions = 1;                               // Bet multiplier with same count to 15x
const ResetBetAtWin = config.ResetBetAtWin.value;                       // Reset bet after hitting bet

/*      SECTOR - 6 - Random bets          */

const rndBets = false;
const rndBaseBet = 1000;
const rndPlaceEveryX = 14;
const rndBaseTarget = 1.5;

/*      SECTOR - 7 - Seed Management          */

const NewSeedAtWin = false;
const changeSeedAfterY = 9000;
const placeSeed = 2000;
const consecutiveWinReset = false

var engine = this;

let _increaseAfterX = increaseAfterX, _increasePercent = increasePercent;
let consecutiveLosses = 0, target = baseTarget, net_profit = 0, bet = baseBet, betCount = 0, rndCount = 0, flagged = 0;
let profit = 0, targetCount = 0, isX = 0, added_winning_bet = 0;

var current_balance = this.balance

while (true) {      // Starts main game loop
  betCount++;
  rndCount++;
  targetCount++;

  if (config.autoStop.value){
    if (this.balance <= current_balance - config.dontLoseThan.value || this.balance > current_balance + config.TargetProfit.value) {
      this.log(`Auto stopping triggered!`)
      this.stop()
    }
  }
  if (betCount % changeSeedAfterY == 0 && betCount != 0) {
    if (changeSeedAfterY != 0) { if (flagged == 0) await generateSeed(); }
  }

  if (targetCount == config.increaseTargetEveryX.value && config.multiplierTargetX.value != 0) {
    target = target * config.multiplierTargetX.value;
    targetCount = 0;
  }

  if (bet / 100 > percentAfterBet) {                          // Checking if our bet has reached point to start multiply process.
    if (bet / 100 < increasePercentStop) {
      bet = Math.round((bet / 100) * _increasePercent) * 100;
    }
  }

  let tbet = 0;
  if (divisions > 1) {
    tbet = bet * divisions;
  };

  if (tbet == 0) { tbet = bet }

  if (tbet > resetBetAtX) { tbet = resetBetAtX; }

  if (rndBets == true && rndCount == rndPlaceEveryX) {
    await this.bet(betSize(rndBaseBet), rndBaseTarget);
    rndCount = 0;
  }

  const { multiplier } = await this.bet(betSize(tbet), target);                                 // Place bet, can be used in parallex mode with threadings.
  this.clearLog();
  //this.log(`Current balance ${this.balance / 100} bits`);
  this.log(`Auto Stop:  LOSS: ${(current_balance - config.dontLoseThan.value) / 100} bits  | PROFIT: ${(current_balance + config.TargetProfit.value) / 100} bits`)
  await checkConditions(this.balance);

  if (pausePerBetMilliseconds != 0) await sleep(pausePerBetMilliseconds)           // Slow down script if necessary.

  if (multiplier < target) {     //  LOSS
      consecutiveLosses++;

      if (targetIncrease != 0) {
        target += targetIncrease

        if (config.baseTarget.value > config.targetMax.value){
          if (config.baseTarget.value <= target || config.targetMax.value > target) {
            target = config.baseTarget.value
          }
        } else {
          if (target >= targetMax) {
            target = baseTarget
          }
        }

      } else {
        target = config.baseTarget.value;
      }

      profit = profit + bet;                                 // Fix value to do in future calculations on profit.
      //await this.log(`Stats: ${profit / 100} bits lost at the moment.`);
      //await this.log(`Lost consecutive bet #${consecutiveLosses}`);

      if (consecutiveLosses > _increaseAfterX) { consecutiveLosses++;
                           if (bet / 100 == 1) { consecutiveLosses = 0; }
      }

      if (consecutiveLosses * (bet / 100) >= target) {
        bet += increaseOnBetWith;
        switch (bet / 100) {
          case 1:
            _increaseAfterX = 13      // 14 times
            break;
          case 2:
            _increaseAfterX = 7       //  7 times
            break;
          case 3:
            _increaseAfterX = 5       //  5 times
            break;
          case 4:
            _increaseAfterX = 4       //  4 times
            break;
          case 5:
            _increaseAfterX = 3       //  3 times
            break;
          case 6:
            _increaseAfterX = 2       //  2 times
            break;
          case 7:
            _increaseAfterX = 2       //  2 times
            break;
          case 8:
            _increaseAfterX = 2       //  2 times
            break;
          case 9:
            _increaseAfterX = 2       //  2 times
            break;
          case 10:
            _increaseAfterX = 2       //  1 times
            break;
          case 11:
            _increaseAfterX = 2       //  2 times
          default:
            await this.log("Multiplier calculation enabled");
        }

        if (toBits(bet) > 10) { _increaseAfterX = 2 }
        if (toBits(bet) > 26) { _increaseAfterX = 2 }
        if (toBits(bet) > 30) { _increaseAfterX = 2 }
        if (toBits(bet) > 40) { _increaseAfterX = 2 }
        if (toBits(bet) > 15) { _increaseAfterX = 2 }

        if (bet / 100 > placeSeed && flagged == 0) {                 // TRIGGER placeSeed
          _increaseAfterX = 1;
          flagged = 1;
          await generateSeed();
        }

        if (bet > resetBetAtX) {                             // TRIGGER resetBetAtX
          bet = resetBetTo;
          consecutiveLosses = 0;

          isX = 0;

          if (config.resetMaxWager.value){
            resetBetAtX = config.resetBetAtX.value

          }
        }

        if (bet != 100) {
          consecutiveLosses = 0;
        } else {
          consecutiveLosses++
        }
      }

  } else {                               //    WIN - conditions when we win.
      if (consecutiveWinReset == true) consecutiveLosses = 0;
      if (NewSeedAtWin) await generateSeed()
      if (config.increaseMaxBetAtWin.value){
        added_winning_bet = getRandomNumber(1, 3); // default was 1, 3
        bet += added_winning_bet * 100
      }
      sound_loop(8);

      if (config.increaseMaxWager.value){ resetBetAtX += config.increaseOnAmount.value }

      net_profit = net_profit + profit;
      profit = 0;
      betCount = 0;
      flagged = 0;
      _increasePercent = increasePercent;

      if (increaseBaseBetAtWin) {
        isX++
        bet = isX * baseBet;
      } else {
        if (ResetBetAtWin) {
          bet = baseBet;
          consecutiveLosses = 0;
        }
      }


      if (increaseBaseTargetAtWin) {
        target = target + (baseTarget / dividerWinTarget);
      } else {
        target = baseTarget;
      }

      this.log(`Net profit ${Math.round(net_profit) / 100}`);
      _increaseAfterX = increaseAfterX;
    }
};

function betSize(bet) {
  return Math.max(100, Math.round((bet) / 100) * 100)
}

async function sleep(ms = 0) { return new Promise(resolve => setTimeout(resolve, ms)) };

async function generateSeed() {
  try {
    const { server_seed_hash } = await engine.newSeedPair();
    await engine.setClientSeed(server_seed_hash);
  }
  catch (e) {
    engine.log(`Client seed already was reset and not used`);
  }
};

async function sound_loop(sound_number, name) {
  let sound_track = [ `cl_hihat`, `claves`, `conga1`, `cowbell`, `hi_conga`, `hightom`, `rimshot`, `snare`, `tom1`, `sc` ];
  let url = `https://raw.githubusercontent.com/ruzli/misc/master/`;
  let format = `.wav`;
  let full_string = url + name + format;

  if (name != undefined) {
    full_string = url + name + format;
  } else if (sound_number != undefined) {
    full_string = url + sound_track[ sound_number ] + format;
  } else {
    engine.log(`Sound not found.`);
  };
  const audio = new Audio(full_string);
  await audio.play();
  return new Promise(resolve => audio.onended = resolve);
};

async function checkConditions(balance) {
  if (balance >= config.TargetProfit.value && !config.autoStop.value) {
    engine.log(`You reached target profit of ${config.TargetProfit.value / 100}!`);
    await engine.stop();
  };
  if (balance <= config.dontLoseThan.value && !config.autoStop.value) {
    engine.log(`Your balance lose limit ${config.dontLoseThan.value / 100}, was reached. Stopping script`);
    await engine.stop();
  };
};

function getRandomNumber(min, max) {
  let rnd =  Math.ceil((Math.random() * (max - min)) + min) * config.onWinVariationAdd.value
  engine.log(rnd)
  return rnd
};

function toBits(satoshi) {
  return satoshi / 100;
};