BUILDING SCALABLE AND EFFICIENT FULL-STACK APPLICATIONS

function Test-IsWinPE {
    return (Test-Path 'X:\Windows') -and (Get-PSDrive -Name X -ErrorAction SilentlyContinue)
}

function Ensure-DellBIOSProvider {
    param([bool]$IsWinPE)
    if ($IsWinPE) {
        Write-Log "WinPE detected." "INFO"
        # Auto-copy DellBIOSProvider from USB root to WinPE
        $dest = 'X:\Windows\System32\WindowsPowerShell\v1.0\Modules'
        foreach ($dl in 'C','D','E','F'...) {
            $candidate = "$dl`:\DellBIOSProvider"
            if (Test-Path $candidate) { 
                Copy-Item -Path $candidate -Destination $dest -Recurse -Force
                break
            }
        }
        Import-Module DellBIOSProvider -ErrorAction Stop
    }
}

function Set-OwnershipTag {
    param(
        [Parameter(Mandatory)][string]$Tag,
        [bool]$IsWinPE
    )
    if ($IsWinPE) {
        Set-Item -Path 'DellSmbios:\SystemInformation\OwnershipTag' -Value $Tag
    } else {
        Set-ItemProperty -Path 'DellSmbios:\SystemInformation\OwnershipTag' 
                         -Name 'CurrentValue' -Value $Tag
    }
}

# Automatic validation after setting
$validated = Get-CurrentOwnershipTag
if ($validated -eq $ownershipTag) {
    Write-Log "Ownership Tag successfully set to '$validated'." "SUCCESS"
} else {
    throw "Validation mismatch. Expected '$ownershipTag', got '$validated'."
}

function Get-DellModelNumeric {
    $fields = @(
        (Get-CimInstance Win32_ComputerSystem).Model,
        (Get-CimInstance Win32_BaseBoard).Product,
        (Get-CimInstance Win32_BIOS).SMBIOSBIOSVersion
    ) | Where-Object { $_ }
    
    foreach ($f in $fields) {
        if ($f -match '\b(\d{3,4})\b') { return $Matches[1] }
    }
    throw "Unable to determine Dell model."
}

# Build ownership tag from country code + model suffix
$model = Get-DellModelNumeric
$suffix = $models[$modelKey]
$ownershipTag = "$countryCode$suffix"

async function fetchProductInfo(serialNumber) {
    const url = 'https://pcsupport.lenovo.com/ca/en/api/v4/upsell/redport/getIbaseInfo';
    const headers = { 'Content-Type': 'application/json' };
    const body = { serialNumber };
    
    try {
        const response = await axios.post(url, body, { headers });
        const data = response.data;
        const machineInfo = data?.data?.machineInfo;
        
        if (!machineInfo) {
            return { error: 'No machine information found for this serial number.' };
        }
        
        const model = machineInfo.productName?.split('(')[0].trim() || 'Unknown';
        const warrantyDetails = data.data.currentWarranty;
        const warrantyEndDate = warrantyDetails?.endDate || null;
        
        return {
            serialNumber,
            model,
            warrantyEndDate: warrantyEndDate || 'No warranty info available',
            underWarranty: isUnderWarranty(warrantyEndDate),
        };
    } catch (error) {
        console.error('Error fetching product info:', error.message);
        return { error: 'Failed to fetch product info.' };
    }
}

function isUnderWarranty(warrantyEndDate) {
    if (!warrantyEndDate) {
        return false;
    }
    const currentDate = new Date();
    const endDate = new Date(warrantyEndDate);
    return currentDate <= endDate;
}

// API endpoint with validation
app.post('/api/product-info', async (req, res) => {
    const { serialNumber } = req.body;
    if (!serialNumber) {
        return res.status(400).json({ error: 'Serial number is required.' });
    }
    const productInfo = await fetchProductInfo(serialNumber);
    if (productInfo.error) {
        return res.status(500).json(productInfo);
    }
    res.json(productInfo);
});

async function fetchProductInfo(serialNumber) {
    const apiUrl = 'https://product-info-api-production.up.railway.app/api/product-info';
    
    try {
        const response = await fetch(apiUrl, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ serialNumber }),
        });
        
        if (!response.ok) {
            throw new Error(`API call failed with status: ${response.status}`);
        }
        
        const data = await response.json();
        // Display results with proper error handling
    } catch (error) {
        resultDiv.innerHTML = `<p style="color: red;">Error: ${error.message}</p>`;
    }
}

// Excel file processing logic
const excelProcessor = require('./excelProcessor');
const fs = require('fs');
const path = require('path');

async function processExcelFile(filePath) {
    try {
        const workbook = await excelProcessor.readFile(filePath);
        const data = excelProcessor.extractData(workbook);
        return {
            success: true,
            data: data,
            rows: data.length
        };
    } catch (error) {
        console.error('Error processing Excel file:', error);
        return {
            success: false,
            error: error.message
        };
    }
}

// Express route for file upload
app.post('/upload', upload.single('excelFile'), async (req, res) => {
    if (!req.file) {
        return res.status(400).json({ error: 'No file uploaded' });
    }
    
    const filePath = req.file.path;
    const result = await processExcelFile(filePath);
    
    if (result.success) {
        res.json({
            message: 'File processed successfully',
            rows: result.rows,
            data: result.data
        });
    } else {
        res.status(500).json({ error: result.error });
    }
});

// Extract and process Excel data
function extractData(workbook) {
    const worksheet = workbook.Sheets[workbook.SheetNames[0]];
    const data = XLSX.utils.sheet_to_json(worksheet);
    
    return data.map(row => {
        // Process and normalize data
        return {
            ...row,
            processed: true,
            timestamp: new Date().toISOString()
        };
    });
}

:: Ensure script is running as Administrator
net session >nul 2>&1
if %errorLevel% neq 0 (
    echo This script must be run as Administrator.
    pause
    exit /b
)

:: Enable display of non-present devices
set devmgr_show_nonpresent_devices=1
start devmgmt.msc

:: Remove ghost display devices
for /f "tokens=2 delims==" %%a in (
    'wmic path Win32_PnPEntity where "PNPDeviceID like '%%Display%%' and Status='Error'" get PNPDeviceID /value'
) do (
    echo Removing: %%a
    wmic path Win32_PnPEntity where PNPDeviceID='%%a' call Delete
)

echo Ghost device cleanup completed successfully.
pause

$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition
$assetFile = Join-Path $scriptDir "assets.txt"

if (!(Test-Path $assetFile)) {
    Write-Host "Asset list not found: $assetFile" -ForegroundColor Red
    exit
}

$assets = Get-Content $assetFile |
    ForEach-Object { $_.Trim() } |
    Where-Object { $_ -match '^(WIN|WIND)' -and $_ -ne "" }

if ($assets.Count -eq 0) {
    Write-Host "No valid asset tags found." -ForegroundColor Yellow
    exit
}

function Get-IPsFromName {
    param([string]$Name)
    
    $ips = @()
    
    try {
        $ips += Resolve-DnsName -Name $Name -Type A -ErrorAction Stop |
                Select-Object -ExpandProperty IPAddress
    } catch {}
    
    try {
        $ips += [System.Net.Dns]::GetHostAddresses($Name) |
                Where-Object { $_.AddressFamily -eq 'InterNetwork' } |
                ForEach-Object { $_.IPAddressToString }
    } catch {}
    
    return $ips | Select-Object -Unique
}

Write-Host "Pinging $($assets.Count) assets..."