/* jshint esversion: 2024, module: true */

import { Utils } from './utils.js';
import { InterfaceState } from './enums.js';

/**
 * Static Interface Renderer for displaying network interfaces
 * @class InterfaceRenderer
 */
class InterfaceRenderer {
    /**
     * Render interface tabs
     * @static
     * @param {Array} interfaces - Array of interface objects
     * @param {Object} currentInterface - Current interface object
     * @returns {string} HTML string
     */
    static renderInterfaceTabs(interfaces, currentInterface) {
        if (!interfaces.length) {
            return '<div class="no-interfaces">No network interfaces found</div>';
        }

        const tabsHTML = interfaces.map(iface => {
            const state = Utils.getInterfaceState(iface);
            const stateClass = Utils.getStateClass(state);
            const stateText = Utils.getStateText(iface);
            const isActive = iface === currentInterface;

            return `
                <button class="interface-tab ${isActive ? 'active' : ''}"
                        data-interface="${Utils.sanitizeHTML(iface.Name)}">
                    ${Utils.sanitizeHTML(iface.Name)}
                    <span class="interface-state ${stateClass}">${Utils.sanitizeHTML(stateText)}</span>
                </button>
            `;
        }).join('');

        return `<div class="interface-tabs-container">${tabsHTML}</div>`;
    }

    /**
     * Show detailed interface information
     * @static
     * @param {Object} iface - Interface object
     * @returns {string} HTML string
     */
    static showInterfaceDetails(iface) {
        const details = [
            InterfaceRenderer.renderDetailRow('Link File', iface.LinkFile),
            InterfaceRenderer.renderDetailRow('Network File', iface.NetworkFile),
            InterfaceRenderer.renderDetailRow('State', iface.State, Utils.getStateClass(Utils.getInterfaceState(iface))),
            InterfaceRenderer.renderDetailRow('Online State', iface.OnlineState),
            InterfaceRenderer.renderDetailRow('Type', iface.Type),
            InterfaceRenderer.renderDetailRow('Path', iface.Path),
            InterfaceRenderer.renderDetailRow('Driver', iface.Driver),
            InterfaceRenderer.renderDetailRow('Vendor', iface.Vendor),
            InterfaceRenderer.renderDetailRow('Model', iface.Model),
            InterfaceRenderer.renderDetailRow('Hardware Address', Utils.arrayToMac(iface.HardwareAddress)),
            InterfaceRenderer.renderDetailRow('MTU', iface.MTU ? `${iface.MTU} (min: ${iface.MTUMin ?? '?'}, max: ${iface.MTUMax ?? '?'})` : ''),
            InterfaceRenderer.renderDetailRow('QDisc', iface.QDisc),
            InterfaceRenderer.renderDetailRow('IPv6 Address Generation Mode', iface.IPv6AddressGenerationMode),
            InterfaceRenderer.renderDetailRow('Number of Queues (Tx/Rx)', iface.Queues ? `${iface.Queues.Tx ?? '?'}/${iface.Queues.Rx ?? '?'}` : ''),
            InterfaceRenderer.renderDetailRow('Auto negotiation', iface.AutoNegotiation ? 'yes' : 'no'),
            InterfaceRenderer.renderDetailRow('Speed', iface.Speed),
            InterfaceRenderer.renderDetailRow('Duplex', iface.Duplex),
            InterfaceRenderer.renderDetailRow('Port', iface.Port),
            InterfaceRenderer.renderDetailRow('Address', InterfaceRenderer.renderAddressList(iface.Addresses)),
            InterfaceRenderer.renderDetailRow('DNS', InterfaceRenderer.renderDNSServerList(iface.DNS)),
            InterfaceRenderer.renderDetailRow('NTP', iface.NTP),
            InterfaceRenderer.renderDetailRow('Activation Policy', iface.ActivationPolicy),
            InterfaceRenderer.renderDetailRow('Required For Online', iface.RequiredForOnline ? 'yes' : 'no'),
            InterfaceRenderer.renderDetailRow('Connected To', iface.ConnectedTo),
            InterfaceRenderer.renderDetailRow('Offered DHCP leases', InterfaceRenderer.renderDHCPLeases(iface.DHCPLeases))
        ].filter(Boolean).join('');

        return `<div class="interface-detail-grid">${details}</div>`;
    }

    /**
     * Render a detail row with abbreviations
     * @static
     * @param {string} label - Row label
     * @param {string} value - Row value
     * @param {string} [valueClass] - CSS class for value
     * @returns {string} HTML string
     */
    static renderDetailRow(label, value, valueClass = '') {
        if (!value) return '';

        const abbreviations = {
            'MTU': 'Maximum Transmission Unit',
            'QDisc': 'Queueing Discipline',
            'Tx': 'Transmit',
            'Rx': 'Receive',
            'DNS': 'Domain Name System',
            'NTP': 'Network Time Protocol',
            'DHCP': 'Dynamic Host Configuration Protocol',
            'MAC': 'Media Access Control',
            'IP': 'Internet Protocol',
            'IPv6': 'Internet Protocol version 6'
        };

        const abbrLabel = Object.keys(abbreviations).includes(label)
            ? `<abbr title="${abbreviations[label]}">${label}</abbr>`
            : label;

        return `
            <div class="detail-row">
                <span class="detail-label">${abbrLabel}:</span>
                <span class="detail-value ${valueClass}">${Utils.sanitizeHTML(value)}</span>
            </div>
        `;
    }

    /**
     * Render address list
     * @static
     * @param {Array} addresses - Array of addresses
     * @returns {string} Formatted addresses
     */
    static renderAddressList(addresses) {
        if (!addresses?.length) return '';

        return addresses.map(addr => {
            const ip = Utils.ipFromArray(addr);
            return ip ? `<div class="address-item">${Utils.sanitizeHTML(ip)}</div>` : '';
        }).join('');
    }

    /**
     * Render DNS server list
     * @static
     * @param {Array} dnsServers - Array of DNS servers
     * @returns {string} Formatted DNS servers
     */
    static renderDNSServerList(dnsServers) {
        if (!dnsServers?.length) return '';

        return dnsServers.map(dns => {
            const server = Utils.ipFromArray(dns.Address ?? dns);
            return server ? `<div class="dns-item">${Utils.sanitizeHTML(server)}</div>` : '';
        }).join('');
    }

    /**
     * Render DHCP leases
     * @static
     * @param {Array} leases - Array of DHCP leases
     * @returns {string} Formatted leases
     */
    static renderDHCPLeases(leases) {
        if (!leases?.length) return '';

        return leases.map(lease => {
            const ip = lease.IP ?? lease;
            const to = lease.To ?? lease.MAC ?? '';
            return `<div class="lease-item">${Utils.sanitizeHTML(ip)} (to ${Utils.sanitizeHTML(to)})</div>`;
        }).join('');
    }
}

export { InterfaceRenderer };