server.js

import { Hono } from 'hono';
import { serve } from '@hono/node-server';
import { chromium, firefox, webkit } from 'playwright';
import { logger } from 'hono/logger';
import { cors } from 'hono/cors';

const app = new Hono();

// Configuration (can be overridden by ENV)
const API_KEY = process.env.RENDERER_API_KEY || 'supersecret123';
const PORT = parseInt(process.env.PORT || '3000', 10);
const MAX_CONCURRENCY = parseInt(process.env.MAX_CONCURRENCY || '2', 10);
const BROWSER_ENGINE = process.env.BROWSER_ENGINE || 'chromium'; // chromium | firefox | webkit
const ALLOWED_ORIGINS = process.env.ALLOWED_ORIGINS || '*';

let browser = null;
let active = 0; // simple concurrency counter

// === Middleware ===
app.use('*', logger());
app.use('*', cors({
    origin: ALLOWED_ORIGINS === '*' ? '*' : ALLOWED_ORIGINS.split(','),
    allowMethods: ['GET', 'POST', 'OPTIONS'],
    allowHeaders: ['Content-Type', 'Authorization'],
}));

// === Helper: Auth middleware (simple Bearer token) ===
app.use('/screenshot', async (c, next) => {
    const auth = c.req.header('authorization') || '';
    if (!auth.startsWith('Bearer ')) return c.json({ error: 'Unauthorized' }, 401);
    const token = auth.slice(7).trim();
    if (!token || token !== API_KEY) return c.json({ error: 'Unauthorized' }, 401);
    await next();
});

app.use('/pdf', async (c, next) => {
    const auth = c.req.header('authorization') || '';
    if (!auth.startsWith('Bearer ')) return c.json({ error: 'Unauthorized' }, 401);
    const token = auth.slice(7).trim();
    if (!token || token !== API_KEY) return c.json({ error: 'Unauthorized' }, 401);
    await next();
});

app.use('/evaluate', async (c, next) => {
    const auth = c.req.header('authorization') || '';
    if (!auth.startsWith('Bearer ')) return c.json({ error: 'Unauthorized' }, 401);
    const token = auth.slice(7).trim();
    if (!token || token !== API_KEY) return c.json({ error: 'Unauthorized' }, 401);
    await next();
});

// === Helper: Acquire browser ===
async function getBrowser() {
    if (browser) return browser;
    const engine = (BROWSER_ENGINE || 'chromium').toLowerCase();
    if (engine === 'firefox') {
        browser = await firefox.launch({
            headless: true,
            args: ['--no-sandbox', '--disable-setuid-sandbox']
        });
    } else if (engine === 'webkit') {
        browser = await webkit.launch({ headless: true });
    } else {
        browser = await chromium.launch({
            headless: true,
            args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
        });
    }
    return browser;
}

// === Utility: normalize waitUntil values ===
function normalizeWaitUntil(input) {
    if (!input) return 'networkidle';
    const v = String(input).toLowerCase();
    // Playwright supports: 'load', 'domcontentloaded', 'networkidle'
    if (v === 'networkidle0' || v === 'networkidle2' || v === 'networkidle') return 'networkidle';
    if (v === 'domcontentloaded') return 'domcontentloaded';
    if (v === 'load') return 'load';
    return 'networkidle';
}

// === Basic JSON validation ===
function validateScreenshotBody(body) {
    if (!body || typeof body !== 'object') return 'body must be a JSON object';
    if (!body.url || typeof body.url !== 'string') return 'url (string) is required';
    if (body.viewport) {
        if (typeof body.viewport.width !== 'number' || typeof body.viewport.height !== 'number') {
            return 'viewport must contain numeric width and height';
        }
    }
    return null;
}

// === Root endpoint ===
app.get('/', (c) => {
    return c.json({
        name: 'Open Browser Rendering',
        version: '1.0.0',
        description: 'Open-source alternative to Cloudflare Browser Rendering API',
        endpoints: {
            screenshot: 'POST /screenshot',
            pdf: 'POST /pdf',
            evaluate: 'POST /evaluate',
            health: 'GET /health'
        },
        documentation: 'https://github.com/yourusername/OpenBrowserRendering'
    });
});

// === Screenshot Endpoint ===
app.post('/screenshot', async (c) => {
    // Concurrency check
    if (active >= MAX_CONCURRENCY) {
        return c.json({ error: 'Too many concurrent requests' }, 429);
    }

    active++;
    try {
        const body = await c.req.json().catch(() => null);
        const validationError = validateScreenshotBody(body);
        if (validationError) return c.json({ error: validationError }, 400);

        const url = body.url;
        const viewport = body.viewport || { width: 1280, height: 720 };
        const screenshotOptions = body.screenshotOptions || {};
        const gotoOptions = body.gotoOptions || {};

        // Normalize options
        const type = screenshotOptions.type === 'jpeg' ? 'jpeg' : 'png';
        const fullPage = Boolean(screenshotOptions.fullPage === true);
        const quality = typeof screenshotOptions.quality === 'number' ? screenshotOptions.quality : undefined; // for jpeg

        const waitUntil = normalizeWaitUntil(gotoOptions.waitUntil);
        const timeout = typeof gotoOptions.timeout === 'number' ? gotoOptions.timeout : 30000;

        const browser = await getBrowser();
        const context = await browser.newContext({ viewport });
        const page = await context.newPage();

        // Navigate
        await page.goto(url, { waitUntil, timeout });

        const opts = { fullPage, type };
        if (type === 'jpeg' && typeof quality === 'number') opts.quality = Math.max(1, Math.min(100, Math.floor(quality)));

        const buffer = await page.screenshot(opts);

        await context.close();

        const contentType = type === 'png' ? 'image/png' : 'image/jpeg';
        return new Response(buffer, { headers: { 'Content-Type': contentType } });
    } catch (err) {
        console.error('screenshot error', err);
        return c.json({ error: (err && err.message) || String(err) }, 500);
    } finally {
        active--;
    }
});

// === PDF Endpoint ===
app.post('/pdf', async (c) => {
    if (active >= MAX_CONCURRENCY) return c.json({ error: 'Too many concurrent requests' }, 429);
    active++;
    try {
        const body = await c.req.json().catch(() => null);
        if (!body || typeof body.url !== 'string') return c.json({ error: 'url (string) is required' }, 400);

        const url = body.url;
        const format = body.format || 'A4';
        const printBackground = body.printBackground !== false; // default true
        const gotoOptions = body.gotoOptions || {};
        const waitUntil = normalizeWaitUntil(gotoOptions.waitUntil);
        const timeout = typeof gotoOptions.timeout === 'number' ? gotoOptions.timeout : 30000;

        const browser = await getBrowser();
        const context = await browser.newContext();
        const page = await context.newPage();

        await page.goto(url, { waitUntil, timeout });

        const pdfBuffer = await page.pdf({ format, printBackground });

        await context.close();

        return new Response(pdfBuffer, { headers: { 'Content-Type': 'application/pdf' } });
    } catch (err) {
        console.error('pdf error', err);
        return c.json({ error: (err && err.message) || String(err) }, 500);
    } finally {
        active--;
    }
});

// === Evaluate Endpoint (safe-ish: runs inside page context) ===
app.post('/evaluate', async (c) => {
    if (active >= MAX_CONCURRENCY) return c.json({ error: 'Too many concurrent requests' }, 429);
    active++;
    try {
        const body = await c.req.json().catch(() => null);
        if (!body || typeof body.url !== 'string' || typeof body.script !== 'string') {
            return c.json({ error: 'url (string) and script (string) are required' }, 400);
        }

        const url = body.url;
        const script = body.script; // expected: a JS expression or function body that returns
        const gotoOptions = body.gotoOptions || {};
        const waitUntil = normalizeWaitUntil(gotoOptions.waitUntil);
        const timeout = typeof gotoOptions.timeout === 'number' ? gotoOptions.timeout : 30000;

        const browser = await getBrowser();
        const context = await browser.newContext();
        const page = await context.newPage();

        await page.goto(url, { waitUntil, timeout });

        // We evaluate script inside page context; wrap to return value
        const wrapped = `(function(){ try { return (${script}); } catch(e) { return {__error: String(e)}; } })()`;
        const result = await page.evaluate(wrapped);

        await context.close();

        if (result && result.__error) return c.json({ error: result.__error }, 500);
        return c.json({ result });
    } catch (err) {
        console.error('evaluate error', err);
        return c.json({ error: (err && err.message) || String(err) }, 500);
    } finally {
        active--;
    }
});

// === Health & metrics endpoints ===
app.get('/health', (c) => c.json({
    status: 'ok',
    active,
    maxConcurrency: MAX_CONCURRENCY,
    browserEngine: BROWSER_ENGINE,
    uptime: process.uptime()
}));

// === Start server (using Node's http serve wrapper) ===
console.log(`🚀 Open Browser Rendering Server`);
console.log(`📍 Port: ${PORT}`);
console.log(`🌐 Browser Engine: ${BROWSER_ENGINE}`);
console.log(`⚡ Max Concurrency: ${MAX_CONCURRENCY}`);
console.log(`🔐 API Key: ${API_KEY === 'supersecret123' ? '⚠️  Using default key (change in production!)' : '✓ Custom key set'}`);

serve({
    fetch: app.fetch,
    port: PORT
});

// Graceful shutdown
process.on('SIGINT', async () => {
    console.log('\n🛑 SIGINT received: closing browser');
    try {
        if (browser) await browser.close();
    } catch (e) {
        console.error('Error closing browser:', e);
    }
    process.exit(0);
});

process.on('SIGTERM', async () => {
    console.log('\n🛑 SIGTERM received: closing browser');
    try {
        if (browser) await browser.close();
    } catch (e) {
        console.error('Error closing browser:', e);
    }
    process.exit(0);
});