import { z } from 'zod';
import { BaseConnector, type ConnectorMeta, type CrawlContext, type RawRecordInput, type RawRecordLike } from '@rareindex/connectors';
import { NormalizedAuctionLotSchema, NormalizedSaleSchema, type NormalizedRecord } from '@rareindex/shared';
import { normalizeCondition, parseGradeFromTitle } from '@rareindex/taxonomy';
import { brandFromSlug, hintFromLabel, isBundleTitle, legoSetNumber, safeYear, slugFromTitle, watchBrand, watchReference, type DeptHint } from '../../api/_auction-lib/categories.js';

/**
 * Catawiki — closed-lot results (hammer = final bid, EUR) and live lots, two-phase crawl.
 * Engine: Scrapfly. See meta.json accessNotes for the access rationale and cost model.
 */

const SITE = 'https://www.catawiki.com';

const SeedSchema = z.object({ id: z.number().int(), path: z.string(), hint: z.string() });
type Seed = z.infer<typeof SeedSchema>;

export const AuctionInfoSchema = z.object({
  id: z.number().int(),
  title: z.string(),
  url: z.string(),
  status: z.string().nullable(),
  startAt: z.string().nullable(),
  closeAt: z.string().nullable(),
  closedAt: z.string().nullable(),
  categories: z.array(z.string()),
  lotCount: z.number().nullable(),
});
export type AuctionInfo = z.infer<typeof AuctionInfoSchema>;

export const LiveLotSchema = z.object({
  id: z.number().int(),
  title: z.string(),
  subtitle: z.string().nullable(),
  url: z.string(),
  imageUrl: z.string().nullable(),
  reservePriceSet: z.boolean().nullable(),
  biddingStartTime: z.string().nullable(),
});
export const AuctionLotsPayloadSchema = z.object({
  kind: z.literal('auction_lots'),
  seedHint: z.string(),
  auction: AuctionInfoSchema,
  lots: z.array(LiveLotSchema),
});
export type AuctionLotsPayload = z.infer<typeof AuctionLotsPayloadSchema>;

export const LotPayloadSchema = z.object({
  kind: z.literal('lot'),
  seedHint: z.string(),
  id: z.number().int(),
  url: z.string(),
  title: z.string(),
  subtitle: z.string().nullable(),
  description: z.string().nullable(),
  images: z.array(z.string()),
  categoryId: z.number().nullable(),
  categoryUrl: z.string().nullable(),
  auction: AuctionInfoSchema.nullable(),
  specs: z.array(z.object({ name: z.string(), value: z.string() })),
  estimateMinEur: z.number().nullable(),
  estimateMaxEur: z.number().nullable(),
  sellerCountry: z.string().nullable(),
  sellerName: z.string().nullable(),
  sellerIsPro: z.boolean().nullable(),
  bidding: z.object({
    closed: z.boolean().nullable(),
    sold: z.boolean().nullable(),
    finalBidEur: z.number().nullable(),
    biddingStartTime: z.number().nullable(),
    biddingEndTime: z.number().nullable(),
    bidCount: z.number().nullable(),
    reservePriceMet: z.boolean().nullable(),
  }),
});
export type LotPayload = z.infer<typeof LotPayloadSchema>;

const ConfigSchema = z.object({
  seeds: z.array(SeedSchema).default([]),
  maxNewAuctionsPerRun: z.number().int().default(30),
  maxLotFetchesPerRun: z.number().int().default(400),
  pendingCap: z.number().int().default(6000),
  harvestDelayMinutes: z.number().int().default(20),
});

interface Pending {
  id: number;
  url: string;
  auctionId: number;
  closeAt: string;
  hint: string;
}
interface Cursor {
  auctions?: Record<string, { closeAt: string | null; hint: string }>;
  pending?: Pending[];
}

export function nextData(html: string): Record<string, any> | null {
  const m = html.match(/<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/);
  if (!m) return null;
  try {
    return (JSON.parse(m[1]!) as { props?: { pageProps?: Record<string, any> } }).props?.pageProps ?? null;
  } catch {
    return null;
  }
}

function auctionInfo(a: Record<string, any> | null | undefined): AuctionInfo | null {
  if (!a || !a.id) return null;
  return AuctionInfoSchema.parse({
    id: Number(a.id),
    title: String(a.title ?? ''),
    url: String(a.url ?? `${SITE}/en/a/${a.id}`),
    status: a.status ?? null,
    startAt: a.startAt ?? null,
    closeAt: a.closeAt ?? null,
    closedAt: a.closedAt ?? null,
    categories: ((a.categories as Array<{ title?: string; titleEn?: string }> | undefined) ?? []).map((c) => c.titleEn ?? c.title ?? '').filter(Boolean),
    lotCount: typeof a.lotCount === 'number' ? a.lotCount : typeof a.numberOfLots === 'number' ? a.numberOfLots : null,
  });
}

/** Auction page → auction info + live lot list. */
export function parseAuctionPage(html: string): { auction: AuctionInfo; lots: z.infer<typeof LiveLotSchema>[] } | null {
  const pp = nextData(html);
  const auction = auctionInfo(pp?.auction);
  if (!auction) return null;
  const lots = ((pp?.lots as Array<Record<string, any>> | undefined) ?? []).map((l) =>
    LiveLotSchema.parse({
      id: Number(l.id),
      title: String(l.title ?? ''),
      subtitle: l.subtitle ?? null,
      url: String(l.url ?? `${SITE}/en/l/${l.id}`),
      imageUrl: l.originalImageUrl ?? l.thumbImageUrl ?? null,
      reservePriceSet: typeof l.reservePriceSet === 'boolean' ? l.reservePriceSet : null,
      biddingStartTime: l.biddingStartTime ?? null,
    }),
  );
  return { auction, lots };
}

/** Lot page → compact payload. */
export function parseLotPage(html: string, url: string, seedHint: string): LotPayload | null {
  const pp = nextData(html);
  const ld = pp?.lotDetailsData;
  if (!ld) return null;
  const bb = pp?.biddingBlockResponse ?? {};
  const live = bb.live?.lot ?? {};
  const est = ld.expertsEstimate ?? {};
  const seller = ld.sellerInfo ?? {};
  const finalBid = typeof live.bid?.EUR === 'number' ? live.bid.EUR : typeof bb.localizedCurrentBidAmount === 'number' ? bb.localizedCurrentBidAmount : null;
  const bids = bb.biddingHistory?.bids;
  const bidCount = Array.isArray(bids) && bids.length ? Number(bids[0]?.totalBids ?? bids.length) : null;
  return LotPayloadSchema.parse({
    kind: 'lot',
    seedHint,
    id: Number(ld.lotId ?? pp?.lotId),
    url,
    title: String(ld.lotTitle ?? ''),
    subtitle: ld.lotSubtitle ?? null,
    description: typeof ld.description === 'string' ? ld.description.replace(/\s+/g, ' ').slice(0, 800) : null,
    images: ((ld.images as Array<{ large?: string; id?: string }> | undefined) ?? []).map((i) => i.large ?? i.id ?? '').filter(Boolean).slice(0, 3),
    categoryId: typeof ld.category?.id === 'number' ? ld.category.id : null,
    categoryUrl: ld.category?.url ?? null,
    auction: auctionInfo(pp?.auction),
    specs: ((ld.specifications as Array<{ name?: string; value?: string }> | undefined) ?? []).filter((s) => s.name && s.value).map((s) => ({ name: String(s.name), value: String(s.value) })),
    estimateMinEur: typeof est.min?.EUR === 'number' && est.min.EUR > 0 ? est.min.EUR : null,
    estimateMaxEur: typeof est.max?.EUR === 'number' && est.max.EUR > 0 ? est.max.EUR : null,
    sellerCountry: seller.address?.country?.shortCode ? String(seller.address.country.shortCode).toUpperCase() : null,
    sellerName: seller.sellerName ?? null,
    sellerIsPro: typeof seller.isPro === 'boolean' ? seller.isPro : null,
    bidding: {
      closed: typeof bb.closed === 'boolean' ? bb.closed : typeof ld.isClosed === 'boolean' ? ld.isClosed : null,
      sold: typeof bb.sold === 'boolean' ? bb.sold : null,
      finalBidEur: finalBid,
      biddingStartTime: typeof bb.biddingStartTime === 'number' ? bb.biddingStartTime : null,
      biddingEndTime: typeof bb.biddingEndTime === 'number' ? bb.biddingEndTime : typeof live.biddingEndTime === 'number' ? live.biddingEndTime : null,
      bidCount,
      reservePriceMet: typeof bb.reservePriceMet === 'boolean' ? bb.reservePriceMet : null,
    },
  });
}

export function categoryPageAuctionIds(html: string): number[] {
  return [...new Set([...html.matchAll(/\/en\/a\/(\d+)/g)].map((m) => Number(m[1])))];
}

function spec(specs: Array<{ name: string; value: string }>, ...names: string[]): string | null {
  for (const n of names) {
    const hit = specs.find((s) => s.name.toLowerCase() === n.toLowerCase());
    if (hit) return hit.value;
  }
  return null;
}

/** Derive taxonomy slug + attributes from a Catawiki lot (seed hint + auction categories + specs + title). */
export function classifyLot(lot: LotPayload): { slug: string | null; hint: DeptHint } {
  const cats = lot.auction?.categories ?? [];
  const labelHint = hintFromLabel(cats[cats.length - 1]) !== 'unknown' ? hintFromLabel(cats[cats.length - 1]) : hintFromLabel(cats[0]);
  const hint: DeptHint = (lot.seedHint as DeptHint) !== 'unknown' && lot.seedHint ? (lot.seedHint as DeptHint) : labelHint;
  const catText = cats.join(' ');
  // The most specific (leaf) category decides; the full path only for franchise-style families.
  const leaf = cats[cats.length - 1] ?? '';
  const text = `${lot.title} ${lot.subtitle ?? ''}`;
  if (/lego/i.test(catText)) return { slug: 'lego_sets', hint };
  if (/funko/i.test(catText)) return { slug: 'funko', hint };
  if (/pok[eé]mon/i.test(catText)) return { slug: 'pokemon', hint };
  if (/model (?:cars|trains)|modelauto|diecast/i.test(leaf)) return { slug: /train/i.test(leaf) ? 'model_trains' : 'model_cars', hint };
  if (/video ?games|retro gaming/i.test(leaf)) return { slug: 'video_games', hint };
  if (/sneaker/i.test(leaf)) return { slug: 'sneakers', hint };
  if (/handbag|bags/i.test(leaf)) return { slug: 'luxury_handbags', hint };
  if (/whisky|whiskey/i.test(leaf)) return { slug: 'whisky', hint };
  if (/\bwine|champagne/i.test(leaf)) return { slug: slugFromTitle(text, 'wine') ?? 'wine', hint };
  if (/watch/i.test(leaf) && !/pen|lighter/i.test(leaf)) return { slug: watchBrand(text).slug, hint: 'watches' };
  if (/banknote/i.test(leaf)) return { slug: 'banknotes', hint };
  if (/stamp/i.test(leaf) && !/coin/i.test(leaf)) return { slug: 'stamps', hint };
  if (/coin|numismat/i.test(leaf)) return { slug: slugFromTitle(text, 'coins') ?? 'coins', hint: 'coins' };
  if (/vinyl|records/i.test(leaf)) return { slug: 'music', hint };
  if (/movie poster|film poster/i.test(leaf)) return { slug: 'movie_posters', hint };
  if (/camera/i.test(leaf)) return { slug: 'cameras', hint };
  return { slug: slugFromTitle(text, hint), hint };
}

function toDate(ms: number | null | undefined): Date | null {
  return typeof ms === 'number' && ms > 0 ? new Date(ms) : null;
}

export default function createConnector(meta: ConnectorMeta) {
  return new CatawikiConnector(meta);
}

export class CatawikiConnector extends BaseConnector {
  readonly version = '1.0.0';
  readonly parserVersion = '1.0.0';
  override readonly urlPatterns = [/^https?:\/\/(www\.)?catawiki\.[a-z]+\/[a-z]{2}\/l\/\d+/i];
  protected override minIntervalMs = 2000;
  private readonly config = ConfigSchema.parse(this.meta.config ?? {});

  private async html(ctx: CrawlContext, url: string, renderJs: boolean): Promise<string | null> {
    await this.throttle();
    const res = await ctx.fetch(url, { engines: ['scrapfly'], renderJs, country: 'nl', minQuality: 0, waitForMs: renderJs ? 3000 : undefined, timeoutMs: renderJs ? 120_000 : 60_000 });
    if (!res.success || !res.html) {
      ctx.anomaly('page_fetch_failed', `${url}: ${res.error ?? res.httpStatus}`);
      return null;
    }
    return res.html;
  }

  private async fetchLot(ctx: CrawlContext, url: string, hint: string): Promise<LotPayload | null> {
    const html = await this.html(ctx, url, false);
    if (!html) return null;
    const lot = parseLotPage(html, url, hint);
    if (!lot) ctx.anomaly('parse_failure', `${url}: no lotDetailsData`);
    return lot;
  }

  async *crawl(ctx: CrawlContext): AsyncIterable<RawRecordInput> {
    const cursor: Cursor = { auctions: {}, pending: [], ...(ctx.options.cursor ?? {}) };
    const probe = ctx.options.mode === 'probe';
    const now = Date.now();
    let yielded = 0;

    // 0. Explicit seeds (lot or auction URLs) — used by probes, smoke tests and backfills.
    for (const s of ctx.options.seeds ?? []) {
      const lotM = s.match(/\/l\/(\d+)/);
      if (lotM) {
        const lot = await this.fetchLot(ctx, s, 'unknown');
        if (lot && lot.bidding.closed && lot.bidding.sold) {
          yield { url: s, externalId: String(lot.id), kind: 'sale', engine: 'scrapfly', httpStatus: 200, payload: lot, fetchedAt: new Date() };
          if (this.reached(ctx, ++yielded)) return;
        }
        continue;
      }
      if (/\/a\/\d+/.test(s)) {
        const html = await this.html(ctx, s, false);
        const parsed = html ? parseAuctionPage(html) : null;
        if (parsed) {
          const payload: AuctionLotsPayload = { kind: 'auction_lots', seedHint: 'unknown', auction: parsed.auction, lots: parsed.lots };
          yield { url: s, externalId: `a${parsed.auction.id}`, kind: 'auction_lot', engine: 'scrapfly', httpStatus: 200, payload, fetchedAt: new Date() };
          this.remember(cursor, parsed, 'unknown');
        }
      }
    }
    if (probe && (ctx.options.seeds?.length ?? 0) > 0) {
      await ctx.setCursor(cursor as Record<string, unknown>);
      return;
    }

    // 1. Harvest closed lots
    const delayMs = this.config.harvestDelayMinutes * 60_000;
    const due = (cursor.pending ?? []).filter((p) => new Date(p.closeAt).getTime() + delayMs <= now).slice(0, probe ? 3 : this.config.maxLotFetchesPerRun);
    const dueIds = new Set(due.map((p) => p.id));
    for (const p of due) {
      if (ctx.signal?.aborted) break;
      const lot = await this.fetchLot(ctx, p.url, p.hint);
      if (lot && lot.bidding.closed === false) {
        // extended bidding — try again next run
        dueIds.delete(p.id);
        continue;
      }
      if (lot && lot.bidding.closed && lot.bidding.sold) {
        yield { url: p.url, externalId: String(lot.id), kind: 'sale', engine: 'scrapfly', httpStatus: 200, payload: lot, fetchedAt: new Date() };
        if (this.reached(ctx, ++yielded)) break;
      }
    }
    cursor.pending = (cursor.pending ?? []).filter((p) => !dueIds.has(p.id));
    await ctx.setCursor(cursor as Record<string, unknown>);

    // 2. Discovery of live auctions per seed category
    const seeds = ctx.options.categories?.length ? this.config.seeds.filter((s) => ctx.options.categories!.includes(s.hint)) : this.config.seeds;
    let newAuctions = 0;
    for (const seed of probe ? seeds.slice(0, 1) : seeds) {
      if (ctx.signal?.aborted) break;
      const html = await this.html(ctx, `${SITE}/en/c/${seed.path}`, true);
      if (!html) continue;
      const ids = categoryPageAuctionIds(html);
      if (!ids.length) ctx.anomaly('empty_page', `category ${seed.path}: no auction links after render`);
      for (const id of ids) {
        if (cursor.auctions?.[String(id)]) continue;
        if (newAuctions >= (probe ? 1 : this.config.maxNewAuctionsPerRun)) break;
        const url = `${SITE}/en/a/${id}`;
        const ahtml = await this.html(ctx, url, false);
        const parsed = ahtml ? parseAuctionPage(ahtml) : null;
        if (!parsed) continue;
        newAuctions++;
        this.remember(cursor, parsed, seed.hint);
        if (parsed.lots.length) {
          const payload: AuctionLotsPayload = { kind: 'auction_lots', seedHint: seed.hint, auction: parsed.auction, lots: parsed.lots };
          yield { url: parsed.auction.url, externalId: `a${parsed.auction.id}`, kind: 'auction_lot', engine: 'scrapfly', httpStatus: 200, payload, fetchedAt: new Date() };
        }
        await ctx.setCursor(cursor as Record<string, unknown>);
      }
    }
    // prune remembered auctions older than 30 days
    const cutoff = now - 30 * 86_400_000;
    for (const [id, a] of Object.entries(cursor.auctions ?? {})) if (a.closeAt && new Date(a.closeAt).getTime() < cutoff) delete cursor.auctions![id];
    await ctx.setCursor(cursor as Record<string, unknown>);
  }

  private remember(cursor: Cursor, parsed: NonNullable<ReturnType<typeof parseAuctionPage>>, hint: string): void {
    cursor.auctions ??= {};
    cursor.pending ??= [];
    cursor.auctions[String(parsed.auction.id)] = { closeAt: parsed.auction.closeAt, hint };
    if (!parsed.auction.closeAt) return;
    const known = new Set(cursor.pending.map((p) => p.id));
    for (const l of parsed.lots) {
      if (known.has(l.id)) continue;
      cursor.pending.push({ id: l.id, url: l.url, auctionId: parsed.auction.id, closeAt: parsed.auction.closeAt, hint });
    }
    if (cursor.pending.length > this.config.pendingCap) cursor.pending = cursor.pending.slice(-this.config.pendingCap);
  }

  async lookup(url: string, ctx: CrawlContext): Promise<RawRecordInput[]> {
    const lot = await this.fetchLot(ctx, url, 'unknown');
    if (!lot) return [];
    return [{ url, externalId: String(lot.id), kind: lot.bidding.closed ? 'sale' : 'auction_lot', engine: 'scrapfly', httpStatus: 200, payload: lot, fetchedAt: new Date() }];
  }

  async normalize(raw: RawRecordLike): Promise<NormalizedRecord[]> {
    const p = raw.payload as { kind?: string };
    if (p?.kind === 'auction_lots') return this.normalizeAuctionLots(raw, AuctionLotsPayloadSchema.parse(raw.payload));
    const lot = LotPayloadSchema.parse(raw.payload);
    const { slug } = classifyLot(lot);
    if (!slug) return [];
    const text = `${lot.title} ${lot.subtitle ?? ''}`.trim();
    const grade = parseGradeFromTitle(text);
    const grader = spec(lot.specs, 'Grading company', 'Graded by');
    const gradeSpec = spec(lot.specs, 'Grade', 'Card grade');
    const brandSpec = spec(lot.specs, 'Brand', 'Manufacturer', 'Producer', 'Publisher', 'Winery', 'Distillery');
    const model = spec(lot.specs, 'Model', 'Series', 'Theme', 'Set');
    const reference = spec(lot.specs, 'Reference number', 'Reference', 'Set number', 'Catalogue number') ?? (['rolex', 'patek_philippe', 'audemars_piguet', 'omega', 'other_watches'].includes(slug) ? watchReference(text) : null);
    const yearSpec = spec(lot.specs, 'Year', 'Year of production', 'Vintage', 'Year of publication', 'Release year');
    const conditionRaw = spec(lot.specs, 'Condition', 'Card condition', 'Condition of the item');
    const identifiers: Record<string, string> = { catawiki_lot_id: String(lot.id) };
    if (reference) identifiers.reference = reference;
    if (slug === 'lego_sets') {
      const n = spec(lot.specs, 'Set number') ?? legoSetNumber(text);
      if (n) identifiers.lego_set_number = n;
    }
    const attributes = {
      categorySlug: slug,
      name: lot.title,
      brand: brandSpec ?? brandFromSlug(slug, text),
      model,
      reference,
      year: yearSpec ? safeYear(yearSpec) : safeYear(text),
      country: spec(lot.specs, 'Country of origin', 'Country'),
      material: spec(lot.specs, 'Material'),
      identifiers,
      metadata: { auction_id: lot.auction?.id ?? null, auction_title: lot.auction?.title ?? null, auction_categories: lot.auction?.categories ?? [], category_id: lot.categoryId, category_url: lot.categoryUrl, specs: Object.fromEntries(lot.specs.map((s) => [s.name, s.value])), estimate_min_eur: lot.estimateMinEur, estimate_max_eur: lot.estimateMaxEur, seller_country: lot.sellerCountry, seller_pro: lot.sellerIsPro, bids: lot.bidding.bidCount, buyer_fee_note: 'Catawiki charges the buyer an additional protection fee (~9% + VAT) on top of the final bid' },
    };
    const base = {
      connectorId: this.meta.id,
      sourceId: this.meta.sourceId,
      sourceUrl: lot.url,
      externalId: String(lot.id),
      rawTitle: text,
      description: lot.description,
      imageUrls: lot.images,
      attributes,
      grade: { grader: grader ? (parseGradeFromTitle(`${grader} 1`).grader ?? grader.toLowerCase()) : grade.grader, grade: gradeSpec ?? grade.grade, qualifier: grade.qualifier, certificationNumber: spec(lot.specs, 'Certificate number', 'Certification number') },
      condition: { condition: normalizeCondition(slug, conditionRaw), conditionRaw, completeness: null },
      observedAt: raw.fetchedAt,
      parserVersion: this.parserVersion,
    };
    const endsAt = toDate(lot.bidding.biddingEndTime);
    if (lot.bidding.closed && lot.bidding.sold && lot.bidding.finalBidEur && endsAt) {
      if (endsAt.getTime() > new Date(raw.fetchedAt).getTime() + 86_400_000) return []; // a 'closed' lot ending after observation is inconsistent
      return [
        NormalizedSaleSchema.parse({
          ...base,
          kind: 'sale',
          confidence: 0.85,
          saleType: 'auction',
          saleDate: endsAt,
          price: lot.bidding.finalBidEur,
          currency: 'EUR',
          buyerPremiumIncluded: false,
          quantity: 1,
          isBundle: isBundleTitle(text),
          location: lot.sellerCountry,
          auctionHouse: 'Catawiki',
          lotNumber: null,
        }),
      ];
    }
    if (!lot.bidding.closed) {
      return [
        NormalizedAuctionLotSchema.parse({
          ...base,
          kind: 'auction_lot',
          confidence: 0.8,
          auctionHouse: 'Catawiki',
          auctionName: lot.auction?.title ?? null,
          lotNumber: null,
          startsAt: toDate(lot.bidding.biddingStartTime),
          endsAt,
          estimateLow: lot.estimateMinEur,
          estimateHigh: lot.estimateMaxEur,
          currentBid: lot.bidding.finalBidEur,
          currency: 'EUR',
          status: 'live',
          location: lot.sellerCountry,
        }),
      ];
    }
    return [];
  }

  private normalizeAuctionLots(raw: RawRecordLike, page: AuctionLotsPayload): NormalizedRecord[] {
    const out: NormalizedRecord[] = [];
    const a = page.auction;
    const closeAt = a.closeAt ? new Date(a.closeAt) : null;
    const startAt = a.startAt ? new Date(a.startAt) : null;
    // staleness is judged at observation time (raw.fetchedAt), not at normalisation time: fixtures and
    // delayed normalisation must not silently drop lots that were live when crawled
    const observedAtMs = new Date(raw.fetchedAt).getTime();
    if (closeAt && closeAt.getTime() < observedAtMs) return []; // stale listing page
    const catLabel = a.categories[a.categories.length - 1] ?? a.categories[0] ?? null;
    for (const l of page.lots) {
      const text = `${l.title} ${l.subtitle ?? ''}`.trim();
      const slug = classifyLot({ kind: 'lot', seedHint: page.seedHint, id: l.id, url: l.url, title: l.title, subtitle: l.subtitle, description: null, images: [], categoryId: null, categoryUrl: null, auction: a, specs: [], estimateMinEur: null, estimateMaxEur: null, sellerCountry: null, sellerName: null, sellerIsPro: null, bidding: { closed: false, sold: null, finalBidEur: null, biddingStartTime: null, biddingEndTime: null, bidCount: null, reservePriceMet: null } }).slug;
      if (!slug) continue;
      const grade = parseGradeFromTitle(text);
      out.push(
        NormalizedAuctionLotSchema.parse({
          kind: 'auction_lot',
          connectorId: this.meta.id,
          sourceId: this.meta.sourceId,
          sourceUrl: l.url,
          externalId: String(l.id),
          rawTitle: text,
          description: null,
          imageUrls: l.imageUrl ? [l.imageUrl] : [],
          attributes: { categorySlug: slug, name: l.title, brand: brandFromSlug(slug, text), year: safeYear(text), identifiers: { catawiki_lot_id: String(l.id) }, metadata: { auction_id: a.id, auction_title: a.title, auction_categories: a.categories, category_label: catLabel } },
          grade: { grader: grade.grader, grade: grade.grade, qualifier: grade.qualifier, certificationNumber: null },
          condition: {},
          observedAt: raw.fetchedAt,
          confidence: 0.7,
          parserVersion: this.parserVersion,
          auctionHouse: 'Catawiki',
          auctionName: a.title,
          lotNumber: null,
          startsAt: startAt,
          endsAt: closeAt,
          estimateLow: null,
          estimateHigh: null,
          currentBid: null,
          currency: 'EUR',
          status: startAt && startAt.getTime() <= observedAtMs ? 'live' : 'upcoming',
          location: null,
        }),
      );
    }
    return out;
  }
}