.. заглавие: BGP/IP WHOIS търсене
.. slug: bgp-whois-търсене
.. дата: 2026-01-02 15:00:00 UTC
.. тагове: калкулатори, работа в мрежа, bgp, whois, asn, geoip
.. категория: Калкулатори
.. връзка:
.. описание: Потърсете BGP ASN, WHOIS информация за контакт и GeoIP местоположение за всеки IP адрес или ASN
.. тип: текст
<style>
    .bgp-lookup-container {
        max-width: 1000px;
        margin: 20px auto;
        padding: 20px;
    }

    .search-box {
        margin-bottom: 30px;
        padding: 25px;
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        border-radius: 12px;
        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
        color: white;
    }

    .search-box h2 {
        margin-top: 0;
        color: white;
        font-size: 28px;
        margin-bottom: 10px;
    }

    .search-box p {
        margin: 10px 0;
        opacity: 0.95;
        font-size: 15px;
    }

    .input-group {
        display: flex;
        gap: 10px;
        margin-top: 20px;
    }

    #ipInput {
        flex: 1;
        padding: 14px;
        font-size: 16px;
        border: 2px solid rgba(255,255,255,0.3);
        border-radius: 6px;
        font-family: 'Courier New', monospace;
        background: rgba(255,255,255,0.95);
        transition: all 0.3s ease;
    }

    #ipInput:focus {
        outline: none;
        border-color: #4CAF50;
        background: white;
        box-shadow: 0 0 0 3px rgba(76, 175, 80, 0.1);
    }

    #searchBtn {
        padding: 14px 35px;
        font-size: 16px;
        background: #4CAF50;
        color: white;
        border: none;
        border-radius: 6px;
        cursor: pointer;
        font-weight: bold;
        transition: all 0.3s ease;
        box-shadow: 0 2px 4px rgba(0,0,0,0.2);
    }

    #searchBtn:hover {
        background: #45a049;
        transform: translateY(-1px);
        box-shadow: 0 4px 8px rgba(0,0,0,0.3);
    }

    #searchBtn:active {
        background: #3d8b40;
        transform: translateY(0);
    }

    #searchBtn:disabled {
        background: #ccc;
        cursor: not-allowed;
        transform: none;
    }

    .help-text {
        margin-top: 15px;
        font-size: 14px;
        color: rgba(255,255,255,0.9);
        background: rgba(0,0,0,0.1);
        padding: 10px 15px;
        border-radius: 4px;
    }

    .help-text strong {
        color: white;
    }

    .results {
        margin-top: 30px;
        display: none;
    }

    .results.show {
        display: block;
    }

    .result-section {
        background: white;
        border: 1px solid #e0e0e0;
        border-radius: 8px;
        margin-bottom: 15px;
        overflow: hidden;
        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
        transition: all 0.3s ease;
    }

    .result-section:hover {
        box-shadow: 0 4px 8px rgba(0,0,0,0.1);
    }

    .section-header {
        background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%);
        color: white;
        padding: 15px 20px;
        cursor: pointer;
        display: flex;
        justify-content: space-between;
        align-items: center;
        user-select: none;
        transition: background 0.3s ease;
    }

    .section-header:hover {
        background: linear-gradient(135deg, #45a049 0%, #3d8b40 100%);
    }

    .section-header h3 {
        margin: 0;
        font-size: 18px;
        display: flex;
        align-items: center;
        gap: 10px;
    }

    .section-header .icon {
        font-size: 20px;
    }

    .section-toggle {
        font-size: 24px;
        transition: transform 0.3s ease;
    }

    .section-header.collapsed .section-toggle {
        transform: rotate(-90deg);
    }

    .section-content {
        padding: 20px;
        background: #fafafa;
        max-height: 1000px;
        overflow: hidden;
        transition: max-height 0.3s ease, padding 0.3s ease;
    }

    .section-content.collapsed {
        max-height: 0;
        padding: 0 20px;
    }

    .data-row {
        display: flex;
        margin: 12px 0;
        padding: 10px;
        background: white;
        border-radius: 4px;
        border-left: 3px solid #4CAF50;
    }

    .data-label {
        font-weight: bold;
        color: #555;
        min-width: 180px;
        flex-shrink: 0;
    }

    .data-value {
        color: #333;
        font-family: 'Courier New', monospace;
        word-break: break-word;
    }

    .data-value.highlight {
        color: #4CAF50;
        font-weight: bold;
    }

    .data-value a {
        color: #2196F3;
        text-decoration: none;
    }

    .data-value a:hover {
        text-decoration: underline;
    }

    .loading {
        text-align: center;
        padding: 40px;
        color: #666;
    }

    .loading .spinner {
        border: 4px solid #f3f3f3;
        border-top: 4px solid #4CAF50;
        border-radius: 50%;
        width: 40px;
        height: 40px;
        animation: spin 1s linear infinite;
        margin: 0 auto 20px;
    }

    @keyframes spin {
        0% { transform: rotate(0deg); }
        100% { transform: rotate(360deg); }
    }

    .error {
        background: #ffebee;
        color: #c62828;
        padding: 15px 20px;
        border-radius: 8px;
        border-left: 4px solid #c62828;
        margin: 20px 0;
    }

    .warning {
        background: #fff3e0;
        color: #e65100;
        padding: 15px 20px;
        border-radius: 8px;
        border-left: 4px solid #ff9800;
        margin: 20px 0;
    }

    .info {
        background: #e3f2fd;
        color: #1565c0;
        padding: 15px 20px;
        border-radius: 8px;
        border-left: 4px solid #2196F3;
        margin: 20px 0;
    }

    .no-data {
        text-align: center;
        padding: 30px;
        color: #999;
        font-style: italic;
    }

    .stats {
        margin-top: 30px;
        padding: 20px;
        background: white;
        border-radius: 8px;
        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
        font-size: 14px;
        color: #666;
        border-top: 3px solid #4CAF50;
    }

    .stats strong {
        color: #333;
    }

    .example-queries {
        margin-top: 15px;
        padding: 15px;
        background: rgba(0,0,0,0.05);
        border-radius: 4px;
    }

    .example-queries strong {
        display: block;
        margin-bottom: 8px;
        color: white;
    }

    .example-link {
        display: inline-block;
        margin: 4px 8px 4px 0;
        padding: 6px 12px;
        background: rgba(255,255,255,0.2);
        color: white;
        text-decoration: none;
        border-radius: 4px;
        font-size: 13px;
        font-family: monospace;
        transition: all 0.2s ease;
    }

    .example-link:hover {
        background: rgba(255,255,255,0.3);
        transform: translateY(-1px);
    }

    /* IP Reputation Styles */
    .reputation-alert {
        margin: 15px 0;
        padding: 15px 20px;
        border-radius: 8px;
        border-left: 4px solid;
        display: flex;
        align-items: flex-start;
        gap: 15px;
    }

    .reputation-alert.clean {
        background: #e8f5e9;
        border-color: #4CAF50;
        color: #2e7d32;
    }

    .reputation-alert.warning {
        background: #fff3e0;
        border-color: #ff9800;
        color: #e65100;
    }

    .reputation-alert.critical {
        background: #ffebee;
        border-color: #f44336;
        color: #c62828;
    }

    .reputation-icon {
        font-size: 32px;
        flex-shrink: 0;
    }

    .reputation-content {
        flex: 1;
    }

    .reputation-title {
        font-weight: bold;
        font-size: 16px;
        margin-bottom: 8px;
    }

    .reputation-details {
        font-size: 14px;
        line-height: 1.6;
    }

    .reputation-badge {
        display: inline-block;
        padding: 4px 10px;
        border-radius: 4px;
        font-size: 12px;
        font-weight: bold;
        margin: 4px 4px 4px 0;
    }

    .reputation-badge.firehol-1 {
        background: #f44336;
        color: white;
    }

    .reputation-badge.firehol-2 {
        background: #ff9800;
        color: white;
    }

    .reputation-badge.firehol-3 {
        background: #ffc107;
        color: #333;
    }

    .reputation-badge.ipsum {
        background: #9c27b0;
        color: white;
    }

    .reputation-description {
        margin-top: 10px;
        padding: 10px;
        background: rgba(0,0,0,0.05);
        border-radius: 4px;
        font-size: 13px;
    }

    /* Transfer History Styles */
    .transfer-timeline {
        position: relative;
        padding-left: 30px;
        margin: 20px 0;
    }

    .transfer-timeline::before {
        content: '';
        position: absolute;
        left: 10px;
        top: 0;
        bottom: 0;
        width: 2px;
        background: linear-gradient(180deg, #4CAF50 0%, #2196F3 100%);
    }

    .transfer-record {
        position: relative;
        margin-bottom: 20px;
        padding: 15px;
        background: white;
        border: 1px solid #e0e0e0;
        border-radius: 8px;
        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
        transition: all 0.3s ease;
    }

    .transfer-record:hover {
        box-shadow: 0 4px 8px rgba(0,0,0,0.1);
        transform: translateX(4px);
    }

    .transfer-record::before {
        content: '';
        position: absolute;
        left: -24px;
        top: 20px;
        width: 10px;
        height: 10px;
        border-radius: 50%;
        background: #4CAF50;
        border: 2px solid white;
        box-shadow: 0 0 0 2px #4CAF50;
    }

    .transfer-date {
        font-weight: bold;
        color: #4CAF50;
        font-size: 14px;
        margin-bottom: 8px;
        display: flex;
        align-items: center;
        gap: 8px;
    }

    .transfer-date::before {
        content: '📅';
        font-size: 16px;
    }

    .transfer-type {
        display: inline-block;
        padding: 4px 10px;
        background: #e3f2fd;
        color: #1565c0;
        border-radius: 4px;
        font-size: 12px;
        font-weight: bold;
        margin-left: 10px;
    }

    .transfer-parties {
        display: grid;
        grid-template-columns: 1fr auto 1fr;
        gap: 15px;
        align-items: center;
        margin: 15px 0;
        padding: 12px;
        background: #f8f9fa;
        border-radius: 6px;
    }

    .transfer-party {
        text-align: center;
    }

    .transfer-party-label {
        font-size: 11px;
        text-transform: uppercase;
        color: #666;
        font-weight: bold;
        margin-bottom: 5px;
        letter-spacing: 0.5px;
    }

    .transfer-party-name {
        font-weight: 600;
        color: #333;
        font-size: 14px;
    }

    .transfer-party-country {
        font-size: 12px;
        color: #666;
        margin-top: 3px;
    }

    .transfer-arrow {
        font-size: 24px;
        color: #4CAF50;
    }

    .transfer-resources {
        margin-top: 12px;
        padding: 10px;
        background: white;
        border: 1px solid #e0e0e0;
        border-radius: 4px;
    }

    .transfer-resources-label {
        font-size: 12px;
        font-weight: bold;
        color: #666;
        margin-bottom: 6px;
        text-transform: uppercase;
    }

    .transfer-resource-item {
        font-family: 'Courier New', monospace;
        color: #1976d2;
        font-size: 13px;
        padding: 4px 8px;
        background: #f5f5f5;
        border-radius: 3px;
        display: inline-block;
        margin: 2px 4px 2px 0;
    }

    .transfer-rir-info {
        margin-top: 10px;
        font-size: 12px;
        color: #666;
        display: flex;
        gap: 20px;
    }

    .transfer-rir-info span {
        display: flex;
        align-items: center;
        gap: 5px;
    }

    .transfer-count-badge {
        display: inline-block;
        background: #4CAF50;
        color: white;
        padding: 4px 10px;
        border-radius: 12px;
        font-size: 12px;
        font-weight: bold;
        margin-left: 10px;
    }

    /* Responsive design */
    @media (max-width: 768px) {
        .input-group {
            flex-direction: column;
        }

        #searchBtn {
            width: 100%;
        }

        .data-row {
            flex-direction: column;
        }

        .data-label {
            margin-bottom: 5px;
            min-width: auto;
        }
    }
</style>
<div class="bgp-lookup-container">
<div class="search-box">
<h2>BGP/IP WHOIS търсене</h2>
<p>Открийте мрежата зад всеки IP адрес или ASN. Получете информация за маршрутизиране на BGP, подробности за WHOIS регистрация и географско местоположение.</p>
<div class="input-group">
<input autocomplete="off" id="ipInput" placeholder="e.g., 8.8.8.8, 2001:4860:4860::8888, AS15169, or 1.1.1.0/24" type="text"/>
<button id="searchBtn" onclick="searchIP()">Търсене</button>
</div>
<div class="help-text">
<strong>Поддържани формати:</strong>IPv4 (8.8.8.8) • IPv6 (2001:4860:4860::8888) • ASN (AS15169 или 15169) • CIDR (1.1.1.0/24)</div>
<div class="example-queries">
<strong>Опитайте тези примери:</strong>
<a class="example-link" href="#" onclick="searchExample('8.8.8.8'); return false;">8.8.8.8</a>
<a class="example-link" href="#" onclick="searchExample('2001:4860:4860::8888'); return false;">2001:4860:4860::8888</a>
<a class="example-link" href="#" onclick="searchExample('1.1.1.1'); return false;">1.1.1.1</a>
<a class="example-link" href="#" onclick="searchExample('AS15169'); return false;">AS15169</a>
<a class="example-link" href="#" onclick="searchExample('2606:4700:4700::1111'); return false;">2606:4700:4700::1111</a>
</div>
</div>
<div class="error" id="errorMessage" style="display: none;"></div>
<div class="results" id="results">
Информационен раздел за BGP ASN
<div class="result-section" id="asnSection">
<div class="section-header" onclick="toggleSection('asn')">
<h3><span class="icon">🔢</span>BGP ASN информация</h3>
<span class="section-toggle">▼</span>
</div>
<div class="section-content" id="asnContent">
<div class="no-data">Няма налични данни</div>
</div>
</div>
Информационен раздел WHOIS
<div class="result-section" id="whoisSection">
<div class="section-header" onclick="toggleSection('whois')">
<h3><span class="icon">📋</span>WHOIS информация</h3>
<span class="section-toggle">▼</span>
</div>
<div class="section-content" id="whoisContent">
<div class="no-data">Няма налични данни</div>
</div>
</div>
Раздел за географско местоположение
<div class="result-section" id="geoipSection">
<div class="section-header" onclick="toggleSection('geoip')">
<h3><span class="icon">📍</span>Географско местоположение</h3>
<span class="section-toggle">▼</span>
</div>
<div class="section-content" id="geoipContent">
<div class="no-data">Няма налични данни</div>
</div>
</div>
Секция за IP репутация
<div class="result-section" id="reputationSection" style="display: none;">
<div class="section-header" onclick="toggleSection('reputation')">
<h3><span class="icon">🛡️</span>IP репутация</h3>
<span class="section-toggle">▼</span>
</div>
<div class="section-content" id="reputationContent">
<div class="no-data">Няма налични данни</div>
</div>
</div>
Секция за история на прехвърлянето
<div class="result-section" id="transferSection">
<div class="section-header" onclick="toggleSection('transfer')">
<h3><span class="icon">🔄</span>История на прехвърлянето</h3>
<span class="section-toggle">▼</span>
</div>
<div class="section-content" id="transferContent">
<div class="no-data">Няма налични данни</div>
</div>
</div>
</div>
<div class="stats">
<strong>Информация за базата данни:</strong><br/>
<div style="margin-top: 15px; padding-top: 15px; border-top: 1px solid #e0e0e0; font-size: 12px;">
<strong>Източници на данни:</strong>MaxMind GeoLite2, CAIDA AS организации, RIPE NCC, APNIC, LACNIC, ARIN<br/>
<strong>Данни за репутацията:</strong>
<a href="https://github.com/firehol/blocklist-ipsets" rel="noopener" target="_blank">Списъци с блокирани IP адреси на FireHOL</a>,
            <a href="https://github.com/stamparm/ipsum" rel="noopener" target="_blank">IPsum разузнаване на заплахи</a><br/>
<strong>История на трансферите:</strong>Доклади за трансфер на RIR (ARIN, APNIC, LACNIC)<br/>
<strong>Последна актуализация:</strong>2026-01-04 •<strong>Поверителност:</strong>Всички търсения се извършват от страна на клиента от публични RIR бази данни</div>
</div>
</div>
<script>
/**
 * BGP/IP WHOIS Lookup Tool - Hierarchical File-Based Lookups
 * Efficient lookups that only fetch the specific file needed.
 *
 * File Structure:
 *   IPv4: /data/ipv4/{first_octet}.json (e.g., /data/ipv4/8.json for 8.x.x.x)
 *   IPv6: /data/ipv6/{first_hextet}.json (e.g., /data/ipv6/2606.json for 2606::/16)
 *   ASN:  /data/asn/{range}.json (e.g., /data/asn/10000-19999.json for ASN 15169)
 *   Transfers: /data/transfers/latest.json (historical transfer records)
 *
 * Data Structure:
 *   Each file contains: { "ranges": [ {...}, {...} ] }
 *   Multiple ranges may match a single IP (e.g., /24 and /22)
 *   Most specific prefix (highest /XX value) is selected
 *   Ranges may include reputation field: { "listed": true, "firehol_level": 1 }
 *
 * Features:
 *   - BGP ASN Information (AS numbers, organizations, prefixes)
 *   - WHOIS Registration Data (contacts, status, RIR information)
 *   - GeoIP Location (country, city, coordinates, timezone)
 *   - IP Reputation (FireHOL levels 1-3, IPsum threat scores)
 *   - Transfer History (chronological ownership changes)
 *
 * Changelog:
 *   v2.3.0 (2026-01-04): Added IP Reputation and Transfer History features
 *                        - IP Reputation: FireHOL blocklists (levels 1-3) and IPsum scores
 *                        - Visual alerts for malicious IPs with severity indicators
 *                        - Transfer History: displays chronological IP/ASN transfers
 *                        - Timeline-based UI for transfer records
 *   v2.2.0 (2026-01-02): Fixed IPv6 :: compression normalization algorithm
 *                        - Rewrote normalizeIPv6() to properly handle all :: positions
 *                        - Split on :: first, then process before/after groups
 *                        - Fixes: 2606:4700:4700::1111, 2603:9000:3240:41a4:75dc::0
 *   v2.1.0 (2026-01-02): Multiple range matching, most-specific prefix selection
 *
 * @version 2.3.0
 * @date 2026-01-04
 */

'use strict';

// ============================================================================
// Configuration
// ============================================================================

const CONFIG = {
    dataBasePath: '/data',
    ipv4Path: '/data/ipv4',
    ipv6Path: '/data/ipv6',
    asnPath: '/data/asn',
    asnBucketSize: 10000,
    cacheEnabled: true,
    cacheTTL: 3600000 // 1 hour in milliseconds
};

// Simple in-memory cache
const dataCache = new Map();

// ============================================================================
// Path Building Functions
// ============================================================================

/**
 * Get hierarchical path for IPv4 address by first octet
 * @param {string} ip - IPv4 address (e.g., "8.8.8.8")
 * @returns {string} - Path to JSON file (e.g., "/data/ipv4/8.json")
 */
function getIPv4Path(ip) {
    const firstOctet = ip.split('.')[0];
    return `${CONFIG.ipv4Path}/${firstOctet}.json`;
}

/**
 * Get hierarchical path for IPv6 address by first 16 bits (first hextet)
 * @param {string} ip - IPv6 address (e.g., "2001:4860:4860::8888")
 * @returns {string} - Path to JSON file (e.g., "/data/ipv6/2001.json")
 */
function getIPv6Path(ip) {
    // Normalize and expand the IPv6 address
    const normalized = normalizeIPv6(ip);
    if (!normalized) {
        throw new Error('Invalid IPv6 address');
    }

    // Get first 4 hex digits (first hextet)
    const firstHextet = normalized.substring(0, 4).toLowerCase();
    return `${CONFIG.ipv6Path}/${firstHextet}.json`;
}

/**
 * Get hierarchical path for ASN grouped by buckets of 10,000
 * @param {number} asn - AS number (e.g., 15169)
 * @returns {string} - Path to JSON file (e.g., "/data/asn/10000-19999.json")
 */
function getASNPath(asn) {
    const bucketStart = Math.floor(asn / CONFIG.asnBucketSize) * CONFIG.asnBucketSize;
    const bucketEnd = bucketStart + CONFIG.asnBucketSize - 1;
    return `${CONFIG.asnPath}/${bucketStart}-${bucketEnd}.json`;
}

// ============================================================================
// Data Fetching with Caching
// ============================================================================

/**
 * Fetch hierarchical data file with caching support
 * @param {string} path - Path to JSON file
 * @returns {Promise<Object|null>} - Parsed JSON data or null if not found
 */
async function fetchHierarchicalData(path) {
    // Check cache first
    if (CONFIG.cacheEnabled && dataCache.has(path)) {
        const cached = dataCache.get(path);
        if (Date.now() - cached.timestamp < CONFIG.cacheTTL) {
            console.log(`Cache hit: ${path}`);
            return cached.data;
        }
        // Cache expired, remove it
        dataCache.delete(path);
    }

    try {
        console.log(`Fetching: ${path}`);
        const response = await fetch(path);

        if (!response.ok) {
            if (response.status === 404) {
                console.warn(`File not found: ${path}`);
                return null;
            }
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();

        // Cache the result
        if (CONFIG.cacheEnabled) {
            dataCache.set(path, {
                data,
                timestamp: Date.now()
            });
        }

        return data;
    } catch (error) {
        console.error(`Error fetching ${path}:`, error);
        throw error;
    }
}

// ============================================================================
// IP Conversion Utilities
// ============================================================================

/**
 * Convert IPv4 address to 32-bit unsigned integer
 * @param {string} ip - IPv4 address (e.g., "8.8.8.8")
 * @returns {number} - 32-bit unsigned integer
 */
function ipv4ToInt(ip) {
    const parts = ip.split('.');
    return (parseInt(parts[0]) << 24 |
            parseInt(parts[1]) << 16 |
            parseInt(parts[2]) << 8 |
            parseInt(parts[3])) >>> 0;
}

/**
 * Normalize IPv6 address to full canonical form (remove :: compression)
 * Handles compressed notation, leading zeros, and various formats
 * @param {string} ip - IPv6 address in any valid format
 * @returns {string|null} - Normalized IPv6 address (32 hex digits with colons) or null if invalid
 */
function normalizeIPv6(ip) {
    // Trim whitespace
    ip = ip.trim();

    // Handle IPv4-mapped IPv6 addresses (::ffff:192.0.2.1)
    const ipv4MappedMatch = ip.match(/^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/i);
    if (ipv4MappedMatch) {
        const ipv4 = ipv4MappedMatch[1];
        const ipv4Parts = ipv4.split('.');
        if (ipv4Parts.every(p => {
            const num = parseInt(p, 10);
            return num >= 0 && num <= 255;
        })) {
            // Convert IPv4 to hex
            const hex1 = (parseInt(ipv4Parts[0]) * 256 + parseInt(ipv4Parts[1])).toString(16).padStart(4, '0');
            const hex2 = (parseInt(ipv4Parts[2]) * 256 + parseInt(ipv4Parts[3])).toString(16).padStart(4, '0');
            return `0000:0000:0000:0000:0000:ffff:${hex1}:${hex2}`;
        }
        return null;
    }

    // Handle :: compression by replacing :: with appropriate number of :0:
    if (ip.indexOf('::') !== -1) {
        // Check for multiple :: (invalid)
        if ((ip.match(/::/g) || []).length > 1) {
            return null;
        }

        // Count existing groups (non-empty parts when split by single :)
        // We need to handle :: specially
        let beforeDouble = '';
        let afterDouble = '';

        if (ip.startsWith('::')) {
            // Starts with :: (e.g., "::1" or "::ffff:...")
            afterDouble = ip.substring(2);
        } else if (ip.endsWith('::')) {
            // Ends with :: (e.g., "fe80::")
            beforeDouble = ip.substring(0, ip.length - 2);
        } else {
            // :: in the middle (e.g., "2001:db8::1")
            const doubleSplit = ip.split('::');
            beforeDouble = doubleSplit[0];
            afterDouble = doubleSplit[1];
        }

        // Count groups before and after ::
        const beforeGroups = beforeDouble ? beforeDouble.split(':').filter(g => g !== '') : [];
        const afterGroups = afterDouble ? afterDouble.split(':').filter(g => g !== '') : [];

        const existingGroups = beforeGroups.length + afterGroups.length;
        if (existingGroups > 7) {
            return null; // Too many groups for :: compression
        }

        // Calculate zero groups to insert
        const zeroGroups = 8 - existingGroups;

        // Build complete address
        const allGroups = [
            ...beforeGroups,
            ...Array(zeroGroups).fill('0'),
            ...afterGroups
        ];

        // Validate and normalize each group
        if (allGroups.length !== 8) {
            return null;
        }

        const normalized = allGroups.map(group => {
            if (!/^[0-9a-fA-F]{1,4}$/.test(group)) {
                return null;
            }
            return group.padStart(4, '0');
        });

        if (normalized.includes(null)) {
            return null;
        }

        return normalized.join(':');
    } else {
        // No compression, validate parts
        const parts = ip.split(':');
        if (parts.length !== 8) {
            return null;
        }

        const normalized = parts.map(part => {
            if (!/^[0-9a-fA-F]{1,4}$/.test(part)) {
                return null;
            }
            return part.padStart(4, '0');
        });

        if (normalized.includes(null)) {
            return null;
        }

        return normalized.join(':');
    }
}

/**
 * Convert IPv6 address to 128-bit BigInt
 * @param {string} ip - Normalized IPv6 address
 * @returns {BigInt} - 128-bit integer representation
 */
function ipv6ToBigInt(ip) {
    const normalized = normalizeIPv6(ip);
    if (!normalized) {
        throw new Error('Invalid IPv6 address');
    }

    // Remove colons and parse as hex
    const hexString = normalized.replace(/:/g, '');
    return BigInt('0x' + hexString);
}

// ============================================================================
// Input Validation
// ============================================================================

/**
 * Validate and identify input type
 * @param {string} input - User input
 * @returns {Object} - {valid: boolean, type: string, value: any, error?: string}
 */
function validateInput(input) {
    input = input.trim();

    // ASN format: AS15169 or 15169
    const asnMatch = input.match(/^(?:AS)?(\d+)$/i);
    if (asnMatch) {
        const asn = parseInt(asnMatch[1], 10);
        if (asn >= 0 && asn <= 4294967295) {
            return { valid: true, type: 'asn', value: asn };
        }
        return { valid: false, error: 'ASN out of valid range (0-4294967295)' };
    }

    // IPv4 address
    const ipv4Regex = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
    const ipv4Match = input.match(ipv4Regex);
    if (ipv4Match) {
        const octets = ipv4Match.slice(1, 5).map(Number);
        if (octets.every(o => o >= 0 && o <= 255)) {
            return { valid: true, type: 'ipv4', value: input };
        }
        return { valid: false, error: 'Invalid IPv4 address (octets must be 0-255)' };
    }

    // IPv4 CIDR (convert to ipv4 type and use network address)
    const cidrV4Regex = /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\/(\d{1,2})$/;
    const cidrV4Match = input.match(cidrV4Regex);
    if (cidrV4Match) {
        const ip = cidrV4Match[1];
        const prefix = parseInt(cidrV4Match[2], 10);
        const ipResult = validateInput(ip);
        if (ipResult.valid && prefix >= 0 && prefix <= 32) {
            // Treat CIDR as IPv4 lookup using the network address
            return { valid: true, type: 'ipv4', value: ip };
        }
        return { valid: false, error: 'Invalid IPv4 CIDR (prefix must be 0-32)' };
    }

    // IPv6 CIDR (extract address part)
    const cidrV6Regex = /^([0-9a-fA-F:]+)\/(\d{1,3})$/;
    const cidrV6Match = input.match(cidrV6Regex);
    if (cidrV6Match) {
        const ip = cidrV6Match[1];
        const prefix = parseInt(cidrV6Match[2], 10);
        if (prefix >= 0 && prefix <= 128) {
            // Validate the IPv6 address part
            const normalized = normalizeIPv6(ip);
            if (normalized) {
                // Treat CIDR as IPv6 lookup using the network address
                return { valid: true, type: 'ipv6', value: ip };
            }
        }
        return { valid: false, error: 'Invalid IPv6 CIDR (prefix must be 0-128)' };
    }

    // IPv6 address (must contain at least one colon)
    if (input.includes(':')) {
        const normalized = normalizeIPv6(input);
        if (normalized) {
            return { valid: true, type: 'ipv6', value: input };
        }
        return { valid: false, error: 'Invalid IPv6 address format' };
    }

    return { valid: false, error: 'Unrecognized input format. Supported: IPv4 (8.8.8.8), IPv6 (2001:4860:4860::8888), CIDR (2001:db8::/32), ASN (AS15169 or 15169)' };
}

// ============================================================================
// Range Searching
// ============================================================================

/**
 * Extract prefix length from CIDR notation
 * @param {string} prefix - CIDR prefix (e.g., "216.39.244.0/24")
 * @returns {number} - Prefix length or 0 if invalid
 */
function getPrefixLength(prefix) {
    if (!prefix || typeof prefix !== 'string') return 0;
    const match = prefix.match(/\/(\d+)$/);
    return match ? parseInt(match[1], 10) : 0;
}

/**
 * Find matching IP ranges and select most specific
 * @param {number|BigInt} ipInt - IP as integer (number for IPv4, BigInt for IPv6)
 * @param {Array} ranges - Array of range objects with start/end properties
 * @returns {Object|null} - Matching range with merged data or null
 */
function findMatchingRange(ipInt, ranges) {
    if (!ranges || ranges.length === 0) {
        return null;
    }

    // Determine if we're working with BigInt (IPv6) or number (IPv4)
    const isBigInt = typeof ipInt === 'bigint';

    // Find ALL matching ranges (not just first match)
    const matchingRanges = [];

    for (let i = 0; i < ranges.length; i++) {
        const range = ranges[i];

        // Convert range boundaries to BigInt if needed
        const rangeStart = isBigInt ? BigInt(range.start) : range.start;
        const rangeEnd = isBigInt ? BigInt(range.end) : range.end;

        if (ipInt >= rangeStart && ipInt <= rangeEnd) {
            matchingRanges.push(range);
        }
    }

    if (matchingRanges.length === 0) {
        return null;
    }

    // If single match, return it
    if (matchingRanges.length === 1) {
        return matchingRanges[0];
    }

    // Multiple matches: select most specific prefix and merge data
    // Most specific = highest prefix length (e.g., /24 > /22 > /16)
    matchingRanges.sort((a, b) => {
        const lenA = getPrefixLength(a.prefix);
        const lenB = getPrefixLength(b.prefix);
        return lenB - lenA; // Descending order (highest first)
    });

    // Start with the most specific prefix as base
    const mostSpecific = matchingRanges[0];
    const mergedResult = { ...mostSpecific };

    // Merge data from other matching ranges
    // Priority: ASN data from most specific, GeoIP and WHOIS from any available
    for (let i = 1; i < matchingRanges.length; i++) {
        const range = matchingRanges[i];

        // Merge ASN data if not present in more specific range
        if (!mergedResult.asn && range.asn) {
            mergedResult.asn = range.asn;
            mergedResult.asn_name = range.asn_name;
            mergedResult.asn_org = range.asn_org;
            mergedResult.asn_country = range.asn_country;
        }

        // Merge GeoIP data if not present
        if (!mergedResult.geoip && range.geoip) {
            mergedResult.geoip = range.geoip;
        }

        // Merge WHOIS data if not present
        if (!mergedResult.whois && range.whois) {
            mergedResult.whois = range.whois;
        }
    }

    console.log(`Found ${matchingRanges.length} matching ranges, selected most specific: ${mergedResult.prefix}`);

    return mergedResult;
}

// ============================================================================
// Transfer History Functions
// ============================================================================

/**
 * Load transfer data for a specific prefix or ASN
 * For demo purposes, this loads from a static file.
 * In production, this would load from hierarchical transfer files.
 *
 * @param {string} query - IP address, CIDR, or ASN
 * @param {string} type - Type of query ('ipv4', 'ipv6', 'asn')
 * @returns {Promise<Array>} - Array of transfer records
 */
async function loadTransferHistory(query, type) {
    try {
        // For now, load from a centralized transfers file
        // TODO: Implement hierarchical loading like the main lookup
        const transferPath = '/data/transfers/latest.json';

        const response = await fetch(transferPath);
        if (!response.ok) {
            console.log('Transfer data not available');
            return [];
        }

        const data = await response.json();
        return data.transfers || [];
    } catch (error) {
        console.log('Could not load transfer data:', error.message);
        return [];
    }
}

/**
 * Check if an IP address falls within a range
 * @param {string} ip - IP address
 * @param {string} startAddr - Start of range
 * @param {string} endAddr - End of range
 * @param {boolean} isIPv6 - Whether this is IPv6
 * @returns {boolean} - True if IP is in range
 */
function ipInRange(ip, startAddr, endAddr, isIPv6 = false) {
    try {
        if (isIPv6) {
            const ipNum = ipv6ToBigInt(ip);
            const startNum = ipv6ToBigInt(startAddr);
            const endNum = ipv6ToBigInt(endAddr);
            return ipNum >= startNum && ipNum <= endNum;
        } else {
            const ipNum = ipv4ToInt(ip);
            const startNum = ipv4ToInt(startAddr);
            const endNum = ipv4ToInt(endAddr);
            return ipNum >= startNum && ipNum <= endNum;
        }
    } catch {
        return false;
    }
}

/**
 * Match transfers to a query (IP or ASN)
 * @param {Array} transfers - Array of all transfer records
 * @param {string} query - Query string (IP or ASN)
 * @param {string} type - Query type ('ipv4', 'ipv6', 'asn')
 * @returns {Array} - Matched transfer records, sorted oldest to newest
 */
function matchTransfers(transfers, query, type) {
    if (!transfers || transfers.length === 0) {
        return [];
    }

    const matched = [];

    // Extract ASN number if query is an ASN
    const asnNumber = type === 'asn' ? parseInt(query.replace(/^AS/i, '')) : null;

    for (const transfer of transfers) {
        let isMatch = false;

        // Check ASN transfers
        if (asnNumber && transfer.asns) {
            const original = transfer.asns.original_set || [];
            const transferSet = transfer.asns.transfer_set || [];

            for (const range of [...original, ...transferSet]) {
                if (asnNumber >= range.start && asnNumber <= range.end) {
                    isMatch = true;
                    break;
                }
            }
        }

        // Check IPv4 transfers
        if (type === 'ipv4' && transfer.ip4nets) {
            const original = transfer.ip4nets.original_set || [];
            const transferSet = transfer.ip4nets.transfer_set || [];

            for (const range of [...original, ...transferSet]) {
                if (ipInRange(query, range.start_address, range.end_address, false)) {
                    isMatch = true;
                    break;
                }
            }
        }

        // Check IPv6 transfers
        if (type === 'ipv6' && transfer.ip6nets) {
            const original = transfer.ip6nets.original_set || [];
            const transferSet = transfer.ip6nets.transfer_set || [];

            for (const range of [...original, ...transferSet]) {
                if (ipInRange(query, range.start_address, range.end_address, true)) {
                    isMatch = true;
                    break;
                }
            }
        }

        if (isMatch) {
            matched.push(transfer);
        }
    }

    // Sort by transfer_date (oldest to newest)
    matched.sort((a, b) => {
        const dateA = new Date(a.transfer_date);
        const dateB = new Date(b.transfer_date);
        return dateA - dateB;
    });

    return matched;
}

/**
 * Format transfer date for display
 * @param {string} isoDate - ISO 8601 date string
 * @returns {string} - Formatted date
 */
function formatTransferDate(isoDate) {
    const date = new Date(isoDate);
    return date.toLocaleDateString('en-US', {
        year: 'numeric',
        month: 'long',
        day: 'numeric'
    });
}

/**
 * Format resource ranges for display
 * @param {Object} transfer - Transfer record
 * @returns {string} - HTML string of resource items
 */
function formatTransferResources(transfer) {
    let html = '';

    // Format ASN ranges
    if (transfer.asns) {
        const sets = transfer.asns.transfer_set || transfer.asns.original_set || [];
        for (const range of sets) {
            if (range.start === range.end) {
                html += `<span class="transfer-resource-item">AS${range.start}</span>`;
            } else {
                html += `<span class="transfer-resource-item">AS${range.start} - AS${range.end}</span>`;
            }
        }
    }

    // Format IPv4 ranges
    if (transfer.ip4nets) {
        const sets = transfer.ip4nets.transfer_set || transfer.ip4nets.original_set || [];
        for (const range of sets) {
            html += `<span class="transfer-resource-item">${range.start_address} - ${range.end_address}</span>`;
        }
    }

    // Format IPv6 ranges
    if (transfer.ip6nets) {
        const sets = transfer.ip6nets.transfer_set || transfer.ip6nets.original_set || [];
        for (const range of sets) {
            html += `<span class="transfer-resource-item">${range.start_address} - ${range.end_address}</span>`;
        }
    }

    return html || '<span class="transfer-resource-item">Unknown</span>';
}

/**
 * Display transfer history
 * @param {Array} transfers - Array of matched transfer records
 */
function displayTransferHistory(transfers) {
    const transferContent = document.getElementById('transferContent');
    const transferSection = document.getElementById('transferSection');

    if (!transfers || transfers.length === 0) {
        transferContent.innerHTML = '<div class="no-data">No transfer history found for this resource</div>';
        transferSection.style.display = 'block';
        return;
    }

    let html = `<div class="transfer-timeline">`;
    html += `<div style="margin-bottom: 15px; color: #666;">
        <strong>Found ${transfers.length} transfer record${transfers.length > 1 ? 's' : ''}</strong>
        <span class="transfer-count-badge">${transfers.length}</span>
    </div>`;

    for (const transfer of transfers) {
        html += `<div class="transfer-record">`;

        // Date and type
        html += `<div class="transfer-date">
            ${formatTransferDate(transfer.transfer_date)}
            <span class="transfer-type">${transfer.type || 'RESOURCE_TRANSFER'}</span>
        </div>`;

        // Transfer parties (source → recipient)
        html += `<div class="transfer-parties">
            <div class="transfer-party">
                <div class="transfer-party-label">From</div>
                <div class="transfer-party-name">${escapeHtml(transfer.source_organization?.name || 'Unknown')}</div>
                <div class="transfer-party-country">${transfer.source_organization?.country_code || ''}</div>
            </div>
            <div class="transfer-arrow">→</div>
            <div class="transfer-party">
                <div class="transfer-party-label">To</div>
                <div class="transfer-party-name">${escapeHtml(transfer.recipient_organization?.name || 'Unknown')}</div>
                <div class="transfer-party-country">${transfer.recipient_organization?.country_code || ''}</div>
            </div>
        </div>`;

        // Resources transferred
        html += `<div class="transfer-resources">
            <div class="transfer-resources-label">Transferred Resources</div>
            ${formatTransferResources(transfer)}
        </div>`;

        // RIR information
        if (transfer.source_rir || transfer.recipient_rir) {
            html += `<div class="transfer-rir-info">`;
            if (transfer.source_rir) {
                html += `<span><strong>Source RIR:</strong> ${transfer.source_rir}</span>`;
            }
            if (transfer.recipient_rir) {
                html += `<span><strong>Recipient RIR:</strong> ${transfer.recipient_rir}</span>`;
            }
            if (transfer.source_registration_date) {
                html += `<span><strong>Original Registration:</strong> ${formatTransferDate(transfer.source_registration_date)}</span>`;
            }
            html += `</div>`;
        }

        html += `</div>`; // transfer-record
    }

    html += `</div>`; // transfer-timeline

    transferContent.innerHTML = html;
    transferSection.style.display = 'block';
}

// ============================================================================
// IP Reputation Functions
// ============================================================================

/**
 * Format and display IP reputation information
 * @param {Object} reputationData - Reputation data from JSON
 * @param {string} queryIP - The IP address being looked up
 */
function displayIPReputation(reputationData, queryIP) {
    const reputationContent = document.getElementById('reputationContent');
    const reputationSection = document.getElementById('reputationSection');

    if (!reputationData || !reputationData.listed) {
        // IP is clean - show positive message
        const html = `
            <div class="reputation-alert clean">
                <div class="reputation-icon">✓</div>
                <div class="reputation-content">
                    <div class="reputation-title">Clean IP Address</div>
                    <div class="reputation-details">
                        This IP address is not listed on any major threat intelligence blocklists.
                        No malicious activity has been detected.
                    </div>
                </div>
            </div>
        `;
        reputationContent.innerHTML = html;
        reputationSection.style.display = 'block';
        return;
    }

    // IP is listed - determine severity and display warning
    const level = reputationData.firehol_level;
    const hasIpsum = reputationData.ipsum_score !== undefined;

    let alertClass = 'warning';
    let icon = '⚠️';
    let title = 'IP Security Alert';

    // FireHOL Level 1 is critical (highest confidence threats)
    if (level === 1) {
        alertClass = 'critical';
        icon = '🚨';
        title = 'Critical Security Alert';
    }

    let badges = '';
    let description = '';

    // Add FireHOL badges and descriptions
    if (level) {
        badges += `<span class="reputation-badge firehol-${level}">FireHOL Level ${level}</span>`;

        if (level === 1) {
            description = `
                <div class="reputation-description">
                    <strong>FireHOL Level 1 (Critical):</strong> Maximum protection blocklist with minimum false positives.
                    This IP is associated with confirmed attacks, malware distribution, botnets, or other severe threats.
                    <strong>Action Recommended:</strong> Block immediately.
                </div>
            `;
        } else if (level === 2) {
            description = `
                <div class="reputation-description">
                    <strong>FireHOL Level 2 (High Risk):</strong> Extended blocklist with broader threat coverage.
                    This IP may be associated with suspicious activity, scanning, or known threat sources.
                    <strong>Action Recommended:</strong> Monitor or block based on your security policy.
                </div>
            `;
        } else if (level === 3) {
            description = `
                <div class="reputation-description">
                    <strong>FireHOL Level 3 (Medium Risk):</strong> Comprehensive blocklist with widest coverage.
                    This IP is on extended threat lists and may have been flagged for various security concerns.
                    <strong>Action Recommended:</strong> Exercise caution and monitor activity.
                </div>
            `;
        }
    }

    // Add IPsum badge if present
    if (hasIpsum) {
        const ipsumScore = reputationData.ipsum_score;
        badges += `<span class="reputation-badge ipsum">IPsum Score: ${ipsumScore}</span>`;

        description += `
            <div class="reputation-description">
                <strong>IPsum Threat Score:</strong> ${ipsumScore}/10 - This IP appears on ${ipsumScore} or more public blocklists.
                Higher scores indicate more widespread recognition as a threat source.
            </div>
        `;
    }

    const html = `
        <div class="reputation-alert ${alertClass}">
            <div class="reputation-icon">${icon}</div>
            <div class="reputation-content">
                <div class="reputation-title">${title}</div>
                <div class="reputation-details">
                    This IP address (<strong>${escapeHtml(queryIP)}</strong>) is listed on threat intelligence blocklists:
                    <div style="margin-top: 10px;">${badges}</div>
                    ${description}
                </div>
            </div>
        </div>
        <div style="margin-top: 15px; padding: 12px; background: #f5f5f5; border-radius: 4px; font-size: 13px;">
            <strong>Data Sources:</strong>
            <a href="https://github.com/firehol/blocklist-ipsets" target="_blank" rel="noopener">FireHOL IP Blocklists</a> •
            <a href="https://github.com/stamparm/ipsum" target="_blank" rel="noopener">IPsum Threat Intelligence</a><br>
            <strong>Note:</strong> Reputation data is updated regularly but may not reflect the most current status.
            Always verify before taking action.
        </div>
    `;

    reputationContent.innerHTML = html;
    reputationSection.style.display = 'block';
}

// ============================================================================
// Main Lookup Logic
// ============================================================================

/**
 * Perform hierarchical lookup
 * @param {string} input - User input
 * @returns {Promise<Object>} - Lookup results
 */
async function performLookup(input) {
    const validation = validateInput(input);

    if (!validation.valid) {
        throw new Error(validation.error);
    }

    const { type, value } = validation;

    const result = {
        input,
        validation,
        type,          // Add type for transfer matching
        query: value,  // Add normalized query value for transfer matching
        asn: null,
        asnData: null,
        geoip: null,
        whois: null,
        reputation: null  // Add reputation data
    };

    try {
        if (type === 'asn') {
            // Direct ASN lookup
            const path = getASNPath(value);
            const data = await fetchHierarchicalData(path);

            if (data?.asns) {
                // ASN data is keyed by ASN number as string
                const asnData = data.asns[String(value)];
                if (asnData) {
                    result.asnData = asnData;
                    result.asn = value;
                }
            }

        } else if (type === 'ipv4') {
            // IPv4 lookup (also handles CIDR notation)
            const path = getIPv4Path(value);
            const data = await fetchHierarchicalData(path);

            if (data?.ranges) {
                const ipInt = ipv4ToInt(value);
                const matchedRange = findMatchingRange(ipInt, data.ranges);

                if (matchedRange) {
                    result.asn = matchedRange.asn || null;
                    result.asnData = {
                        asn: matchedRange.asn,
                        name: matchedRange.asn_name,
                        org: matchedRange.asn_org,
                        country: matchedRange.asn_country,
                        prefix: matchedRange.prefix
                    };
                    result.geoip = matchedRange.geoip || null;
                    result.whois = matchedRange.whois || null;
                    result.reputation = matchedRange.reputation || null;
                }
            }
        } else if (type === 'ipv6') {
            // IPv6 lookup (also handles CIDR notation)
            const path = getIPv6Path(value);
            console.log(`IPv6 lookup: Fetching data from ${path}`);

            const data = await fetchHierarchicalData(path);

            if (data?.ranges) {
                const normalized = normalizeIPv6(value);
                const ipInt = ipv6ToBigInt(value);
                console.log(`IPv6 normalized: ${normalized}`);
                console.log(`IPv6 as BigInt: ${ipInt}`);
                console.log(`Searching ${data.ranges.length} ranges...`);

                const matchedRange = findMatchingRange(ipInt, data.ranges);

                if (matchedRange) {
                    console.log(`Match found: ${matchedRange.prefix}`);
                    result.asn = matchedRange.asn || null;
                    result.asnData = {
                        asn: matchedRange.asn,
                        name: matchedRange.asn_name,
                        org: matchedRange.asn_org,
                        country: matchedRange.asn_country,
                        prefix: matchedRange.prefix
                    };
                    result.geoip = matchedRange.geoip || null;
                    result.whois = matchedRange.whois || null;
                    result.reputation = matchedRange.reputation || null;
                } else {
                    console.log('No matching range found');
                }
            } else {
                console.log(`No data found at ${path}`);
            }
        }

    } catch (error) {
        console.error('Lookup error:', error);
        throw new Error(`Lookup failed: ${error.message}`);
    }

    return result;
}

// ============================================================================
// Result Formatting
// ============================================================================

/**
 * Format ASN result for display
 * @param {Object} asnData - ASN data object
 * @returns {string} - HTML string
 */
function formatASNResult(asnData) {
    if (!asnData) {
        return '<div class="no-data">No ASN information found</div>';
    }

    let html = '';

    if (asnData.asn) {
        html += `<div class="data-row">
            <div class="data-label">ASN:</div>
            <div class="data-value highlight">AS${asnData.asn}</div>
        </div>`;
    }

    if (asnData.prefix) {
        html += `<div class="data-row">
            <div class="data-label">IP Prefix:</div>
            <div class="data-value">${escapeHtml(asnData.prefix)}</div>
        </div>`;
    }

    if (asnData.name) {
        html += `<div class="data-row">
            <div class="data-label">Name:</div>
            <div class="data-value">${escapeHtml(asnData.name)}</div>
        </div>`;
    }

    if (asnData.org) {
        html += `<div class="data-row">
            <div class="data-label">Organization:</div>
            <div class="data-value">${escapeHtml(asnData.org)}</div>
        </div>`;
    }

    if (asnData.country) {
        html += `<div class="data-row">
            <div class="data-label">Country:</div>
            <div class="data-value">${escapeHtml(asnData.country)}</div>
        </div>`;
    }

    if (asnData.type) {
        html += `<div class="data-row">
            <div class="data-label">Type:</div>
            <div class="data-value">${escapeHtml(asnData.type)}</div>
        </div>`;
    }

    return html;
}

/**
 * Format WHOIS result for display
 * @param {Object} whoisData - WHOIS data object
 * @returns {string} - HTML string
 */
function formatWHOISResult(whoisData) {
    if (!whoisData) {
        return '<div class="no-data">No WHOIS information found</div>';
    }

    let html = '';

    if (whoisData.netname) {
        html += `<div class="data-row">
            <div class="data-label">Network Name:</div>
            <div class="data-value">${escapeHtml(whoisData.netname)}</div>
        </div>`;
    }

    if (whoisData.descr) {
        html += `<div class="data-row">
            <div class="data-label">Description:</div>
            <div class="data-value">${escapeHtml(whoisData.descr)}</div>
        </div>`;
    }

    if (whoisData.org) {
        html += `<div class="data-row">
            <div class="data-label">Organization ID:</div>
            <div class="data-value">${escapeHtml(whoisData.org)}</div>
        </div>`;
    }

    if (whoisData.org_name) {
        html += `<div class="data-row">
            <div class="data-label">Organization Name:</div>
            <div class="data-value">${escapeHtml(whoisData.org_name)}</div>
        </div>`;
    }

    if (whoisData.address) {
        html += `<div class="data-row">
            <div class="data-label">Address:</div>
            <div class="data-value">${escapeHtml(whoisData.address)}</div>
        </div>`;
    }

    if (whoisData.country) {
        html += `<div class="data-row">
            <div class="data-label">Country:</div>
            <div class="data-value">${escapeHtml(whoisData.country)}</div>
        </div>`;
    }

    if (whoisData.status) {
        html += `<div class="data-row">
            <div class="data-label">Status:</div>
            <div class="data-value">${escapeHtml(whoisData.status)}</div>
        </div>`;
    }

    if (whoisData.rir) {
        html += `<div class="data-row">
            <div class="data-label">RIR (Registry):</div>
            <div class="data-value">${escapeHtml(whoisData.rir).toUpperCase()}</div>
        </div>`;
    }

    if (whoisData.created) {
        html += `<div class="data-row">
            <div class="data-label">Registration Date:</div>
            <div class="data-value">${escapeHtml(whoisData.created)}</div>
        </div>`;
    }

    if (whoisData.updated) {
        html += `<div class="data-row">
            <div class="data-label">Last Updated:</div>
            <div class="data-value">${escapeHtml(whoisData.updated)}</div>
        </div>`;
    }

    if (whoisData.admin) {
        html += `<div class="data-row">
            <div class="data-label">Admin Contact:</div>
            <div class="data-value">${escapeHtml(whoisData.admin)}</div>
        </div>`;
    }

    if (whoisData.tech) {
        html += `<div class="data-row">
            <div class="data-label">Tech Contact:</div>
            <div class="data-value">${escapeHtml(whoisData.tech)}</div>
        </div>`;
    }

    if (whoisData.remarks) {
        html += `<div class="data-row">
            <div class="data-label">Remarks:</div>
            <div class="data-value">${escapeHtml(whoisData.remarks)}</div>
        </div>`;
    }

    return html;
}

/**
 * Format GeoIP result for display
 * @param {Object} geoipData - GeoIP data object
 * @returns {string} - HTML string
 */
function formatGeoIPResult(geoipData) {
    if (!geoipData) {
        return '<div class="no-data">No geographic information found</div>';
    }

    let html = '';

    // Helper function to check if a value is valid (not null, undefined, or empty string)
    const isValidValue = (val) => val !== null && val !== undefined && val !== '';

    // Country (prefer full name, fallback to ISO code)
    if (isValidValue(geoipData.country_name) || isValidValue(geoipData.country)) {
        const countryDisplay = geoipData.country_name || geoipData.country;
        const countryCode = isValidValue(geoipData.country) ? ` (${geoipData.country})` : '';
        html += `<div class="data-row">
            <div class="data-label">Country:</div>
            <div class="data-value highlight">${escapeHtml(countryDisplay)}${geoipData.country_name ? countryCode : ''}</div>
        </div>`;
    }

    // Region/State (prefer full name, fallback to code)
    if (isValidValue(geoipData.region_name) || isValidValue(geoipData.region)) {
        const regionDisplay = geoipData.region_name || geoipData.region;
        html += `<div class="data-row">
            <div class="data-label">State/Region:</div>
            <div class="data-value">${escapeHtml(regionDisplay)}</div>
        </div>`;
    }

    // Subdivision 2 (County/District)
    if (isValidValue(geoipData.subdivision_2_name) || isValidValue(geoipData.subdivision_2)) {
        const subDiv2Display = geoipData.subdivision_2_name || geoipData.subdivision_2;
        html += `<div class="data-row">
            <div class="data-label">County/District:</div>
            <div class="data-value">${escapeHtml(subDiv2Display)}</div>
        </div>`;
    }

    // City
    if (isValidValue(geoipData.city)) {
        html += `<div class="data-row">
            <div class="data-label">City:</div>
            <div class="data-value">${escapeHtml(geoipData.city)}</div>
        </div>`;
    }

    // Metro Code (US only)
    if (isValidValue(geoipData.metro_code)) {
        html += `<div class="data-row">
            <div class="data-label">Metro Code:</div>
            <div class="data-value">${escapeHtml(geoipData.metro_code)}</div>
        </div>`;
    }

    // Time Zone
    if (isValidValue(geoipData.time_zone)) {
        html += `<div class="data-row">
            <div class="data-label">Time Zone:</div>
            <div class="data-value">${escapeHtml(geoipData.time_zone)}</div>
        </div>`;
    }

    // Coordinates - validate that lat/lon are actual numbers, not empty strings
    const lat = geoipData.lat;
    const lon = geoipData.lon;
    const hasValidCoords = lat !== null && lat !== undefined && lat !== '' &&
                          lon !== null && lon !== undefined && lon !== '' &&
                          typeof lat === 'number' && typeof lon === 'number' &&
                          !isNaN(lat) && !isNaN(lon);

    if (hasValidCoords) {
        html += `<div class="data-row">
            <div class="data-label">Coordinates:</div>
            <div class="data-value">${lat.toFixed(4)}, ${lon.toFixed(4)}</div>
        </div>`;

        const mapUrl = `https://www.openstreetmap.org/?mlat=${lat}&mlon=${lon}&zoom=12`;
        html += `<div class="data-row">
            <div class="data-label">Map:</div>
            <div class="data-value"><a href="${mapUrl}" target="_blank" rel="noopener">View on OpenStreetMap</a></div>
        </div>`;
    }

    return html;
}

/**
 * Escape HTML to prevent XSS attacks
 * @param {any} text - Text to escape
 * @returns {string} - Escaped HTML
 */
function escapeHtml(text) {
    if (text === null || text === undefined) return '';
    const div = document.createElement('div');
    div.textContent = String(text);
    return div.innerHTML;
}

// ============================================================================
// UI Functions
// ============================================================================

/**
 * Main search function triggered by UI
 */
async function searchIP() {
    const input = document.getElementById('ipInput').value.trim();
    const searchBtn = document.getElementById('searchBtn');

    if (!input) {
        showError('Please enter an IP address, CIDR block, or ASN');
        return;
    }

    // Disable search button
    searchBtn.disabled = true;
    searchBtn.textContent = 'Searching...';

    // Hide previous results and errors
    document.getElementById('results').style.display = 'none';
    const errorDiv = document.getElementById('errorMessage');
    errorDiv.style.display = 'none';

    try {
        // Perform lookup with timing
        const startTime = performance.now();
        const result = await performLookup(input);
        const endTime = performance.now();

        console.log(`Lookup completed in ${(endTime - startTime).toFixed(2)}ms`);

        // Check if we found any data
        if (!result.asnData && !result.geoip && !result.whois) {
            showWarning('No information found for this IP address or ASN. The address may be reserved, private, or not yet allocated.');
        } else {
            // Display results
            displayResults(result);
        }

    } catch (error) {
        showError(error.message);
    } finally {
        // Re-enable search button
        searchBtn.disabled = false;
        searchBtn.textContent = 'Search';
    }
}

/**
 * Display lookup results
 * @param {Object} result - Lookup result object
 */
async function displayResults(result) {
    // Show ASN section
    const asnContent = document.getElementById('asnContent');
    asnContent.innerHTML = formatASNResult(result.asnData);
    document.getElementById('asnSection').style.display = 'block';

    // Show WHOIS section
    const whoisContent = document.getElementById('whoisContent');
    whoisContent.innerHTML = formatWHOISResult(result.whois);
    document.getElementById('whoisSection').style.display = 'block';

    // Show GeoIP section
    const geoipContent = document.getElementById('geoipContent');
    geoipContent.innerHTML = formatGeoIPResult(result.geoip);
    document.getElementById('geoipSection').style.display = 'block';

    // Show IP Reputation section (only for IP lookups, not ASN)
    if (result.type === 'ipv4' || result.type === 'ipv6') {
        displayIPReputation(result.reputation, result.query);
    }

    // Load and show transfer history
    try {
        console.log('Loading transfer history...');
        const transfers = await loadTransferHistory(result.query, result.type);
        const matched = matchTransfers(transfers, result.query, result.type);
        console.log(`Found ${matched.length} matching transfers`);
        displayTransferHistory(matched);
    } catch (error) {
        console.error('Error loading transfer history:', error);
        // Show section even if there's an error
        document.getElementById('transferSection').style.display = 'block';
    }

    // Show results container
    document.getElementById('results').style.display = 'block';

    // Scroll to results
    document.getElementById('results').scrollIntoView({ behavior: 'smooth', block: 'start' });
}

/**
 * Show error message
 * @param {string} message - Error message
 */
function showError(message) {
    const errorDiv = document.getElementById('errorMessage');
    errorDiv.textContent = message;
    errorDiv.className = 'error';
    errorDiv.style.display = 'block';

    // Hide results
    document.getElementById('results').style.display = 'none';
}

/**
 * Show warning message
 * @param {string} message - Warning message
 */
function showWarning(message) {
    const errorDiv = document.getElementById('errorMessage');
    errorDiv.textContent = message;
    errorDiv.className = 'warning';
    errorDiv.style.display = 'block';

    // Hide results
    document.getElementById('results').style.display = 'none';
}

/**
 * Toggle section visibility
 * @param {string} sectionId - Section ID (without 'Content' suffix)
 */
function toggleSection(sectionId) {
    const content = document.getElementById(sectionId + 'Content');
    const header = content.previousElementSibling;

    if (content.classList.contains('collapsed')) {
        content.classList.remove('collapsed');
        header.classList.remove('collapsed');
    } else {
        content.classList.add('collapsed');
        header.classList.add('collapsed');
    }
}

/**
 * Handle example link clicks
 * @param {string} value - Example value to search
 */
function searchExample(value) {
    document.getElementById('ipInput').value = value;
    searchIP();
}

// ============================================================================
// Initialization
// ============================================================================

document.addEventListener('DOMContentLoaded', function() {
    console.log('BGP/IP WHOIS Lookup Tool v2.3.0 - IP Reputation & Transfer History');
    console.log(`Cache enabled: ${CONFIG.cacheEnabled}`);
    console.log('Features: IP Reputation (FireHOL/IPsum), Transfer History, IPv6 support, Hierarchical data loading');

    // Add enter key support
    document.getElementById('ipInput').addEventListener('keypress', function(e) {
        if (e.key === 'Enter') {
            searchIP();
        }
    });

    // Auto-focus input field
    document.getElementById('ipInput').focus();
});
</script>