const puppeteer = require('puppeteer');
const mongoose = require("mongoose");

mongoose.connect("mongodb+srv://m3rt:m3rt12345@m3rt.znjmp.mongodb.net/analiz?retryWrites=true&w=majority");

const turschema = new mongoose.Schema({
    rounds: { type: Number, default: 0 }
});

const uncountsschema = new mongoose.Schema({
    two: { type: Number, default: 0 },
    three: { type: Number, default: 0 },
    four: { type: Number, default: 0 },
    five: { type: Number, default: 0 },
    six: { type: Number, default: 0 },
    seven: { type: Number, default: 0 },
    eight: { type: Number, default: 0 },
    nine: { type: Number, default: 0 },
    ten: { type: Number, default: 0 },
    fifteen: { type: Number, default: 0 },
    twenty: { type: Number, default: 0 },
    twentyfive: { type: Number, default: 0 },
    thirty: { type: Number, default: 0 },
    forty: { type: Number, default: 0 },
    fifty: { type: Number, default: 0 },
    sixty: { type: Number, default: 0 },
    seventy: { type: Number, default: 0 },
    eighty: { type: Number, default: 0 },
    ninety: { type: Number, default: 0 },
    onehundred: { type: Number, default: 0 },
    onehundredtwenty: { type: Number, default: 0 },
    onehundredforty: { type: Number, default: 0 },
    onehundredandsixty: { type: Number, default: 0 },
    twohundred: { type: Number, default: 0 },
    threehundred: { type: Number, default: 0 },
    fourhundred: { type: Number, default: 0 },
    fivehundred: { type: Number, default: 0 },
    onethousand: { type: Number, default: 0 },

});

const gelenschema = new mongoose.Schema({
    one: { type: Number, default: 0 },
    two: { type: Number, default: 0 },
    three: { type: Number, default: 0 },
    four: { type: Number, default: 0 },
    five: { type: Number, default: 0 },
    six: { type: Number, default: 0 },
    seven: { type: Number, default: 0 },
    eight: { type: Number, default: 0 },
    nine: { type: Number, default: 0 },
    ten: { type: Number, default: 0 },
    fifteen: { type: Number, default: 0 },
    twenty: { type: Number, default: 0 },
    twentyfive: { type: Number, default: 0 },
    thirty: { type: Number, default: 0 },
    forty: { type: Number, default: 0 },
    fifty: { type: Number, default: 0 },
    sixty: { type: Number, default: 0 },
    seventy: { type: Number, default: 0 },
    eighty: { type: Number, default: 0 },
    ninety: { type: Number, default: 0 },
    onehundred: { type: Number, default: 0 },
    onehundredtwenty: { type: Number, default: 0 },
    onehundredforty: { type: Number, default: 0 },
    onehundredandsixty: { type: Number, default: 0 },
    twohundred: { type: Number, default: 0 },
    threehundred: { type: Number, default: 0 },
    fourhundred: { type: Number, default: 0 },
    fivehundred: { type: Number, default: 0 },
    onethousand: { type: Number, default: 0 },
});

const Tur = mongoose.model("Tur", turschema);
const UnCount = mongoose.model("UnCount", uncountsschema);
const Gelen = mongoose.model("Gelen", gelenschema);

(async () => {
    try {
        const browser = await puppeteer.launch({
            headless: "new",
            args: ['--no-sandbox', '--disable-setuid-sandbox'],
        });
        const page = await browser.newPage();
        await page.goto('https://www.betist1112.com/', {
            waitUntil: 'load',
            timeout: 0
        });
        await page.setViewport({
            width: 1920,
            height: 1080,
        });
        let k_adi = await page.waitForXPath("//div[@class='position-relative ml-2']//input[@placeholder='Kullanıcıadı']").catch(console.error)
        let sifre = await page.waitForXPath("//div[@class='position-relative ml-2']//input[@placeholder='Şifre']").catch(console.error)
        let submit = await page.waitForXPath("//button[@class='ml-2 ntb ntbl border-0']").catch(console.error)

        await k_adi.type("m3rt7132").then(a => console.log("Kullanıcı Adı Yazıldı."))
        await page.waitForTimeout(1000);
        await sifre.type("themert123").then(a => console.log("Şifre Yazıldı."))
        await page.waitForTimeout(1000);
        await submit.click().then(x => console.log("Giriş yapıldı.")).catch(err => console.error("giriş yapılırken sorun oluştu"))
        await page.waitForTimeout(2500);
        await page.goto("https://www.betist1112.com/spribe/aviator", {
            waitUntil: 'load',
            timeout: 0
        }).then(x => console.log("Aviatör Oyununa Girdim.")).catch(err => console.error("Oyuna giremedim Hata", err));

        await page.waitForSelector('iframe');
        const iframeHandle = await page.$('iframe');
        const frame = await iframeHandle.contentFrame();
        const payoutsDiv = await frame.waitForSelector('div.payouts-block');
        if (payoutsDiv) {
            console.log('iframede div.payouts bloğu bulundu.');
        } else {
            console.log('div.payouts bloğu iframede bulunamadı.');
        }
        let cx = await frame.waitForSelector('app-bubble-multiplier');
        if (cx) {
            console.log('iframede app-bubble-multiplier bloğu bulundu.');
        } else {
            console.log('app-bubble-multiplie bloğu iframede bulunamadı.');
        }

        let previousHTML = '';
        let ikicount = 0;
        let uccount = 0;
        let dortcount = 0;
        let bescount = 0;
        let alticount = 0;
        let yedicount = 0;
        let sekizcount = 0;
        let dokuzcount = 0;
        let oncount = 0;
        let onbescount = 0;
        let yirmicount = 0;
        let yirmibescount = 0;
        let otuzcount = 0;
        let kirkcount = 0;
        let ellicount = 0;
        let atmiscount = 0;
        let yetmiscount = 0;
        let seksencount = 0;
        let doksancount = 0;
        let yuzcount = 0;
        let yuzyirmicount = 0;
        let yuzkirkcount = 0;
        let yuzaltmiscount = 0;
        let ikiyuzcount = 0;
        let ucyuzcount = 0;
        let dortyuzcount = 0;
        let besyuzcount = 0;
        let bincountcount = 0;
        const tur = await UnCount.find({});
        if (!tur || tur.length == 0) new Tur({
            rounds: 0
        }).save();

        const uncount = await UnCount.find({});
        if (!uncount || uncount.length == 0) new UnCount({
            two: 0,
            three: 0,
            four: 0,
            five: 0,
            six: 0,
            seven: 0,
            eight: 0,
            nine: 0,
            ten: 0,
            fifteen: 0,
            twenty: 0,
            twentyfive: 0,
            thirty: 0,
            forty: 0,
            fifty: 0,
            sixty: 0,
            seventy: 0,
            eighty: 0,
            ninety: 0,
            onehundred: 0,
            onehundredtwenty: 0,
            onehundredforty: 0,
            onehundredandsixty: 0,
            twohundred: 0,
            threehundred: 0,
            fourhundred: 0,
            fivehundred: 0,
            onethousand: 0,
        }).save();

        const gelen = await Gelen.find({});
        if (!gelen || gelen.length == 0) new Gelen({
            two: 0,
            three: 0,
            four: 0,
            five: 0,
            six: 0,
            seven: 0,
            eight: 0,
            nine: 0,
            ten: 0,
            fifteen: 0,
            twenty: 0,
            twentyfive: 0,
            thirty: 0,
            forty: 0,
            fifty: 0,
            sixty: 0,
            seventy: 0,
            eighty: 0,
            ninety: 0,
            onehundred: 0,
            onehundredtwenty: 0,
            onehundredforty: 0,
            onehundredandsixty: 0,
            twohundred: 0,
            threehundred: 0,
            fourhundred: 0,
            fivehundred: 0,
            onethousand: 0,
        }).save();

        setInterval(async () => {
            const currentHTML = await frame.evaluate(() => {
                const payoutsBlock = document.querySelector('div.payouts-block');
                return payoutsBlock ? payoutsBlock.innerHTML : '';
            });
            if (currentHTML !== previousHTML) {
                previousHTML = currentHTML;
                console.log('DOM ağacı yenilendi');
                const elementHandle = await frame.$('app-bubble-multiplier');
                const textContent = await frame.evaluate(element => element.textContent.trim(), elementHandle);
                let gelensayi = parseFloat(textContent);

                if (!isNaN(gelensayi)) {
                    console.log(gelensayi);
                    gelensayi = Math.floor(gelensayi);

                    await Tur.updateOne({}, { $inc: { rounds: +1 } }).catch(console.error);

                    //gelen
                    switch (true) {
                        case gelensayi >= 1:
                            await Gelen.updateOne({}, { $inc: { one: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 2:
                            await Gelen.updateOne({}, { $inc: { two: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 3:
                            await Gelen.updateOne({}, { $inc: { three: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 4:
                            await Gelen.updateOne({}, { $inc: { four: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 5:
                            await Gelen.updateOne({}, { $inc: { five: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 6:
                            await Gelen.updateOne({}, { $inc: { six: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 7:
                            await Gelen.updateOne({}, { $inc: { seven: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 8:
                            await Gelen.updateOne({}, { $inc: { eight: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 9:
                            await Gelen.updateOne({}, { $inc: { nine: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 10:
                            await Gelen.updateOne({}, { $inc: { ten: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 15:
                            await Gelen.updateOne({}, { $inc: { fifteen: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 20:
                            await Gelen.updateOne({}, { $inc: { twenty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 25:
                            await Gelen.updateOne({}, { $inc: { twentyfive: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 30:
                            await Gelen.updateOne({}, { $inc: { thirty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 40:
                            await Gelen.updateOne({}, { $inc: { forty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 50:
                            await Gelen.updateOne({}, { $inc: { fifty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 60:
                            await Gelen.updateOne({}, { $inc: { sixty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 70:
                            await Gelen.updateOne({}, { $inc: { seventy: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 80:
                            await Gelen.updateOne({}, { $inc: { eighty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 90:
                            await Gelen.updateOne({}, { $inc: { ninety: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 100:
                            await Gelen.updateOne({}, { $inc: { onehundred: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 120:
                            await Gelen.updateOne({}, { $inc: { onehundredtwenty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 140:
                            await Gelen.updateOne({}, { $inc: { onehundredforty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 160:
                            await Gelen.updateOne({}, { $inc: { onehundredandsixty: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 200:
                            await Gelen.updateOne({}, { $inc: { twohundred: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 300:
                            await Gelen.updateOne({}, { $inc: { threehundred: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 400:
                            await Gelen.updateOne({}, { $inc: { fourhundred: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 500:
                            await Gelen.updateOne({}, { $inc: { fivehundred: +1 } }, { upsert: true });
                            break;
                        case gelensayi >= 1000:
                            await Gelen.updateOne({}, { $inc: { onethousand: +1 } }, { upsert: true });
                            break;
                        default:
                            console.log("hatalı değer");
                            break;
                    }

                    if (gelensayi < 2) {
                        ikicount++;
                    } else if (gelensayi >= 2 && ikicount > uncount[0].two) {
                        await UnCount.updateOne({}, { $set: { two: ikicount } }).catch(console.error);
                        console.log("2 geldi");
                        ikicount = 0;
                    } else {
                        ikicount = 0;
                        console.log("2 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 3) {
                        uccount++;
                    } else if (gelensayi >= 3 && uccount > uncount[0].three) {
                        await UnCount.updateOne({}, { $set: { three: uccount } }).catch(console.error);
                        console.log("3 geldi");
                        uccount = 0;
                    } else {
                        uccount = 0;
                        console.log("3 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 4) {
                        dortcount++;
                    } else if (gelensayi >= 4 && dortcount > uncount[0].four) {
                        await UnCount.updateOne({}, { $set: { four: dortcount } }).catch(console.error);
                        console.log("4 geldi");
                        dortcount = 0;
                    } else {
                        dortcount = 0;
                        console.log("4 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 5) {
                        bescount++;
                    } else if (gelensayi >= 5 && bescount > uncount[0].five) {
                        await UnCount.updateOne({}, { $set: { five: bescount } }).catch(console.error);
                        console.log("5 geldi");
                        bescount = 0;
                    } else {
                        bescount = 0;
                        console.log("5 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 6) {
                        alticount++;
                    } else if (gelensayi >= 6 && alticount > uncount[0].six) {
                        await UnCount.updateOne({}, { $set: { six: alticount } }).catch(console.error);
                        console.log("6 geldi");
                        alticount = 0;
                    } else {
                        alticount = 0;
                        console.log("6 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 7) {
                        yedicount++;
                    } else if (gelensayi >= 7 && yedicount > uncount[0].seven) {
                        await UnCount.updateOne({}, { $set: { seven: yedicount } }).catch(console.error);
                        console.log("7 geldi");
                        yedicount = 0;
                    } else {
                        yedicount = 0;
                        console.log("7 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 8) {
                        sekizcount++;
                    } else if (gelensayi >= 8 && sekizcount > uncount[0].eight) {
                        await UnCount.updateOne({}, { $set: { eight: sekizcount } }).catch(console.error);
                        console.log("8 geldi");
                    } else {
                        sekizcount = 0;
                        console.log("8 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 9) {
                        dokuzcount++;
                    } else if (gelensayi >= 9 && dokuzcount > uncount[0].nine) {
                        await UnCount.updateOne({}, { $set: { nine: dokuzcount } }).catch(console.error);
                        console.log("9 geldi");
                    } else {
                        dokuzcount = 0;
                        console.log("9 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 10) {
                        oncount++;
                    } else if (gelensayi >= 10 && oncount > uncount[0].ten) {
                        await UnCount.updateOne({}, { $set: { ten: oncount } }).catch(console.error);
                        console.log("10 geldi");
                    } else {
                        oncount = 0;
                        console.log("10 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 15) {
                        onbescount++;
                    } else if (gelensayi >= 15 && onbescount > uncount[0].fifteen) {
                        await UnCount.updateOne({}, { $set: { fifteen: onbescount } }).catch(console.error);
                        console.log("15 geldi");
                        onbescount = 0;
                    } else {
                        console.log("15 veya üstü geldi, ancak sayı daha küçük");
                        onbescount = 0;
                    }

                    if (gelensayi < 20) {
                        yirmicount++;
                    } else if (gelensayi >= 20 && yirmicount > uncount[0].twenty) {
                        await UnCount.updateOne({}, { $set: { twenty: yirmicount } }).catch(console.error);
                        console.log("20 geldi");
                        yirmicount = 0;
                    } else {
                        console.log("20 veya üstü geldi, ancak sayı daha küçük");
                        yirmicount = 0;
                    }

                    if (gelensayi < 25) {
                        yirmibescount++;
                    } else if (gelensayi >= 25 && yirmibescount > uncount[0].twentyfive) {
                        await UnCount.updateOne({}, { $set: { twentyfive: yirmibescount } }).catch(console.error);
                        console.log("25 geldi");
                        yirmibescount = 0;
                    } else {
                        console.log("25 veya üstü geldi, ancak sayı daha küçük");
                        yirmibescount = 0;
                    }

                    if (gelensayi < 30) {
                        otuzcount++;
                    } else if (gelensayi >= 30 && otuzcount > uncount[0].thirty) {
                        await UnCount.updateOne({}, { $set: { thirty: otuzcount } }).catch(console.error);
                        console.log("30 geldi");
                        otuzcount = 0;
                    } else {
                        console.log("30 veya üstü geldi, ancak sayı daha küçük");
                        otuzcount = 0;
                    }

                    if (gelensayi < 40) {
                        kirkcount++;
                    } else if (gelensayi >= 40 && kirkcount > uncount[0].forty) {
                        await UnCount.updateOne({}, { $set: { forty: kirkcount } }).catch(console.error);
                        console.log("40 geldi");
                        kirkcount = 0;
                    } else {
                        console.log("40 veya üstü geldi, ancak sayı daha küçük");
                        kirkcount = 0;
                    }

                    if (gelensayi < 50) {
                        ellicount++;
                    } else if (gelensayi >= 50 && ellicount > uncount[0].fifty) {
                        await UnCount.updateOne({}, { $set: { fifty: ellicount } }).catch(console.error);
                        console.log("50 geldi");
                        ellicount = 0;
                    } else {
                        console.log("50 veya üstü geldi, ancak sayı daha küçük");
                        ellicount = 0;
                    }

                    if (gelensayi < 60) {
                        atmiscount++;
                    } else if (gelensayi >= 60 && atmiscount > uncount[0].sixty) {
                        await UnCount.updateOne({}, { $set: { sixty: atmiscount } }).catch(console.error);
                        console.log("60 geldi");
                        atmiscount = 0;
                    } else {
                        console.log("60 veya üstü geldi, ancak sayı daha küçük");
                        atmiscount = 0;
                    }

                    if (gelensayi < 70) {
                        yetmiscount++;
                    } else if (gelensayi >= 70 && yetmiscount > uncount[0].seventy) {
                        await UnCount.updateOne({}, { $set: { seventy: yetmiscount } }).catch(console.error);
                        console.log("70 geldi");
                        yetmiscount = 0;
                    } else {
                        yetmiscount = 0;
                        console.log("70 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 80) {
                        seksencount++;
                    } else if (gelensayi >= 80 && seksencount > uncount[0].eighty) {
                        await UnCount.updateOne({}, { $set: { eighty: seksencount } }).catch(console.error);
                        console.log("80 geldi");
                        seksencount = 0;
                    } else {
                        seksencount = 0;
                        console.log("80 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 90) {
                        doksancount++;
                    } else if (gelensayi >= 90 && doksancount > uncount[0].ninety) {
                        await UnCount.updateOne({}, { $set: { ninety: doksancount } }).catch(console.error);
                        console.log("90 geldi");
                        doksancount = 0;
                    } else {
                        doksancount = 0;
                        console.log("90 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 100) {
                        yuzcount++;
                    } else if (gelensayi >= 100 && yuzcount > uncount[0].onehundred) {
                        await UnCount.updateOne({}, { $set: { onehundred: yuzcount } }).catch(console.error);
                        console.log("100 geldi");
                        yuzcount = 0;
                    } else {
                        yuzcount = 0;
                        console.log("100 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 120) {
                        yuzyirmicount++;
                    } else if (gelensayi >= 120 && yuzyirmicount > uncount[0].onehundredtwenty) {
                        await UnCount.updateOne({}, { $set: { onehundredtwenty: yuzyirmicount } }).catch(console.error);
                        console.log("120 geldi");
                        yuzyirmicount = 0;
                    } else {
                        yuzyirmicount = 0;
                        console.log("120 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 140) {
                        yuzkirkcount++;
                    } else if (gelensayi >= 140 && yuzkirkcount > uncount[0].onehundredforty) {
                        await UnCount.updateOne({}, { $set: { onehundredforty: yuzkirkcount } }).catch(console.error);
                        console.log("140 geldi");
                        yuzkirkcount = 0;
                    } else {
                        yuzkirkcount = 0;
                        console.log("140 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 160) {
                        yuzaltmiscount++;
                    } else if (gelensayi >= 160 && yuzaltmiscount > uncount[0].onehundredandsixty) {
                        await UnCount.updateOne({}, { $set: { onehundredandsixty: yuzaltmiscount } }).catch(console.error);
                        console.log("160 geldi");
                        yuzaltmiscount = 0;
                    } else {
                        yuzaltmiscount = 0;
                        console.log("160 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 200) {
                        ikiyuzcount++;
                    } else if (gelensayi >= 200 && ikiyuzcount > uncount[0].twohundred) {
                        await UnCount.updateOne({}, { $set: { twohundred: ikiyuzcount } }).catch(console.error);
                        console.log("200 geldi");
                        ikiyuzcount = 0;
                    } else {
                        ikiyuzcount = 0;
                        console.log("200 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 300) {
                        ucyuzcount++;
                    } else if (gelensayi >= 300 && ucyuzcount > uncount[0].threehundred) {
                        await UnCount.updateOne({}, { $set: { threehundred: ucyuzcount } }).catch(console.error);
                        console.log("300 geldi");
                        ucyuzcount = 0;
                    } else {
                        ucyuzcount = 0;
                        console.log("300 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 400) {
                        dortyuzcount++;
                    } else if (gelensayi >= 400 && dortyuzcount > uncount[0].fourhundred) {
                        await UnCount.updateOne({}, { $set: { fourhundred: dortyuzcount } }).catch(console.error);
                        console.log("400 geldi");
                        dortyuzcount = 0;
                    } else {
                        dortyuzcount = 0;
                        console.log("400 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 500) {
                        besyuzcount++;
                    } else if (gelensayi >= 500 && besyuzcount > uncount[0].fivehundred) {
                        await UnCount.updateOne({}, { $set: { fivehundred: besyuzcount } }).catch(console.error);
                        console.log("500 geldi");
                        besyuzcount = 0;
                    } else {
                        besyuzcount = 0;
                        console.log("500 veya üstü geldi, ancak sayı daha küçük");
                    }

                    if (gelensayi < 1000) {
                        bincountcount++;
                    } else if (gelensayi >= 1000 && bincountcount > uncount[0].onethousand) {
                        await UnCount.updateOne({}, { $set: { onethousand: bincountcount } }).catch(console.error);
                        console.log("1000 geldi");
                        bincountcount = 0;
                    } else {
                        bincountcount = 0;
                        console.log("1000 veya üstü geldi, ancak sayı daha küçük");
                    }
                }

            }
        }, 8000);
    } catch (error) {
        console.log("Hata:", error)
    }
})();