const express = require('express');
const cors = require('cors');
const { connect } = require("puppeteer-real-browser");

const app = express();
app.use(cors());
app.use(express.json());

const PORT = process.env.PORT || 7860;
const MAX_CONCURRENT_BROWSERS = 3; 
let activeBrowsers = 0;

async function createBrowser(proxy = null) {
    const options = {
        headless: false,
        turnstile: true,
        args: [
            '--no-sandbox',
            '--disable-setuid-sandbox',
            '--disable-dev-shm-usage',
            '--disable-accelerated-2d-canvas',
            '--no-first-run',
            '--no-zygote',
            '--disable-gpu',
            '--window-size=1920,1080',
            '--disable-blink-features=AutomationControlled'
        ],
        executablePath: process.env.CHROME_PATH || "/usr/bin/google-chrome-stable",
        customConfig: {},
        connectOption: { defaultViewport: null }
    };

    if (proxy) {
        options.args.push(`--proxy-server=${proxy.hostname}:${proxy.port}`);
    }

    const { browser, page } = await connect(options);
    
    if (proxy && proxy.username && proxy.password) {
        await page.authenticate({ username: proxy.username, password: proxy.password });
    }

    return { browser, page };
}

async function handleCloudflare(page, url) {
    return new Promise(async (resolve, reject) => {
        const timeout = setTimeout(() => reject(new Error("Timeout Cloudflare Bypass")), 120000);

        try {
            console.log(`[Cloudflare] Navigating to ${url}`);
            
            let cookieFoundTime = 0;
            let finalCookieValue = "";
            let hasForcedNavigated = false;

            page.on('response', async resp => {
                try {
                    const headers = resp.headers();
                    const setCookie = headers['set-cookie'] || headers['Set-Cookie'] || headers['set-cookie'.toLowerCase()];
                    
                    if (setCookie) {
                        const cookieStr = Array.isArray(setCookie) ? setCookie.join(' ') : setCookie;
                        if (cookieStr.includes('cf_clearance')) {
                            if (cookieFoundTime === 0) {
                                cookieFoundTime = Date.now();
                                console.log(`[Cloudflare] 🔥 FAST DETECT: cf_clearance found via Listener!`);
                                const match = cookieStr.match(/cf_clearance=([^;]+)/);
                                if (match) finalCookieValue = match[1];
                            }
                        }
                    }
                } catch(e){}
            });

            await page.bringToFront();
            await page.goto(url, { waitUntil: "domcontentloaded", timeout: 60000 });

            const loop = setInterval(async () => {
                try {
                    const title = await page.title();
                    const content = await page.content();
                    const currentTime = Date.now();
                    const cookies = await page.cookies();

                    const cfCookie = cookies.find(c => c.name === 'cf_clearance');
                    if (cfCookie) {
                         if (cookieFoundTime === 0) console.log(`[Cloudflare] Cookie found in storage.`);
                         cookieFoundTime = cookieFoundTime || Date.now();
                         finalCookieValue = cfCookie.value;
                    }

                    const isChallengePage = title.includes("Just a moment") || 
                                          content.includes("challenge-platform") || 
                                          title.includes("Cloudflare");

                    if (!isChallengePage && title.trim().length > 0) {
                        clearInterval(loop);
                        clearTimeout(timeout);
                        const ua = await page.evaluate(() => navigator.userAgent);
                        console.log(`[Cloudflare] Success! Page Title: ${title}`);
                        resolve({
                            status: "success",
                            userAgent: ua,
                            cookies_full: cookies,
                            cookie: finalCookieValue,
                            title: title
                        });
                        return;
                    }

                    if (cookieFoundTime > 0 && (currentTime - cookieFoundTime) > 5000 && !hasForcedNavigated) {
                        console.log("[Cloudflare] Cookie found but stuck. Performing FORCE NAVIGATION...");
                        hasForcedNavigated = true;
                        await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 }).catch(()=>{});
                        return;
                    }

                    if (hasForcedNavigated && (currentTime - cookieFoundTime) > 20000) {
                        clearInterval(loop);
                        clearTimeout(timeout);
                        console.log("[Cloudflare] Giving up waiting for title change. Returning valid cookie.");
                        const ua = await page.evaluate(() => navigator.userAgent);
                        resolve({
                            status: "success",
                            userAgent: ua,
                            cookies_full: cookies,
                            cookie: finalCookieValue,
                            title: title
                        });
                        return;
                    }

                    const frames = page.frames();
                    const challengeFrame = frames.find(f => f.url().includes("challenges.cloudflare.com") || f.url().includes("turnstile"));
                    
                    if (challengeFrame) {
                        try {
                            const checkbox = await challengeFrame.$("input[type='checkbox']");
                            if (checkbox) {
                                const isChecked = await challengeFrame.evaluate(el => el.checked, checkbox);
                                if (!isChecked) {
                                    console.log("[Cloudflare] Checkbox found & clicked!");
                                    await checkbox.click();
                                }
                            } else {
                                await challengeFrame.click('body').catch(()=>{});
                            }
                        } catch(e) {}
                    }

                    try {
                        await page.mouse.move(Math.floor(Math.random() * 500), Math.floor(Math.random() * 500));
                        if (Math.random() > 0.95) await page.click('body').catch(()=>{});
                    } catch (err) {}

                } catch (e) {}
            }, 1000); 

        } catch (e) {
            clearTimeout(timeout);
            reject(e);
        }
    });
}

async function handleTurnstile(page, url, siteKey) {
    return new Promise(async (resolve, reject) => {
        const timeout = setTimeout(() => reject(new Error("Timeout Turnstile")), 60000);
        try {
            const htmlContent = `<!DOCTYPE html><html lang="en"><body><div class="cf-turnstile" data-sitekey="${siteKey}" data-callback="turnstileCallback"></div><script src="https://challenges.cloudflare.com/turnstile/v0/api.js" async defer></script><script>function turnstileCallback(token) { window.cf_token = token; }</script></body></html>`;
            await page.setRequestInterception(true);
            page.once('request', request => request.respond({ status: 200, contentType: 'text/html', body: htmlContent }));
            page.on('request', req => { if (req.isInterceptResolutionHandled()) return; req.continue(); });
            await page.goto(url, { waitUntil: "domcontentloaded" });
            const checkToken = setInterval(async () => {
                try {
                    const token = await page.evaluate(() => window.cf_token);
                    if (token) { clearInterval(checkToken); clearTimeout(timeout); resolve({ token: token }); }
                } catch (e) {}
            }, 1000);
        } catch (e) { clearTimeout(timeout); reject(e); }
    });
}

app.post('/bypass', async (req, res) => {
    const { url, mode, siteKey, proxy } = req.body;
    if (!url || !mode) return res.status(400).json({ status: "error", message: "Missing url or mode" });
    if (activeBrowsers >= MAX_CONCURRENT_BROWSERS) return res.status(429).json({ status: "busy", message: "Server busy" });

    activeBrowsers++;
    let browserInstance = null;
    try {
        console.log(`[REQ] Processing: ${url} | Mode: ${mode}`);
        const { browser, page } = await createBrowser(proxy);
        browserInstance = browser;
        let result;
        if (mode === 'turnstile') result = await handleTurnstile(page, url, siteKey);
        else if (mode === 'cloudflare') result = await handleCloudflare(page, url);
        else throw new Error("Invalid mode");
        console.log(`[SUCCESS] Operation completed for ${mode}`);
        res.json({ status: "success", ...result });
    } catch (error) {
        console.error(`[ERROR] ${error.message}`);
        res.status(500).json({ status: "error", message: error.message });
    } finally {
        if (browserInstance) try { await browserInstance.close(); } catch {}
        activeBrowsers--;
    }
});

app.get('/', (req, res) => res.send("Server Running"));
app.listen(PORT, () => console.log(`Server listening on port ${PORT}`));