Fanatics Markets Mock Interview

function getSortConfig(sortBy = "updatedAt_desc") {
  const map = {
    volume_desc: { field: "volume", dir: -1 },
    volume_asc: { field: "volume", dir: 1 },
    probability_desc: { field: "probability", dir: -1 },
    probability_asc: { field: "probability", dir: 1 },
    updatedAt_desc: { field: "updatedAt", dir: -1 },
    updatedAt_asc: { field: "updatedAt", dir: 1 }
  };
  return map[sortBy] || map.updatedAt_desc;
}

function getVisibleMarkets(markets, { search = "", status = "all", sortBy = "updatedAt_desc" } = {}) {
  const term = search.trim().toLowerCase(); // Normalize search once for consistent matching.
  const normalizedStatus = status.trim().toLowerCase();
  const sort = getSortConfig(sortBy);

  return markets
    .filter(m => normalizedStatus === "all" || m.status.toLowerCase() === normalizedStatus) // Filter from source data; do not mutate source markets.
    .filter(m => m.title.toLowerCase().includes(term))
    .slice()
    .sort((a, b) => {
      const av = sort.field === "updatedAt" ? new Date(a.updatedAt).getTime() : a[sort.field];
      const bv = sort.field === "updatedAt" ? new Date(b.updatedAt).getTime() : b[sort.field];
      if (av === bv) return String(a.id).localeCompare(String(b.id)); // Deterministic tie-break prevents unstable list ordering.
      return (av - bv) * sort.dir;
    });
}

function getMarketListState({ markets, loading, error, filters }) {
  if (loading) return { type: "loading", message: "Loading markets..." };
  if (error) return { type: "error", message: error, canRetry: true };
  const rows = getVisibleMarkets(markets, filters);
  if (!rows.length) return { type: "empty", message: "No matching markets found." };
  return { type: "ready", data: rows };
}

function debounce(fn, wait = 300) { // Debounce limits request volume while user is typing.
  let timerId = null;
  return (...args) => {
    clearTimeout(timerId);
    timerId = setTimeout(() => fn(...args), wait);
  };
}

function createDebouncedMarketSearch({ fetchMarkets, onStateChange, debounceMs = 300 }) {
  let requestCounter = 0;
  let activeController = null;
  let latestQuery = "";

  const state = { query: "", data: [], loading: false, error: null };
  const setState = patch => { Object.assign(state, patch); onStateChange({ ...state }); };

  async function runSearch(query) {
    latestQuery = query;
    const trimmed = query.trim();
    if (!trimmed) {
      if (activeController) activeController.abort(); // Cancel stale in-flight requests to avoid race overwrite.
      setState({ query, data: [], loading: false, error: null });
      return;
    }

    if (activeController) activeController.abort();
    activeController = new AbortController();

    const currentId = ++requestCounter; // Request ordering guard ensures latest intent wins.
    setState({ query, loading: true, error: null });

    try {
      const data = await fetchMarkets(trimmed, { signal: activeController.signal });
      if (currentId !== requestCounter || query !== latestQuery) return;
      setState({ data, loading: false, error: null });
    } catch (err) {
      if (err?.name === "AbortError" || currentId !== requestCounter) return;
      setState({ loading: false, error: err?.message || "Search failed" });
    }
  }

  const debouncedSearch = debounce(runSearch, debounceMs);
  return {
    search: debouncedSearch,
    retry: () => runSearch(state.query),
    cancel: () => activeController && activeController.abort(),
    getState: () => ({ ...state })
  };
}

function calculateHoldings(trades, currentPriceByMarket = {}) { // Pure aggregation function: unit-test this independently.
  const seen = new Set();
  const byMarket = new Map();
  const issues = [];

  for (const t of trades) {
    if (!t || seen.has(t.id)) { if (t?.id) issues.push(`duplicate:${t.id}`); continue; } // Idempotency/duplicate protection for repeated events.
    seen.add(t.id);
    if (t.status === "cancelled") continue; // Cancelled trades are excluded from holdings math.
    if (!["buy", "sell"].includes(t.side) || !Number.isFinite(t.quantity) || t.quantity <= 0 || !Number.isFinite(t.price)) {
      issues.push(`invalid:${t.id}`);
      continue;
    }

    const row = byMarket.get(t.marketId) || {
      marketId: t.marketId,
      marketTitle: t.marketTitle,
      quantity: 0,
      costBasis: 0,
      realizedPnl: 0
    };

    if (t.side === "buy") {
      row.quantity += t.quantity;
      row.costBasis += t.quantity * t.price;
    } else {
      if (row.quantity < t.quantity) {
        issues.push(`oversell:${t.id}`); // Oversell is explicit validation, not silent correction.
        continue;
      }
      const avgCost = row.quantity ? row.costBasis / row.quantity : 0;
      row.quantity -= t.quantity;
      row.costBasis -= avgCost * t.quantity;
      row.realizedPnl += (t.price - avgCost) * t.quantity;
    }

    byMarket.set(t.marketId, row);
  }

  const holdings = Array.from(byMarket.values()).map(h => {
    const mark = currentPriceByMarket[h.marketId];
    const unrealizedPnl = Number.isFinite(mark) ? (mark * h.quantity) - h.costBasis : null;
    return { ...h, unrealizedPnl };
  }).sort((a, b) => b.quantity - a.quantity);

  return { holdings, issues };
}

async function fetchMarkets(query, { signal } = {}) { // Fetch wrapper isolates transport concerns from UI state logic.
  const res = await fetch(`/api/markets?q=${encodeURIComponent(query)}`, { signal });
  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
  return res.json();
}

function createMarketsLoader() {
  let requestId = 0;
  let controller = null;

  return async function load(query, prev = { data: [], loading: false, error: null }) {
    if (controller) controller.abort();
    controller = new AbortController();
    const current = ++requestId; // Sequence id prevents stale responses replacing fresh state.
    const next = { ...prev, loading: true, error: null };

    try {
      const data = await fetchMarkets(query, { signal: controller.signal });
      if (current !== requestId) return prev;
      return { data, loading: false, error: null };
    } catch (e) {
      if (e.name === "AbortError" || current !== requestId) return prev; // Ignore aborted/stale outcomes to preserve correctness.
      return { ...next, loading: false, error: e.message };
    }
  };
}

function validateTradeInput({ quantity, price }) { // Validate early before optimistic mutation.
  if (!Number.isFinite(quantity) || quantity <= 0) return { ok: false, message: "Quantity must be greater than 0" };
  if (!Number.isFinite(price) || price < 0 || price > 1) return { ok: false, message: "Price must be between 0 and 1" };
  return { ok: true };
}

function addPendingTrade(prev, pending) { return [pending, ...prev]; }
function replaceTrade(prev, tempId, confirmed) { return prev.map(t => (t.id === tempId ? confirmed : t)); }
function removeTrade(prev, tempId) { return prev.filter(t => t.id !== tempId); }

async function submitTradeOptimistically(input, handlers) {
  const { readTrades, writeTrades, apiSubmit } = handlers;
  const check = validateTradeInput(input);
  if (!check.ok) throw new Error(check.message);

  const id = crypto.randomUUID();
  const pending = { id, ...input, status: "pending" }; // Optimistic row gives immediate user feedback.
  writeTrades(addPendingTrade(readTrades(), pending));

  try {
    const confirmed = await apiSubmit({ ...input, clientRequestId: id });
    writeTrades(replaceTrade(readTrades(), id, { ...confirmed, status: "confirmed" }));
    return confirmed;
  } catch (e) {
    writeTrades(removeTrade(readTrades(), id)); // Rollback on failure keeps UI consistent with server truth.
    throw e;
  }
}

function applyUpdate(markets, update) { // Immutable patch keeps state transitions predictable.
  return markets.map(m => {
    if (m.id !== update.marketId) return m; // Ignore unknown/non-target rows to avoid accidental writes.
    const prevTs = new Date(m.updatedAt).getTime();
    const nextTs = new Date(update.updatedAt).getTime();
    if (Number.isFinite(prevTs) && Number.isFinite(nextTs) && nextTs < prevTs) return m; // Drop stale updates so state never regresses.
    return { ...m, ...update, id: m.id }; // Immutable patch preserves unchanged fields.
  });
}

function applyBatchUpdates(markets, updates) {
  let next = markets;
  for (const u of updates) {
    if (!next.some(m => m.id === u.marketId)) continue;
    next = applyUpdate(next, u);
  }
  return next;
}

function getFeatureConfig(flags = {}) { 
  return {
    newMarketCard: Boolean(flags.newMarketCard), // Safe fallback when flag payload is partial/missing.
    quickTrade: Boolean(flags.quickTrade),
    showProbabilityChart: Boolean(flags.showProbabilityChart)
  };
}

function getMarketPresentation(market, flags) {
  const cfg = getFeatureConfig(flags);
  return {
    cardVariant: cfg.newMarketCard ? "v2" : "v1",
    canQuickTrade: cfg.quickTrade && market.status === "open",
    showProbabilityChart: cfg.showProbabilityChart
  };
}

function getExperimentMetrics() { 
  return ["card_click_through", "quick_trade_submit_rate", "trade_completion_rate", "error_rate"];
}

function paginate(items, page = 1, pageSize = 20) { // Pagination math remains framework-agnostic and deterministic.
  const totalPages = Math.max(1, Math.ceil(items.length / pageSize));
  const safePage = Math.min(Math.max(page, 1), totalPages); // Clamp page index to valid bounds.
  const start = (safePage - 1) * pageSize; // Deterministic offset calculation for stable paging.

  return {
    rows: items.slice(start, start + pageSize),
    page: safePage,
    totalPages,
    hasNext: safePage < totalPages,
    hasPrev: safePage > 1
  };
}

function makeRequestKey({ page, pageSize, filters }) { 
  return JSON.stringify({ page, pageSize, filters });
}

function shouldFetchPage(cache, key) {
  return !cache.has(key);
}

function canTrade(market) { 
  return market?.status === "open";
}

function applyMarketResolution(market, update) {
  if (market.id !== update.id) return market;
  return { ...market, status: update.status, outcome: update.outcome ?? market.outcome }; 
}

function getMarketUiState(market) {
  return {
    disabledTrading: !canTrade(market),
    resolvedBanner: market.status === "resolved" ? `Resolved: ${market.outcome}` : null
  };
}

function reconcileTradeSubmitError(err) {
  if (err?.code === "MARKET_CLOSED") return "Market just closed. Trade was not placed."; // Race-condition submit is reconciled with clear UX message.
  return "Trade failed. Please retry.";
}

function toggleWatchlistId(ids, marketId) { // Toggle logic is pure and reversible.
  return ids.includes(marketId) ? ids.filter(id => id !== marketId) : [marketId, ...ids]; 
}

function sortWatchlist(markets, watchlistIds) {
  const set = new Set(watchlistIds);
  return markets
    .filter(m => set.has(m.id))
    .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
}

async function persistWatchlist(apiSave, ids) {
  await apiSave(ids);
  return ids;
}

async function toggleWatchlistOptimistically(state, marketId, apiSave) {
  const prev = [...state.watchlistIds];
  const next = toggleWatchlistId(prev, marketId);
  state.watchlistIds = next;
  try {
    await persistWatchlist(apiSave, next);
  } catch {
    state.watchlistIds = prev; // Rollback restores prior state on persistence failure.
    throw new Error("Failed to update watchlist");
  }
}