DavidMarquardt

/**
 * Live lookup against Dell's TechDirect Asset Entitlement API
 * (OAuth2 client-credentials, then GET .../asset-entitlements?servicetags=...).
 * Confirmed response shape for a real tag:
 *   [{ serviceTag, invalid, productCode, productId, productFamily,
 *      productLineDescription, productLobDescription, systemDescription,
 *      shipDate, entitlements: [...] }]
 *
 * This API answers "what model/warranty is this tag", not "what CPU/RAM/
 * storage does it have" — Dell doesn't expose full build specs by tag on
 * this endpoint, so callers should still fall back to the offline
 * dell-catalog guesses (by model name) to fill in CPU/RAM/storage.
 *
 * Every call is best-effort: on any failure this returns null (or omits
 * the tag from lookupMany's result map) rather than throwing, so a bulk
 * import never gets blocked by one bad tag or a network hiccup.
 */

let cachedToken = null; // { value, expiresAt }

function apiConfigured() {
  const d = config.dell;
  return Boolean(d.clientId && d.clientSecret && d.tokenUrl);
}

async function getToken() {
  if (cachedToken && cachedToken.expiresAt > Date.now() + 30_000) return cachedToken.value;

  const { clientId, clientSecret, tokenUrl } = config.dell;
  const body = new URLSearchParams({ client_id: clientId, client_secret: clientSecret, grant_type: 'client_credentials' });
  const res = await fetch(tokenUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body,
    signal: AbortSignal.timeout(config.dell.timeoutMs),
  });
  if (!res.ok) throw new Error(`Dell token request failed: ${res.status}`);
  const json = await res.json();
  cachedToken = { value: json.access_token, expiresAt: Date.now() + (json.expires_in || 3600) * 1000 };
  return cachedToken.value;
}

// … categoryFromFamily(): maps Dell's product-family path to a store category

/** One service tag -> {model, description, family, category, shipDate} or null. Never throws. */
async function lookupByServiceTag(tag) {
  if (!apiConfigured() || !tag) return null;
  try {
    const token = await getToken();
    const url = `${config.dell.apiBase}/asset-entitlements?servicetags=${encodeURIComponent(tag)}`;
    const res = await fetch(url, {
      headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
      signal: AbortSignal.timeout(config.dell.timeoutMs),
    });
    if (!res.ok) return null;
    const arr = await res.json();
    const row = Array.isArray(arr) ? arr[0] : null;
    if (!row || row.invalid) return null;
    return {
      model: titleCaseModel(row.productLineDescription || ''),
      description: (row.systemDescription || '').trim(),
      family: row.productFamily || '',
      category: categoryFromFamily(row.productFamily),
      shipDate: row.shipDate || '',
    };
  } catch (e) {
    console.error(`[dell] lookup failed for ${tag}:`, e.message);
    return null;
  }
}

/**
 * Looks up many tags with a small worker pool so a large import doesn't
 * fire hundreds of requests at once or serialize one-at-a-time for minutes.
 * Returns a Map<tag, result|null>; tags Dell doesn't recognize are simply
 * absent-or-null so callers fall back to the offline catalog for them.
 */
async function lookupMany(tags, { concurrency = 2 } = {}) {
  const unique = [...new Set((tags || []).filter(Boolean))];
  const results = new Map();
  if (!apiConfigured() || unique.length === 0) return results;

  let cursor = 0;
  async function worker() {
    while (cursor < unique.length) {
      const tag = unique[cursor++];
      results.set(tag, await lookupByServiceTag(tag));
    }
  }
  await Promise.all(Array.from({ length: Math.min(concurrency, unique.length) }, worker));
  return results;
}

/**
 * Imports rows into the database. `rows` come from parse() (optionally
 * edited by the admin first). Matches existing items by service_tag when
 * present, otherwise always creates a new draft item.
 *
 * When the Dell API is configured (DELL_CLIENT_ID/SECRET), every unique
 * service tag in the batch is looked up first (a handful of parallel
 * requests, not one big serial wait) so the real model/description Dell has
 * on file wins over whatever the spreadsheet's "Product" column said. Blank
 * CPU/RAM/storage — which that API doesn't return — still falls back to the
 * offline catalog guess by model name, same as when the API isn't set up.
 */
async function commit(rows, filename) {
  // … open an import-batch record for this upload …

  const dellResults = dell.apiConfigured()
    ? await dell.lookupMany(rows.map((r) => r.service_tag))
    : new Map();
  let dellMatched = 0;

  let created = 0, updated = 0, skipped = 0;
  for (const r of rows) {
    if (!r.title && !r.model && !r.service_tag) { skipped++; continue; }

    const dellInfo = r.service_tag ? dellResults.get(r.service_tag) : null;
    if (dellInfo) dellMatched++;

    const existing = r.service_tag ? rawDb.get('SELECT * FROM items WHERE service_tag = ? AND service_tag != ?', [r.service_tag, '']) : null;
    const fields = {
      title: r.explicitTitle || (dellInfo && dellInfo.model) || r.title,
      make: r.make || (dellInfo ? 'Dell' : ''),
      model: (dellInfo && dellInfo.model) || r.model,
      cpu: r.cpu,
      ram: r.ram,
      storage: r.storage,
      category: r.category || (dellInfo && dellInfo.category) || '',
      form_factor: r.form_factor,
      service_tag: r.service_tag,
      serial: r.serial,
      description: r.description || (dellInfo && dellInfo.description) || '',
      dell_matched: dellInfo ? 'dell-api' : '',
      price_cents: r.price_cents,
      quantity: r.quantity,
      status: 'draft',
      source: 'import',
      import_batch_id: batchId,
    };

    if (existing) {
      items.update(existing.id, fields, { autofill: true });
      updated++;
    } else {
      items.create(fields, { autofill: true });
      created++;
    }
  }

  // … save per-batch counts, including how many tags Dell matched …
}