const express = require('express');
const nodeHtmlToImage = require('node-html-to-image');
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');

const app = express();
const PORT = 3000;
const CACHE_DIR = path.join(__dirname, 'cache');

// Create cache directory if it doesn't exist
if (!fs.existsSync(CACHE_DIR)) {
    fs.mkdirSync(CACHE_DIR);
}

app.use(express.json({ limit: '1gb' }));
app.use(express.urlencoded({ limit: '1gb', extended: true }));

// Request logging middleware
app.use((req, res, next) => {
    const timestamp = new Date().toISOString();
    console.log(`\n[${timestamp}] ${req.method} ${req.url}`);

    if (req.method === 'POST' && req.body) {
        const logBody = { ...req.body };

        // Truncate long base64 strings for readability
        if (logBody.avatarUrl && logBody.avatarUrl.startsWith('data:')) {
            logBody.avatarUrl = logBody.avatarUrl.substring(0, 50) + '... (base64 truncated)';
        }
        if (logBody.imageUrl && logBody.imageUrl.startsWith('data:')) {
            logBody.imageUrl = logBody.imageUrl.substring(0, 50) + '... (base64 truncated)';
        }

        console.log('Body:', JSON.stringify(logBody, null, 2));
    }

    if (req.method === 'GET' && Object.keys(req.query).length > 0) {
        const logQuery = { ...req.query };

        // Truncate long base64 strings for readability
        if (logQuery.avatarUrl && logQuery.avatarUrl.startsWith('data:')) {
            logQuery.avatarUrl = logQuery.avatarUrl.substring(0, 50) + '... (base64 truncated)';
        }
        if (logQuery.imageUrl && logQuery.imageUrl.startsWith('data:')) {
            logQuery.imageUrl = logQuery.imageUrl.substring(0, 50) + '... (base64 truncated)';
        }

        console.log('Query:', JSON.stringify(logQuery, null, 2));
    }

    next();
});

function normalizeConfig(config) {
    // Remove null, undefined, and empty string values
    const normalized = {};
    for (const [key, value] of Object.entries(config)) {
        if (value !== null && value !== undefined && value !== '') {
            normalized[key] = value;
        }
    }
    return normalized;
}

function hashConfig(config) {
    const normalized = normalizeConfig(config);
    const configString = JSON.stringify(normalized);
    return crypto.createHash('sha256').update(configString).digest('hex');
}

function getCachePath(hash) {
    return path.join(CACHE_DIR, `${hash}.png`);
}

function getCachedImage(config) {
    const hash = hashConfig(config);
    const cachePath = getCachePath(hash);

    if (fs.existsSync(cachePath)) {
        // Update file modification time to mark as recently accessed
        const now = new Date();
        fs.utimesSync(cachePath, now, now);
        return fs.readFileSync(cachePath);
    }

    return null;
}

function cacheImage(config, imageBuffer) {
    const hash = hashConfig(config);
    const cachePath = getCachePath(hash);
    fs.writeFileSync(cachePath, imageBuffer);
}

function clearCache() {
    if (!fs.existsSync(CACHE_DIR)) {
        return;
    }

    const files = fs.readdirSync(CACHE_DIR);
    files.forEach(file => {
        const filePath = path.join(CACHE_DIR, file);
        fs.unlinkSync(filePath);
    });

    console.log(`Cleared ${files.length} cached image(s)`);
}

function cleanupOldCache() {
    const ONE_DAY = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
    const now = Date.now();

    if (!fs.existsSync(CACHE_DIR)) {
        return;
    }

    const files = fs.readdirSync(CACHE_DIR);

    let deletedCount = 0;
    files.forEach(file => {
        const filePath = path.join(CACHE_DIR, file);
        const stats = fs.statSync(filePath);

        // Check if file was last modified more than 24 hours ago
        if (now - stats.mtime.getTime() > ONE_DAY) {
            fs.unlinkSync(filePath);
            deletedCount++;
        }
    });

    if (deletedCount > 0) {
        console.log(`Cleaned up ${deletedCount} cached image(s)`);
    }
}

function formatTimestamp(epoch) {
    const date = new Date(epoch * 1000);

    const hours = date.getHours();
    const minutes = date.getMinutes().toString().padStart(2, '0');
    const ampm = hours >= 12 ? 'PM' : 'AM';
    const hour12 = hours % 12 || 12;

    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
    const month = months[date.getMonth()];
    const day = date.getDate();
    const year = date.getFullYear();

    return `${hour12}:${minutes} ${ampm} · ${month} ${day}, ${year}`;
}

async function generateQuoteBuffer(config) {
    // Build HTML directly with values injected
    const avatarHtml = config.avatarUrl
        ? `<img src="${config.avatarUrl}" style="width:100%;height:100%;object-fit:cover;" />`
        : `<div style="width:100%;height:100%;background:rgb(51,54,57);"></div>`;

    const imageHtml = config.imageUrl
        ? `<div class="tweet-image-container" style="margin-bottom:12px;border-radius:16px;overflow:hidden;border:1px solid rgb(47,51,54);"><img src="${config.imageUrl}" style="width:100%;display:block;" /></div>`
        : '';

    const html = `<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <style>
        body {
            margin: 0;
            height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            background-color: #000;
        }
        .square-container {
            width: calc(100vmin - 20px);
            height: calc(100vmin - 20px);
            display: flex;
            justify-content: center;
            align-items: center;
            background-color: #000;
            overflow: hidden;
        }
        .tweet-container {
            width: 450px;
            background-color: #000;
            padding: 12px 16px;
            box-sizing: border-box;
        }
        .tweet-header {
            display: flex;
            align-items: flex-start;
            margin-bottom: 12px;
        }
        .avatar {
            width: 40px;
            height: 40px;
            border-radius: 50%;
            overflow: hidden;
            margin-right: 12px;
            background: rgb(51, 54, 57);
        }
        .user-info {
            display: flex;
            flex-direction: column;
        }
        .display-name {
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            font-size: 15px;
            font-weight: 700;
            color: rgb(231, 233, 234);
            line-height: 20px;
        }
        .username {
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            font-size: 15px;
            color: rgb(113, 118, 123);
            line-height: 20px;
        }
        .tweet-text {
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            font-size: 15px;
            color: rgb(231, 233, 234);
            line-height: 20px;
            margin-bottom: 12px;
            white-space: pre-wrap;
        }
        .tweet-time {
            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
            font-size: 15px;
            color: rgb(113, 118, 123);
        }
    </style>
</head>
<body>
<div class="square-container">
    <div class="tweet-container">
        <div class="tweet-header">
            <div class="avatar">${avatarHtml}</div>
            <div class="user-info">
                <span class="display-name">${config.displayName}</span>
                <span class="username">${config.username}</span>
            </div>
        </div>
        <div class="tweet-text">${config.text}</div>
        ${imageHtml}
        <div class="tweet-time">${config.timestamp}</div>
    </div>
</div>
<script>
    function fitToSquare() {
        const square = document.querySelector('.square-container');
        const tweet = document.querySelector('.tweet-container');
        const scaleX = square.offsetWidth / tweet.offsetWidth;
        const scaleY = square.offsetHeight / tweet.offsetHeight;
        const scale = Math.min(scaleX, scaleY) * 0.95;
        tweet.style.transform = 'scale(' + scale + ')';
    }
    window.onload = fitToSquare;
</script>
</body>
</html>`;

    const image = await nodeHtmlToImage({
        html: html,
        puppeteerArgs: {
            args: ['--no-sandbox'],
            defaultViewport: {
                width: 3240,
                height: 3240
            }
        },
        beforeScreenshot: async (page) => {
            await new Promise(resolve => setTimeout(resolve, 1000));
        }
    });

    return image;
}

// GET endpoint - use query parameters
app.get('/generate', async (req, res) => {
    try {
        const timestamp = req.query.timestamp ? formatTimestamp(parseInt(req.query.timestamp)) : formatTimestamp(Date.now() / 1000);

        const config = {
            displayName: req.query.displayName || "Anonymous",
            username: req.query.username || "@anonymous",
            avatarUrl: fixDataUri(req.query.avatarUrl) || null,
            text: req.query.text || "No text provided",
            imageUrl: fixDataUri(req.query.imageUrl) || null,
            timestamp: timestamp,
            viewsCount: req.query.viewsCount || "0"
        };

        // Check cache first
        let image = getCachedImage(config);
        let fromCache = true;

        if (!image) {
            // Generate new image
            image = await generateQuoteBuffer(config);
            cacheImage(config, image);
            fromCache = false;
        }

        res.setHeader('Content-Type', 'image/png');
        res.setHeader('X-Cache', fromCache ? 'HIT' : 'MISS');
        res.send(image);
    } catch (error) {
        console.error(error);
        res.status(500).json({ error: 'Failed to generate image' });
    }
});

// POST endpoint - use request body
function detectImageType(base64String) {
    // Extract base64 data
    const base64Data = base64String.includes(',') ? base64String.split(',')[1] : base64String;
    const buffer = Buffer.from(base64Data, 'base64');

    // Check magic numbers
    if (buffer[0] === 0xFF && buffer[1] === 0xD8 && buffer[2] === 0xFF) {
        return 'image/jpeg';
    } else if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4E && buffer[3] === 0x47) {
        return 'image/png';
    } else if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
        return 'image/gif';
    } else if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46) {
        return 'image/webp';
    }
    return 'image/png'; // default fallback
}

function fixDataUri(dataUri) {
    if (!dataUri || !dataUri.startsWith('data:')) return dataUri;

    // Extract the base64 part
    const parts = dataUri.split(',');
    if (parts.length !== 2) return dataUri;

    const base64Data = parts[1];

    try {
        const correctType = detectImageType(base64Data);
        return `data:${correctType};base64,${base64Data}`;
    } catch (error) {
        console.error('Invalid base64 data:', error.message);
        return null;
    }
}

app.post('/generate', async (req, res) => {
    try {
        const timestamp = req.body.timestamp ? formatTimestamp(parseInt(req.body.timestamp)) : formatTimestamp(Date.now() / 1000);

        const username = req.body.username?.trim();

        const config = {
            displayName: req.body.displayName || "Anonymous",
            username: (username && username !== "@") ? username : "@anonymous",
            avatarUrl: fixDataUri(req.body.avatarUrl) || null,
            text: req.body.text || "No text provided",
            imageUrl: fixDataUri(req.body.imageUrl) || null,
            timestamp: timestamp,
            viewsCount: req.body.viewsCount || "0"
        };

        // Check cache first
        let image = getCachedImage(config);
        let fromCache = true;

        if (!image) {
            // Generate new image
            image = await generateQuoteBuffer(config);
            cacheImage(config, image);
            fromCache = false;
        }

        res.setHeader('Content-Type', 'image/png');
        res.setHeader('X-Cache', fromCache ? 'HIT' : 'MISS');
        res.send(image);
    } catch (error) {
        console.error(error);
        res.status(500).json({ error: 'Failed to generate image' });
    }
});

// Health check endpoint
app.get('/health', (req, res) => {
    res.status(200).json({ status: 'ok' });
});

// Clear all cache on startup
clearCache();

// Run cleanup every hour
setInterval(() => {
    cleanupOldCache();
}, 60 * 60 * 1000);

app.listen(PORT, () => {
    console.log(`Quote generator API running on http://localhost:${PORT}`);
    console.log(`GET:  http://localhost:${PORT}/generate?text=Hello&displayName=Test&username=@test&timestamp=1735574400`);
    console.log(`POST: http://localhost:${PORT}/generate`);
    console.log(`Cache cleared on startup, cleanup runs every hour`);
});