lonc/src/api/stock.js

import { apiRequest, getPath } from './client.js';

function unwrapEntryPayload(payload) {
  return payload?.data || payload?.entry || payload?.item || payload;
}

export async function searchItemDefinitions(store, query) {
  if (query.trim().length <= 2) {
    return [];
  }

  const payload = await apiRequest(store, `${getPath('items')}/grouped`, {
    query: { search_name: query, expanded: 0 },
  });

  if (Array.isArray(payload)) {
    return payload;
  }

  return payload?.data || payload?.items || [];
}

export async function listStockEntries(store, filters = {}) {
  const payload = await apiRequest(store, getPath('items'));

  if (Array.isArray(payload)) {
    return payload;
  }

  return payload?.data || payload?.entries || payload?.items || [];
}

export async function listGroupedStockEntries(store) {
  const payload = await apiRequest(store, `${getPath('items')}/grouped`, {
    query: { expanded: 1 },
  });

  if (Array.isArray(payload)) {
    return payload;
  }

  return payload?.data || payload?.entries || payload?.items || payload?.groups || [];
}

export async function getStockEntry(store, stockId) {
  const payload = await apiRequest(store, `${getPath('items')}/${stockId}`);
  return unwrapEntryPayload(payload);
}

export async function createStockEntry(store, body) {
  const payload = await apiRequest(store, getPath('items'), {
    method: 'POST',
    body,
    query: { label: 1, print: 1 },
  });
  return unwrapEntryPayload(payload);
}

function normalizeUpsertResponse(payload) {
  return {
    status: payload?.status || null,
    mode: payload?.mode || null,
    operation: payload?.operation || null,
    matchType: payload?.match_type || null,
    matchedItem: payload?.matched_item || null,
    item: payload?.item || null,
    payload: payload?.payload || null,
  };
}

function normalizeIdentifierLookupResponse(payload) {
  return {
    status: payload?.status || null,
    source: payload?.source || null,
    cacheHit: Boolean(payload?.cache_hit),
    identifierCode: payload?.identifier_code || null,
    identifierType: payload?.identifier_type || null,
    item: payload?.item || null,
    payloadFetchedAt: payload?.payload_fetched_at || null,
    retryAfterSeconds:
      Number.isInteger(payload?.retry_after_seconds) ? payload.retry_after_seconds : null,
    staleCache: Boolean(payload?.stale_cache),
  };
}

function normalizeItemLookupResponse(payload) {
  return {
    status: payload?.status || null,
    found: Boolean(payload?.found),
    update: Boolean(payload?.update),
    identifierCode: payload?.identifier_code || null,
    identifierType: payload?.identifier_type || null,
    preview: payload?.preview || null,
    updatedFields: Array.isArray(payload?.updated_fields) ? payload.updated_fields : [],
    offPayloadFetchedAt: payload?.off_payload_fetched_at || null,
    retryAfterSeconds:
      Number.isInteger(payload?.retry_after_seconds) ? payload.retry_after_seconds : null,
    staleCache: Boolean(payload?.stale_cache),
    item: payload?.item || null,
  };
}

export async function previewItemUpsert(store, body) {
  const payload = await apiRequest(store, `${getPath('items')}/upsert`, {
    method: 'POST',
    body,
    query: { mode: 'preview' },
  });

  return normalizeUpsertResponse(payload);
}

export async function applyItemUpsert(store, body) {
  const payload = await apiRequest(store, `${getPath('items')}/upsert`, {
    method: 'POST',
    body,
    query: { mode: 'apply' },
  });

  return normalizeUpsertResponse(payload);
}

export async function lookupItemByIdentifier(store, identifierCode) {
  const payload = await apiRequest(store, `${getPath('items')}/lookup`, {
    method: 'POST',
    body: {
      identifier_code: String(identifierCode || '').trim(),
    },
  });

  return normalizeIdentifierLookupResponse(payload);
}

export async function lookupItemDetails(store, uuidB64, { update = false } = {}) {
  const payload = await apiRequest(store, `${getPath('items')}/${uuidB64}/lookup`, {
    method: 'POST',
    query: { update: update ? 1 : 0 },
  });

  return normalizeItemLookupResponse(payload);
}

export async function patchStockItem(store, uuidB64, body) {
  const payload = await apiRequest(store, `${getPath('items')}/${uuidB64}`, {
    method: 'PATCH',
    body,
  });
  return unwrapEntryPayload(payload);
}

export async function updateStockItem(store, uuidB64, body) {
  const payload = await apiRequest(store, `${getPath('items')}/${uuidB64}/stock`, {
    method: 'POST',
    body,
  });
  return unwrapEntryPayload(payload);
}

export async function deleteStockItem(store, uuidB64) {
  const payload = await apiRequest(store, `${getPath('items')}/${uuidB64}`, {
    method: 'DELETE',
  });
  return unwrapEntryPayload(payload);
}

export async function useStockItem(store, uuidB64) {
  try {
    await apiRequest(store, `${getPath('items')}/${uuidB64}/use`, {
      method: 'POST',
    });
    return { status: 'used' };
  } catch (error) {
    const status = error?.status || error?.cause?.status;
    if (status === 409) {
      return { status: 'already_gone' };
    }

    if (status === 404 || status === 405) {
      await deleteStockItem(store, uuidB64);
      return { status: 'fallback_delete' };
    }

    throw error;
  }
}

export async function adjustStockEntry(store, stockId, body) {
  const payload = await apiRequest(store, `${getPath('items')}/${stockId}/stock`, {
    method: 'POST',
    body,
  });
  return unwrapEntryPayload(payload);
}

export async function listKitchenChanges(store, { since, limit = 10 } = {}) {
  const payload = await apiRequest(store, getPath('changes'), {
    query: {
      since,
      limit,
    },
  });

  return {
    since: payload?.since || null,
    nextCursor: payload?.next_cursor || null,
    changes: Array.isArray(payload?.changes) ? payload.changes : [],
  };
}