Function bodies 63 total

async function autoLoadSnapshot() {
    try {
        const cfg = loadConfig();
        const candidates = [];
        if (cfg.scholarId) candidates.push(`data/${cfg.scholarId}_network.json`);
        candidates.push('data/network.json');

        let data = null;
        for (const url of candidates) {
            try {
                const resp = await fetch(url);
                if (resp.ok) {
                    data = await resp.json();
                    break;
                }
            } catch (e) { /* try next */ }
        }
        if (!data) return;
        if (!data.publications || data.publications.length === 0) return;

        currentPublications = data.publications;
        updateStats(currentPublications);

        // Restore geo data
        if (data.geoData && Object.keys(data.geoData).length > 0) {
            currentGeoData = data.geoData;
            const agg = aggregateGeoData(currentGeoData);
            currentGlobePoints = agg.points;
            current

function showLoading(text, pct, detail) {
    loadingOverlay.style.display = 'flex';
    loadingText.textContent = text || 'Loading...';
    progressFill.style.width = `${pct || 0}%`;
    loadingDetail.textContent = detail || '';
}

function hideLoading() {
    loadingOverlay.style.display = 'none';
}

function updateStats(publications) {
    const stats = computeStats(publications);
    document.getElementById('statPubs').textContent = `📄 ${stats.totalPubs}`;
    document.getElementById('statCitations').textContent = `📊 ${stats.totalCitations}`;
    document.getElementById('statHIndex').textContent = `📈 H: ${stats.hIndex}`;
}

function showTooltip(event, d) {
    let html = '';
    if (d.type === 'researcher') {
        html = `<div class="tt-title">${d.label}</div><div class="tt-meta">Center researcher</div>`;
    } else if (d.type === 'publication') {
        html = `<div class="tt-title">${d.label}</div>`;
        html += `<div class="tt-meta">Year: ${d.year || '—'} &nbsp;|&nbsp; Citations: ${d.citationCount || 0}</div>`;
        if (d.theme && d.theme !== 'Uncategorized') {
            html += `<span class="tt-theme" style="background:${d.themeColor}33;color:${d.themeColor}">${d.theme}</span>`;
        }
        if (d.summary) {
            html += `<div class="tt-summary">${d.summary}</div>`;
        }
        html += `<div class="tt-meta" style="margin-top:6px;font-style:italic">Click to ${d.childrenExpanded ? 'collapse' : 'expand'} citations</div>`;
    } else if (d.type === 'citation') {
        html = `<div class="tt-title">${d.label}</div>`;
        if (d.authors) html += `<div class="tt-meta">${d.

function hideTooltip() {
    tooltip.classList.remove('visible');
}

function toggleCitations(pubNode) {
    pubNode.childrenExpanded = !pubNode.childrenExpanded;
    const expand = pubNode.childrenExpanded;

    for (const node of currentNetwork.nodes) {
        if (node.type === 'citation' && node.parentPubId === pubNode.id) {
            node.hidden = !expand;
        }
    }

    applyFiltersAndRender();
}

function renderCurrentNetwork() {
    if (!currentNetwork || currentNetwork.nodes.length === 0) {
        emptyState.style.display = 'flex';
        return;
    }
    emptyState.style.display = 'none';
    btnExport.disabled = false;

    renderGraph(currentNetwork, {
        onTooltip: showTooltip,
        onHideTooltip: hideTooltip,
        onToggleCitations: toggleCitations,
    });
}

function applyFiltersAndRender() {
    if (!currentNetwork) return;

    const filters = {
        yearFrom: parseInt(filterYearFrom.value) || null,
        yearTo: parseInt(filterYearTo.value) || null,
        recentN: parseInt(filterRecentN.value) || null,
        search: filterSearch.value.trim() || null,
    };

    const hasFilters = Object.values(filters).some(v => v !== null);
    const displayed = hasFilters ? filterNetwork(currentNetwork, filters) : currentNetwork;

    renderGraph(displayed, {
        onTooltip: showTooltip,
        onHideTooltip: hideTooltip,
        onToggleCitations: toggleCitations,
    });
}

function renderRankings() {
    if (!currentGeoData || Object.keys(currentGeoData).length === 0) {
        rankingsSection.style.display = 'none';
        return;
    }

    const topK = parseInt(rankTopKInput.value) || 10;
    rankingsSection.style.display = 'block';

    // Aggregate by country
    const countryCounts = {};
    const institutionCounts = {};

    for (const [, info] of Object.entries(currentGeoData)) {
        if (info.country) {
            countryCounts[info.country] = (countryCounts[info.country] || 0) + 1;
        }
        if (info.institution) {
            const key = info.institution;
            if (!institutionCounts[key]) {
                institutionCounts[key] = { count: 0, country: info.country || '' };
            }
            institutionCounts[key].count += 1;
        }
    }

    // Sort and take top K
    const topCountries = Object.entries(countryCounts)
        .map(([name, count]) => ({ name, count }))
        .sort((a, b) => b.count - a.count)
 

export function exportNetworkJSON(networkData, scholarId) {
    const payload = {
        version: 1,
        exportedAt: new Date().toISOString(),
        scholarId,
        ...networkData,
    };
    const blob = new Blob([JSON.stringify(payload, null, 2)], { type: 'application/json' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = `${scholarId}_network.json`;
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
}

export function importNetworkJSON() {
    return new Promise((resolve) => {
        const input = document.getElementById('fileImport');
        input.value = '';

        const handler = (e) => {
            input.removeEventListener('change', handler);
            const file = e.target.files[0];
            if (!file) { resolve(null); return; }

            const reader = new FileReader();
            reader.onload = (ev) => {
                try {
                    const data = JSON.parse(ev.target.result);
                    resolve(data);
                } catch (err) {
                    alert('Invalid JSON file.');
                    resolve(null);
                }
            };
            reader.readAsText(file);
        };

        input.addEventListener('change', handler);
        input.click();
    });
}

export function mergePublications(existingPubs, newPubs) {
    const map = new Map();

    // Index existing by title
    for (const pub of existingPubs) {
        map.set(pub.title, pub);
    }

    // Add/update with new data
    for (const pub of newPubs) {
        if (map.has(pub.title)) {
            // Update citation count but keep cached citations list
            const existing = map.get(pub.title);
            existing.citationCount = pub.citationCount;
            existing.year = pub.year || existing.year;
            // If new data has more citations fetched, use those
            if (pub.citations && pub.citations.length > (existing.citations || []).length) {
                existing.citations = pub.citations;
            }
        } else {
            map.set(pub.title, pub);
        }
    }

    return Array.from(map.values());
}

export function buildCacheMap(pubs) {
    const m = {};
    for (const p of pubs) {
        m[p.title] = p;
    }
    return m;
}

export function loadConfig() {
    try {
        const raw = localStorage.getItem(CONFIG_KEY);
        if (raw) return { ...DEFAULTS, ...JSON.parse(raw) };
    } catch (e) { /* ignore */ }
    return { ...DEFAULTS };
}

export function saveConfig(cfg) {
    localStorage.setItem(CONFIG_KEY, JSON.stringify(cfg));
}

export function validateConfig(cfg) {
    const missing = [];
    if (!cfg.scholarId.trim()) missing.push('Scholar ID');
    if (!cfg.researcherName.trim()) missing.push('Researcher Name');
    if (!cfg.scraperKey.trim()) missing.push('ScraperAPI Key');
    return missing;
}

export function initSettingsModal() {
    const modal = document.getElementById('settingsModal');
    const btnOpen = document.getElementById('btnSettings');
    const btnClose = document.getElementById('btnCloseSettings');
    const btnCancel = document.getElementById('btnCancelSettings');
    const btnSave = document.getElementById('btnSaveSettings');

    const fields = {
        scholarId: document.getElementById('cfgScholarId'),
        researcherName: document.getElementById('cfgResearcherName'),
        scraperKey: document.getElementById('cfgScraperKey'),
        llmProvider: document.getElementById('cfgLlmProvider'),
        llmKey: document.getElementById('cfgLlmKey'),
        llmModel: document.getElementById('cfgLlmModel'),
    };

    function populateFields() {
        const cfg = loadConfig();
        for (const [key, el] of Object.entries(fields)) {
            el.value = cfg[key] || '';
        }
    }

    function openModal() {
        populateFields();
        modal

    function populateFields() {
        const cfg = loadConfig();
        for (const [key, el] of Object.entries(fields)) {
            el.value = cfg[key] || '';
        }
    }

    function openModal() {
        populateFields();
        modal.style.display = 'flex';
    }

    function closeModal() {
        modal.style.display = 'none';
    }

export function getCountryCoords(name) {
    if (!name) return null;
    const trimmed = name.trim();
    // Direct lookup
    if (COUNTRY_COORDS[trimmed]) return COUNTRY_COORDS[trimmed];
    // Case-insensitive
    const lower = trimmed.toLowerCase();
    for (const [key, val] of Object.entries(COUNTRY_COORDS)) {
        if (key.toLowerCase() === lower) return val;
    }
    return null;
}

function buildAliasMap() {
    const map = {};
    for (const [geoName, aliases] of Object.entries(COUNTRY_NAME_ALIASES)) {
        for (const alias of aliases) {
            map[alias.toLowerCase()] = geoName;
        }
        map[geoName.toLowerCase()] = geoName;
    }
    return map;
}

export function aggregateGeoData(geoData) {
    const countryCounts = {};
    const countryInstitutions = {};

    for (const [, info] of Object.entries(geoData)) {
        const country = info.country;
        if (!country) continue;
        countryCounts[country] = (countryCounts[country] || 0) + 1;
        if (info.institution) {
            if (!countryInstitutions[country]) countryInstitutions[country] = new Set();
            countryInstitutions[country].add(info.institution);
        }
    }

    const points = [];
    let totalMapped = 0;

    for (const [country, count] of Object.entries(countryCounts)) {
        totalMapped += count;
        const institutions = countryInstitutions[country]
            ? Array.from(countryInstitutions[country])
            : [];

        points.push({
            country,
            count,
            institutions,
        });
    }

    points.sort((a, b) => b.count - a.count);

    return {
        points,
        countryCount: Object.keys

async function loadGeoJson() {
    if (geoJsonData) return geoJsonData;
    const resp = await fetch('https://unpkg.com/world-atlas@2/countries-110m.json');
    const topoData = await resp.json();
    // Convert TopoJSON to GeoJSON using topojson-client
    // globe.gl can handle topojson directly via polygonsData, but we need
    // to use the hexed polygon layer. Let's use the geojson URL instead.
    geoJsonData = topoData;
    return geoJsonData;
}

function matchCountryToFeature(countryName, features) {
    const lower = countryName.toLowerCase();

    // Direct match on feature properties.name or properties.NAME
    for (const f of features) {
        const fName = (f.properties.name || f.properties.NAME || '').toLowerCase();
        if (fName === lower) return f;
    }

    // Try alias map
    const canonical = aliasMap[lower];
    if (canonical) {
        for (const f of features) {
            const fName = (f.properties.name || f.properties.NAME || '').toLowerCase();
            if (fName === canonical.toLowerCase()) return f;
        }
    }

    // Partial match
    for (const f of features) {
        const fName = (f.properties.name || f.properties.NAME || '').toLowerCase();
        if (fName.includes(lower) || lower.includes(fName)) return f;
    }

    return null;
}

export async function initGlobe(container, points, stats) {
    destroyGlobe();

    const width = container.clientWidth;
    const height = container.clientHeight;

    // Find max count for brightness normalization
    const maxCount = Math.max(...points.map(p => p.count), 1);

    // Build country → data lookup
    const countryDataMap = {};
    for (const p of points) {
        countryDataMap[p.country.toLowerCase()] = p;
        // Also index by aliases
        const canonical = aliasMap[p.country.toLowerCase()];
        if (canonical) countryDataMap[canonical.toLowerCase()] = p;
    }

    // Load GeoJSON for country polygons
    const geoUrl = 'https://cdn.jsdelivr.net/npm/world-atlas@2/countries-110m.json';

    globeInstance = Globe()
        .globeImageUrl('//unpkg.com/three-globe/example/img/earth-night.jpg')
        .bumpImageUrl('//unpkg.com/three-globe/example/img/earth-topology.png')
        .backgroundImageUrl('//unpkg.com/three-globe/example/img/night-sky.png')
       

function getCountryData(feature, countryDataMap) {
    const name = (feature.properties.name || feature.properties.NAME || '').toLowerCase();
    if (countryDataMap[name]) return countryDataMap[name];
    // Try alias
    const canonical = aliasMap[name];
    if (canonical && countryDataMap[canonical.toLowerCase()]) {
        return countryDataMap[canonical.toLowerCase()];
    }
    // Try partial
    for (const [key, val] of Object.entries(countryDataMap)) {
        if (name.includes(key) || key.includes(name)) return val;
    }
    return null;
}

function interpolateGlowColor(t) {
    // Low: dim indigo → Medium: purple → High: bright cyan-white
    if (t < 0.33) {
        const r = Math.round(60 + t * 3 * 40);
        const g = Math.round(50 + t * 3 * 50);
        const b = Math.round(140 + t * 3 * 60);
        return `rgba(${r}, ${g}, ${b}, ${0.4 + t * 0.3})`;
    } else if (t < 0.66) {
        const s = (t - 0.33) / 0.33;
        const r = Math.round(100 + s * 68);
        const g = Math.round(100 + s * 55);
        const b = Math.round(200 + s * 47);
        return `rgba(${r}, ${g}, ${b}, ${0.55 + s * 0.2})`;
    } else {
        const s = (t - 0.66) / 0.34;
        const r = Math.round(168 + s * 87);
        const g = Math.round(155 + s * 100);
        const b = Math.round(247);
        return `rgba(${r}, ${g}, ${b}, ${0.75 + s * 0.25})`;
    }
}

function topoFeatures(topology, objectName) {
    const obj = topology.objects[objectName];
    if (!obj) {
        // Try first available object
        const key = Object.keys(topology.objects)[0];
        if (!key) return [];
        return topoFeatures(topology, key);
    }

    const arcs = topology.arcs;
    const transform = topology.transform;

    function decodeArc(arcIdx) {
        const reversed = arcIdx < 0;
        const idx = reversed ? ~arcIdx : arcIdx;
        const arc = arcs[idx];
        const coords = [];
        let x = 0, y = 0;

        for (const [dx, dy] of arc) {
            x += dx;
            y += dy;
            const lng = transform ? x * transform.scale[0] + transform.translate[0] : x;
            const lat = transform ? y * transform.scale[1] + transform.translate[1] : y;
            coords.push([lng, lat]);
        }

        return reversed ? coords.reverse() : coords;
    }

    function decodeRing(ring) {
        const coords = [];
        for (con

    function decodeArc(arcIdx) {
        const reversed = arcIdx < 0;
        const idx = reversed ? ~arcIdx : arcIdx;
        const arc = arcs[idx];
        const coords = [];
        let x = 0, y = 0;

        for (const [dx, dy] of arc) {
            x += dx;
            y += dy;
            const lng = transform ? x * transform.scale[0] + transform.translate[0] : x;
            const lat = transform ? y * transform.scale[1] + transform.translate[1] : y;
            coords.push([lng, lat]);
        }

        return reversed ? coords.reverse() : coords;
    }

    function decodeRing(ring) {
        const coords = [];
        for (const arcIdx of ring) {
            const arcCoords = decodeArc(arcIdx);
            // Skip first point of subsequent arcs to avoid duplicates
            coords.push(...(coords.length > 0 ? arcCoords.slice(1) : arcCoords));
        }
        return coords;
    }

    function decodeGeometry(geom) {
        if (geom.type === 'Polygon') {
            return {
                type: 'Polygon',
                coordinates: geom.arcs.map(decodeRing),
            };
        } else if (geom.type === 'MultiPolygon') {
            return {
                type: 'MultiPolygon',
                coordinates: geom.arcs.map(polygon => polygon.map(decodeRing)),
            };
        }
        return geom;
    }

function updateGlobeStats(container, stats) {
    let overlay = container.querySelector('.globe-stats');
    if (!overlay) {
        overlay = document.createElement('div');
        overlay.className = 'globe-stats';
        container.appendChild(overlay);
    }

    overlay.innerHTML = `
        <div class="globe-stat-item">
            <span class="globe-stat-number">${stats.totalMapped}</span>
            <span class="globe-stat-label">Mapped Citations</span>
        </div>
        <div class="globe-stat-item">
            <span class="globe-stat-number">${stats.countryCount}</span>
            <span class="globe-stat-label">Countries</span>
        </div>
    `;
}

export function updateGlobeData(points, stats) {
    if (!globeInstance) return;
    // Would need to re-init to update polygon colors properly
    const container = globeInstance.domElement?.parentElement;
    if (container) {
        initGlobe(container, points, stats);
    }
}

export function destroyGlobe() {
    if (globeInstance) {
        const container = globeInstance.domElement?.parentElement;
        if (container?._resizeHandler) {
            window.removeEventListener('resize', container._resizeHandler);
        }
        globeInstance._destructor?.();
        globeInstance = null;
    }
}

export function initGraph(container) {
    width = container.clientWidth;
    height = container.clientHeight;

    svg = d3.select(container)
        .append('svg')
        .attr('width', width)
        .attr('height', height);

    // Defs for gradients and glow
    const defs = svg.append('defs');

    const glowFilter = defs.append('filter').attr('id', 'glow');
    glowFilter.append('feGaussianBlur').attr('stdDeviation', '3').attr('result', 'coloredBlur');
    const feMerge = glowFilter.append('feMerge');
    feMerge.append('feMergeNode').attr('in', 'coloredBlur');
    feMerge.append('feMergeNode').attr('in', 'SourceGraphic');

    g = svg.append('g');

    // Zoom behavior
    const zoom = d3.zoom()
        .scaleExtent([0.1, 5])
        .on('zoom', (event) => {
            g.attr('transform', event.transform);
        });
    svg.call(zoom);

    // Handle window resize
    window.addEventListener('resize', () => {
        width = container.clientWidth;
        height = container

export function renderGraph(network, callbacks = {}) {
    currentNetwork = network;

    // Clear previous
    g.selectAll('*').remove();

    const visibleNodes = network.nodes.filter(n => !n.hidden);
    const visibleNodeIds = new Set(visibleNodes.map(n => n.id));
    const visibleLinks = network.links.filter(l => {
        const src = typeof l.source === 'object' ? l.source.id : l.source;
        const tgt = typeof l.target === 'object' ? l.target.id : l.target;
        return visibleNodeIds.has(src) && visibleNodeIds.has(tgt);
    });

    // Force simulation
    simulation = d3.forceSimulation(visibleNodes)
        .force('link', d3.forceLink(visibleLinks).id(d => d.id).distance(d => {
            if (d.type === 'researcher-pub') return 120;
            return 60;
        }))
        .force('charge', d3.forceManyBody().strength(d => {
            if (d.type === 'researcher') return -400;
            if (d.type === 'publication') return -100;
            return -30;
        }))
  

function getNodeRadius(d) {
    if (d.type === 'researcher') return NODE_SIZES.researcher;
    if (d.type === 'publication') {
        return Math.max(NODE_SIZES.publication, Math.min(20, 5 + Math.sqrt(d.citationCount || 0) * 1.5));
    }
    return NODE_SIZES.citation;
}

function getNodeColor(d) {
    if (d.type === 'researcher') return '#6366f1';
    if (d.type === 'publication') return d.themeColor || '#6366f1';
    return '#4a4a6a';
}

function dragStarted(event, d) {
    if (!event.active) simulation.alphaTarget(0.3).restart();
    d.fx = d.x;
    d.fy = d.y;
}

function dragged(event, d) {
    d.fx = event.x;
    d.fy = event.y;
}

function dragEnded(event, d) {
    if (!event.active) simulation.alphaTarget(0);
    d.fx = null;
    d.fy = null;
}

function renderLegend(themes) {
    const legend = document.getElementById('legend');
    if (!themes || themes.length === 0) {
        legend.style.display = 'none';
        return;
    }

    legend.style.display = 'block';
    legend.innerHTML = `
        <h4>Research Themes</h4>
        ${themes.map(t => `
            <div class="legend-item">
                <span class="legend-dot" style="background:${t.color}"></span>
                <span>${t.name}</span>
            </div>
        `).join('')}
        <div class="legend-item" style="margin-top:8px;border-top:1px solid rgba(100,100,180,0.15);padding-top:6px;">
            <span class="legend-dot" style="background:#4a4a6a"></span>
            <span style="color:#8888aa">Citations (click pub to show)</span>
        </div>
    `;
}

export function destroyGraph() {
    if (simulation) simulation.stop();
    if (svg) svg.remove();
    svg = null;
    g = null;
    simulation = null;
}

async function callLLM(provider, apiKey, model, prompt) {
    if (provider === 'openai') {
        return await callOpenAI(apiKey, model || 'gpt-4o-mini', prompt);
    } else if (provider === 'claude') {
        return await callClaude(apiKey, model || 'claude-sonnet-4-20250514', prompt);
    } else if (provider === 'gemini') {
        return await callGemini(apiKey, model || 'gemini-pro', prompt);
    }
    throw new Error(`Unknown LLM provider: ${provider}`);
}

async function callOpenAI(apiKey, model, prompt) {
    const resp = await fetch('https://api.openai.com/v1/chat/completions', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${apiKey}`,
        },
        body: JSON.stringify({
            model,
            messages: [{ role: 'user', content: prompt }],
            temperature: 0.3,
        }),
    });
    if (!resp.ok) {
        const err = await resp.text();
        throw new Error(`OpenAI API error ${resp.status}: ${err}`);
    }
    const data = await resp.json();
    return data.choices[0].message.content;
}

async function callClaude(apiKey, model, prompt) {
    // Note: Claude API requires server-side calls due to CORS.
    // We use a CORS proxy approach or the user needs to handle this.
    // For direct browser use, we'll try the API directly.
    const resp = await fetch('https://api.anthropic.com/v1/messages', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'x-api-key': apiKey,
            'anthropic-version': '2023-06-01',
            'anthropic-dangerous-direct-browser-access': 'true',
        },
        body: JSON.stringify({
            model,
            max_tokens: 4096,
            messages: [{ role: 'user', content: prompt }],
        }),
    });
    if (!resp.ok) {
        const err = await resp.text();
        throw new Error(`Claude API error ${resp.status}: ${err}`);
    }
    const data = await resp.json();
    return data.content[0].text;
}

async function callGemini(apiKey, model, prompt) {
    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
    const resp = await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            contents: [{ parts: [{ text: prompt }] }],
        }),
    });
    if (!resp.ok) {
        const err = await resp.text();
        throw new Error(`Gemini API error ${resp.status}: ${err}`);
    }
    const data = await resp.json();
    return data.candidates[0].content.parts[0].text;
}

export async function analyzePapers(publications, config, onProgress) {
    if (!config.llmKey) {
        return { summaries: {}, themes: {} };
    }

    const titles = publications.map((p, i) => `${i + 1}. ${p.title} (${p.year})`).join('\n');

    // ── Step 1: Cluster into themes ──
    onProgress('Clustering publications into themes...', 92);

    const clusterPrompt = `You are a research analyst. Given these academic publication titles, categorize them into broad, high-level research disciplines.

Use broad categories like: Healthcare, Economics, NLP, Computer Vision, Reinforcement Learning, Operations Research, Robotics, Finance, Education, Climate Science, Cybersecurity, Bioinformatics, Social Science, Materials Science, etc.

Do NOT create narrow or paper-specific themes. Each theme should be a well-known academic field or discipline that a general audience would recognize. Aim for 3-7 broad themes total.

Publications:
${titles}

Respond ONLY with valid JSON (no markdown, no c