[Unit]
Description=CS2D Steam Avatar Proxy
After=network.target

[Service]
Type=simple
WorkingDirectory=/path/to/cs2d
ExecStart=/usr/bin/node steam_avatar_proxy.js
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

// ============================================================
// Steam Avatar Proxy - CS2D (Standalone Node.js, PNG with black fix)
// ============================================================

const fs = require('fs');
const path = require('path');
const axios = require('axios');
const sharp = require('sharp');

const PENDING_FILE = 'sys/pending_avatars.txt';
const AVATAR_DIR   = 'mods/avatars/';
const MAX_RETRIES  = 3;
const SCAN_INTERVAL_MS = 1000;
const REQUEST_TIMEOUT  = 15000; // ms

// Create directories if they don't exist
if (!fs.existsSync('sys')) fs.mkdirSync('sys', { recursive: true });
if (!fs.existsSync(AVATAR_DIR)) fs.mkdirSync(AVATAR_DIR, { recursive: true });
if (!fs.existsSync(PENDING_FILE)) fs.writeFileSync(PENDING_FILE, '');

const retryMap = {};
let processing = false;

function avatarFile(steamid) {
    // Now saving as PNG (required for color correction)
    return path.join(AVATAR_DIR, `${steamid}.png`);
}

/**
 * Downloads a Steam avatar, fixes absolute black pixels, saves as PNG.
 * Returns true on success.
 */
async function downloadAvatar(steamid) {
    const file = avatarFile(steamid);
    if (fs.existsSync(file)) return true; // already cached

    try {
        // 1. Fetch Steam profile XML
        const xmlUrl = `https://steamcommunity.com/profiles/${steamid}/?xml=1`;
        const xmlRes = await axios.get(xmlUrl, {
            timeout: REQUEST_TIMEOUT,
            headers: { 'User-Agent': 'CS2D-Avatar-Proxy/2.0' }
        });

        if (xmlRes.status !== 200 || !xmlRes.data) {
            throw new Error(`XML HTTP ${xmlRes.status}`);
        }

        // 2. Extract avatarMedium URL (64x64)
        const regex = /<avatarMedium><!\[CDATA\[(https?:\/\/[^\]]+)\]\]><\/avatarMedium>/;
        const match = xmlRes.data.match(regex);
        if (!match) {
            throw new Error('Avatar URL not found in XML');
        }

        let avatarUrl = match[1];
        // Force HTTPS
        avatarUrl = avatarUrl.replace(/^http:\/\//, 'https://');

        // 3. Download the image (usually JPEG)
        const imgRes = await axios.get(avatarUrl, {
            timeout: REQUEST_TIMEOUT,
            responseType: 'arraybuffer',
            headers: { 'User-Agent': 'CS2D-Avatar-Proxy/2.0' }
        });

        if (imgRes.status !== 200 || !imgRes.data) {
            throw new Error(`Image HTTP ${imgRes.status}`);
        }

        // 4. Convert to raw RGBA pixels and fix absolute black (#000000 -> #010101)
        const raw = await sharp(imgRes.data)
            .ensureAlpha()
            .raw()
            .toBuffer({ resolveWithObject: true });

        // raw.data is a Buffer of RGBA pixels (each pixel = 4 bytes)
        for (let i = 0; i < raw.data.length; i += 4) {
            // Check for absolute black (R=0, G=0, B=0) and fully opaque (A=255)
            if (raw.data[i] === 0 && raw.data[i+1] === 0 && raw.data[i+2] === 0 && raw.data[i+3] === 255) {
                raw.data[i]   = 1; // R -> 1
                raw.data[i+1] = 1; // G -> 1
                raw.data[i+2] = 1; // B -> 1
                // A remains 255
            }
        }

        // 5. Re-encode as PNG (lossless, preserves our pixel fix)
        const finalPng = await sharp(raw.data, {
            raw: {
                width: raw.info.width,
                height: raw.info.height,
                channels: 4
            }
        }).png().toBuffer();

        // 6. Save to disk
        fs.writeFileSync(file, finalPng);
        console.log(`[Proxy] Avatar saved (PNG, black-fixed): ${steamid}`);
        return true;

    } catch (error) {
        console.log(`[Proxy] Error ${steamid}: ${error.message}`);
        return false;
    }
}

async function processPending() {
    if (processing) return;
    processing = true;

    try {
        const content = fs.readFileSync(PENDING_FILE, 'utf8');
        let ids = content.split(/\r?\n/).map(v => v.trim()).filter(Boolean);
        // Remove duplicates
        ids = [...new Set(ids)];

        if (ids.length === 0) {
            processing = false;
            return;
        }

        console.log(`[Proxy] Processing ${ids.length} pending...`);
        const remaining = [];

        for (const steamid of ids) {
            if (retryMap[steamid] && retryMap[steamid] >= MAX_RETRIES) {
                console.log(`[Proxy] Giving up on ${steamid} (${MAX_RETRIES} attempts)`);
                continue;
            }

            const success = await downloadAvatar(steamid);
            if (success) {
                delete retryMap[steamid];
            } else {
                retryMap[steamid] = (retryMap[steamid] || 0) + 1;
                if (retryMap[steamid] < MAX_RETRIES) {
                    remaining.push(steamid);
                } else {
                    console.log(`[Proxy] Giving up on ${steamid} (${MAX_RETRIES} attempts)`);
                }
            }
        }

        fs.writeFileSync(PENDING_FILE, remaining.join('\n') + (remaining.length > 0 ? '\n' : ''));
        console.log(`[Proxy] Success: ${ids.length - remaining.length} OK, ${remaining.length} pending`);

    } catch (error) {
        console.error('[Proxy] Processing error:', error);
    } finally {
        processing = false;
    }
}

console.log('[Proxy] Started (standalone mode, PNG + black fix)');
setTimeout(processPending, 1000);
setInterval(processPending, SCAN_INTERVAL_MS);

process.on('SIGINT', () => { console.log('[Proxy] Shutting down'); process.exit(0); });
process.on('unhandledRejection', (err) => { console.error('[Proxy] Unhandled rejection:', err); });

-- ============================================================
-- Avatar management for CS2D (works with Node.js proxy)
-- ============================================================

-- Configuration
AVATAR_DIR = "mods/avatars/"
PENDING_FILE = "sys/pending_avatars.txt"

-- Table to prevent duplicate image() requests for the same player (optional)
ClientHas = ClientHas or {}

-- Helper: safely release an image handle
local function ReleaseImage(img)
    if type(img) == "number" then pcall(freeimage, img) end
    return nil
end

-- Helper: build the local avatar file path for a SteamID
function avatarPath(steamid)
    return AVATAR_DIR .. steamid .. ".png"
end

-- Hook called right before a player starts downloading resources
addhook("connect_initplayer", "OnConnectInitPlayer")
function OnConnectInitPlayer(id)
    -- Ignore bots
    if player(id, "bot") then return end
    
    if not ClientHas[id] then ClientHas[id] = {} end
    
    -- Iterate all online players to load their avatars for this client
    for _, pid in ipairs(player(0, "table")) do
        if player(pid, "exists") and not player(pid, "bot") then
            local steam = player(pid, "steamid")
            if steam and steam ~= "0" then
                if fileExists(avatarPath(steam)) then
                    -- Avatar file already cached: send it to the client
                    local img = image(avatarPath(steam), 0, 0, 0, id)
                    if img then ReleaseImage(img) end
                    ClientHas[id][steam] = true
                elseif pid == id then
                    -- It's the connecting player and their avatar doesn't exist yet:
                    -- register a pending request so the Node.js proxy can fetch it
                    local f = io.open(PENDING_FILE, "a")
                    if f then
                        f:write(steam .. "\n")
                        f:close()
                    end
                end
            end
        end
    end
end