var config = {
  BaseSettings: {
    type: 'noop',
    label: 'Base Bet & Payout'
  },
  wager: {
    value: 100,
    type: 'balance',
    label: 'Base bet'
  },
  payout: {
    value: 2,
    type: 'multiplier',
    label: 'Payout'
  },
  stopLossWarning: {
    type: 'noop',
    label: 'Stop Loss Settings'
  },
  stopBelow: {
    value: 2500000,
    type: 'balance',
    label: 'Stop if BR Below'
  },
  stopAbove: {
    value: 100000000,
    type: 'balance',
    label: 'Stop if BR Above'
  },
  autoPauseType: {
  value: 'one', type: 'radio', label: 'AutoPause Settings',
  options: {
    one: { value: 'one', type: 'noop', label: 'Go Back In After x Amount of Greens' },
    two: { value: 'two', type: 'noop', label: 'Go Back In After x Amount of Games' },
  }
},
warning1: {
  type: 'noop',
  label: 'Pauses bets if x consecutive busts happens'
},
  lossCounterStop: {
    value: 5,
    type: 'text',
    label: 'AutoStop After:'
  },
  warning2: {
  type: 'noop',
  label: 'Resumes betting after x consecutive greens'
},
  winCounterGo: {
    value: 2,
    type: 'text',
    label: 'Resume After:'
  },

};

let wantedProfitInBits = config.wager.value / 100;
let netProfit = 0;
let baseList = [];
let currentGamesPlayed = 0;
let maxBet = 0;
let balanceNeeded = 0;
let wins = 0;
let loses = 0;
let currentlyPlaying = true;
let SPLIT_INTO = 3;
var MAX_LOSE = 0;
var SESSION_NET_PROFIT = 0;
var SESSION_MAX_BALANCE_NEEDED = 0;
var ALL_GAMES = [];
var SESSION_TIMES_ENTERED = 0;
addLast50();
var SMALL_SESSION_NET_PROFIT = 0;
var lossCounter = 0;
var autoStop = 0;
var winCounter = 0;
var sessionBR = userInfo.balance



function addLast50() {
  var LATEST_50_GAMES = engine.history.toArray();
  // logTime(`LATEST_50 length ${LATEST_50_GAMES.length}`)
  for (let i = 0; i <= LATEST_50_GAMES.length - 1; i++) {
    ALL_GAMES.unshift(LATEST_50_GAMES[i].bust);
  }
  ALL_GAMES.push(engine.history.first().bust)
  for (var i = 0; i < ALL_GAMES.length - 1; i++) {
    // logTime(`id ${i} ${ALL_GAMES[i]}`);
  }
}



initScript();


function getCurrentBetLightGuide() {
  let currentMultiplier = 0;
  let currentBet = null;
  if (netProfit >= 0 && currentGamesPlayed > 0) {
    return currentBet;
  }
  if (baseList.length >= 2) {
    currentMultiplier = baseList[0] + baseList[baseList.length - 1];
    currentBet = (currentMultiplier * config.wager.value);
  } else if (baseList.length === 1) {
    currentMultiplier = baseList[0];
    currentBet = (currentMultiplier * config.wager.value) * 2;
  } else {
    currentMultiplier = null;
  }
  return currentBet;
}


  logTime(`AutoPause Information:`);
  logTime(`Pause Betting After: ` + config.lossCounterStop.value + ' Consecutive Busts.');
  logTime(' Resume Betting After: ' + config.winCounterGo.value + ' Consecutive Games At ' + config.payout.value + '.0 Or Higher ');
  logTime('Stop script if balance goes below: ' + (config.stopBelow.value)/100 + ' bits, Or if balance goes above: ' + (config.stopAbove.value)/100 + 'bits.');


function initScript() {

  SESSION_TIMES_ENTERED += 1;
  baseList = [1, 2, 3];
  netProfit = 0;
  currentGamesPlayed = 0;
  maxBet = 0;
  balanceNeeded = 0;
  wins = 0;
  loses = 0;
  currentlyPlaying = true;
  SMALL_SESSION_NET_PROFIT = 0;
}






// Try to bet immediately when script starts
if (engine.gameState === "GAME_STARTING") {
  makeBet();
}




engine.on('GAME_STARTING', onGameStarted);
engine.on('GAME_ENDED', onGameEnded);






function onGameStarted() {
  if (!currentlyPlaying) {
    initScript();
  }
  let currentBet = getCurrentBetLightGuide();






  if (!currentBet) {
    currentlyPlaying = false;
    printEndStatus();

    initScript();
  }
  makeBet();
}









function onGameEnded() {
  ALL_GAMES.push(engine.history.first().bust);
  let lastGame = engine.history.first();




if (autoStop >= 1)
{





  if (lastGame.bust >= config.payout.value)
  {
    winCounter += 1;
    var resume = config.winCounterGo.value - winCounter;
    log('AutoPause: Need (' + resume + ') more consecutive games to go back in');


      if (winCounter >= config.winCounterGo.value)
      {
        log('AutoPause has been disabled. Resumming Betting');
        autoStop *= 0;
        winCounter *= 0;
      }
  }
  else if (lastGame.bust < config.payout.value)
  {
    winCounter *= 0;
  }



}



  // If we wagered, it means we played
  if (!lastGame.wager) {
    return;
  }
  let lastBet = getCurrentBetLightGuide();




  if (lastGame.cashedAt) // **************************IF PROFIT THEN ********************
{
    let profit = Math.round(((lastBet * config.payout.value) - lastBet) / 100);
    netProfit += profit;
    SESSION_NET_PROFIT += profit;
    SMALL_SESSION_NET_PROFIT += profit
    logTime(`Won ${profit} bits`);
    if (baseList.length > 1) {
      baseList.splice(baseList.length - 1, 1);
    }
    baseList.splice(0, 1);
    wins += 1;
  lossCounter *= 0;
  }



else // **********************IF BET BUSTS THEN THIS CODE IS EXECUTED ***********************
{
    var lost = lastBet / 100;
    logTime(`BUST - ${lost} `);
    netProfit -= lost;
    SESSION_NET_PROFIT -= lost;
    baseList.push(lastBet / config.wager.value);
    loses += 1;
  lossCounter += 1;
  if (lossCounter >= config.lossCounterStop.value)
  {
    autoStop += 1;
    log('AutoPause Enabled -- Detected ' + config.lossCounterStop.value + ' consecutive busts.');
  }
  }


  if(userInfo.balance > config.stopAbove.value || userInfo.balance < config.stopBelow.value)
      {
          stop('Stopping script due to balance being either too high or too low...');
    //stop('Insufficient balance to make the bet')
      }







  currentGamesPlayed += 1;
  // logTime(`Net profit: ${netProfit} Current bet: ${getCurrentBetLightGuide() / 100}`);
  let currentBalanceNeeded = netProfit + ((getCurrentBetLightGuide() / 100) * -1);
  if (currentBalanceNeeded < balanceNeeded) {
    balanceNeeded = currentBalanceNeeded;
  }

  if (currentBalanceNeeded < SESSION_MAX_BALANCE_NEEDED) {
    SESSION_MAX_BALANCE_NEEDED = currentBalanceNeeded;
  }

  logTime('Net profit: ' + netProfit + ' bits.');
}





function printEndStatus() {
 logTime(`Played: ` + currentGamesPlayed + ' Net profit: ' + netProfit + ' bits. Balance needed: ' + balanceNeeded * -1 + ' bits Max bet: ' + maxBet / 100 + ' bits. Wins: ' + (wins / (wins + loses) * 100) + ' % Loses: ' + (loses / (wins + loses) * 100) + ' %');
 logTime(`SESSION NET PROFIT ${SESSION_NET_PROFIT} bits');
 logTime('SESSION TIMES ENTERED ${SESSION_TIMES_ENTERED}`);
}





function makeBet()
{
  if (autoStop >= 1)
  {
    log('Skipping Bet...');
  }
else{
  let currentBet = getCurrentBetLightGuide();
  if (!currentBet) {

    return;
  }
  engine.bet(currentBet, config.payout.value);
  if (currentBet > maxBet) {
    maxBet = currentBet;
  }
  logTime('Betting ' + Math.round(currentBet / 100) + ' bits at ' + config.payout.value + 'x ');
}

}





function logTime(msg) {
  let today = new Date();
  let calendarDate = ``;
  let now = ``;
  log(`${now} ${msg}`);
}