var config = {
    initBet: { label: "initBet", type: "number", value: 100 },
    initPay: { label: "initPay", type: "number", value: 5 },
    betIncrease: { label: "betIncrease", type: "number", value: 100 },
    payIncrease: { label: "payIncrease", type: "number", value: 0 },
    payStop: { label: "payStop", type: "number", value: 999999999 },
    betStop: { label: "betStop", type: "number", value: 999999999 },
    whenToStop: { type: "number", label: "Balance less than < %", value: 0 },
    whenToStopProfit: { type: "number", label: "Balance above than started > %", value: 0 },
    resetTarget: { type: "checkbox", label: "Reset target too", value: false },
    targetReset: { type: "checkbox", label: "Halve target", value: false },
    halveAt: { type: "number", label: "Halve target at", value: 100 },
    stopScript: { type: "checkbox", label: "Stop script", value: false },
    progressiveBetting: { type: "checkbox", label: "Progressive betting", value: true },
    waitUntil: { type: "checkbox", label: "Skipping phase", value: false },
    skips: { type: "number", label: "Skips", value: 500 },
    skipsMultiplier: { type: "number", label: "Multiplier Skip", value: 100 },
    stopProfit: { label: "Stop Profit(at)", type: "balance", value: 40000 },
    changeSeedEachROlls: { label: "Change Seed After that amount of rolls(0 = OFF)", type: "number", value: 5000 }
};

var engine = this;
var skippingPhase = config.waitUntil.value;
var skips = 0;
var skip_ended = false;

var initBet = config.initBet.value;
var initPay = config.initPay.value;
var betIncrease = config.betIncrease.value;
var payIncrease = config.payIncrease.value;
var payStop = config.payStop.value;
var betStop = config.betStop.value;

var currentBet = initBet;
var currentPay = initPay;

var lock_balance = (this.balance / 100) * (config.whenToStop.value / 100); /* Lock balance specified in config in percent before script start */
var lock_balance_profit = (this.balance / 100) * (config.whenToStopProfit.value / 100); /* Lock balance specified in config in percent before script start */
var lock_normal = (this.balance / 100);

var rolls = 0;

while (true) {
    if (config.stopProfit.value >= this.balance || config.stopProfit.value != 0) this.stop();
    if (skippingPhase) {
        var { multiplier } = await this.bet(100, 1.01);
        if (multiplier < config.skipsMultiplier.value) {
            skips++;
            this.log(`${config.skipsMultiplier.value}x | Skips ${skips}/${config.skips.value}`);
            if (skips >= config.skips.value) {
                skip_ended = true;
                skippingPhase = false;
            }

        } else {
            skips = 0;
        }
    } else {
        skip_ended = true;
        skippingPhase = false;
    }
    if (!skip_ended) continue;

    rolls++;
    if (rolls >= config.changeSeedEachROlls.value && config.changeSeedEachROlls != 0) {
        rolls = 0;
        await generateSeed(this);
    }
    await checkConditions()
    var { multiplier } = await this.bet(roundBit(currentBet), currentPay);

    if (multiplier >= currentPay) {
        if (config.progressiveBetting.value == true) {
            currentBet -= initPay * 100
            if (currentBet < initBet) {
                currentBet = initBet;
            }
            currentPay = initPay;
        } else {
            currentBet = initBet;
            currentPay = initPay;
        }

    } else {
        currentBet += betIncrease;
        currentPay += payIncrease;
    }
    if (currentBet > betStop) {
        this.stop()
    } else if (currentPay > payStop) {
        currentPay = initPay;
        currentBet = initBet;
    }
    if (config.targetReset.value) {
        if (currentPay > config.halveAt.value) {
            currentPay /= 2;
            currentBet *= 2.1;
        }
    }
}

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

async function printStatus() {
    engine.clearLog();
    await engine.log(`Till stop: lose: ${Math.round(Math.round(lock_balance - engine.balance / 100))} bits`);
    await engine.log(`Till stop: profit: ${Math.round(Math.round(lock_balance_profit + lock_normal) - engine.balance / 100)} bits`);
}

async function breakPoint() {
    if (config.stopScript.value) {
        await engine.stop();
    } else {
        currentBet = config.initBet.value;
        if (config.resetTarget.value) {
            currentPay = config.initPay.value
        }
        lock_balance = (engine.balance / 100) * (config.whenToStop.value / 100) /* Lock balance specified in config in percent before script start */
        lock_balance_profit = (engine.balance / 100) * (config.whenToStopProfit.value / 100) /* Lock balance specified in config in percent before script start */
        lock_normal = (engine.balance / 100)
        engine.clearLog()
        await engine.log(`Script recalculated lock profit stop and loss stop; new values are:`)
        await engine.log(`Stop loss ${Math.round(lock_balance)} bits | Stop profit ${Math.round(lock_normal + lock_balance_profit)} bits`);
        await sleep(50)
    }
}

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

async function checkConditions() {
    await printStatus()
    if (engine.balance / 100 <= lock_balance && config.whenToStop.value != 0) {
        await breakPoint()
    }
    if (engine.balance / 100 > lock_normal + lock_balance_profit && config.whenToStopProfit.value != 0) {
        await breakPoint()
    }
};

async function generateSeed(context) {
    try {
        const { server_seed_hash } = await context.newSeedPair()
        await context.setClientSeed(server_seed_hash)
    } catch (error) {
        console.log(`Seed was already reset`)
    }
};