import { z } from 'zod';
import { BaseConnector, type ConnectorMeta, type CrawlContext, type RawRecordInput, type RawRecordLike } from '@rareindex/connectors';
import { AssetAttributesSchema, NormalizedListingSchema, type NormalizedRecord } from '@rareindex/shared';
import { designSlug, plainText, readSeedCursor, yearOrDecade, type DesignVertical } from '../_g10-lib/index.js';

/**
 * 1stDibs — the largest online marketplace for vintage/antique furniture, design, jewelry, watches,
 * fashion and art (USD by default). Browse pages (/furniture/seating/, /jewelry/, … ?page=N, 60 items)
 * embed the server-rendered Relay store in <script id="serverVars_data" type="application/json">;
 * we read the `Item` records from it (title, serviceId, prices in ten currencies, seller company,
 * creators/designers, location, period/style attributes, materials, measurements, photos, sold/hold
 * flags) and never call 1stDibs' GraphQL endpoint ourselves. Asking prices → listings.
 */
const BASE = 'https://www.1stdibs.com';
const PARSER_VERSION = '1.0.0';
const PAGE_SIZE = 60;

export const SeedSchema = z.object({ path: z.string(), slug: z.string().nullable().optional(), vertical: z.enum(['furniture', 'lighting', 'decor', 'art', 'jewelry', 'watches', 'fashion', 'tableware', 'rugs', 'pens', 'unknown']).default('unknown') });
export type Seed = z.infer<typeof SeedSchema>;

export const ItemSchema = z.object({
  serviceId: z.string(),
  title: z.string(),
  url: z.string(),
  prices: z.record(z.string(), z.number()),
  amountType: z.string().nullable(),
  isSold: z.boolean(),
  isOnHold: z.boolean(),
  isUnavailable: z.boolean(),
  isNewListing: z.boolean().nullable(),
  seller: z.object({ serviceId: z.string().nullable(), company: z.string().nullable() }),
  creators: z.array(z.string()),
  country: z.string().nullable(),
  location: z.string().nullable(),
  attributesText: z.string().nullable(),
  materials: z.string().nullable(),
  description: z.string().nullable(),
  measurement: z.string().nullable(),
  categoryCode: z.string().nullable(),
  browseUrl: z.string().nullable(),
  vertical: z.string().nullable(),
  images: z.array(z.string()),
});
export type Item = z.infer<typeof ItemSchema>;

export const PagePayloadSchema = z.object({ kind: z.literal('listing_page'), url: z.string(), seed: SeedSchema, page: z.number().int(), totalResults: z.number().int().nullable(), maxPages: z.number().int().nullable(), items: z.array(ItemSchema), snapshot: z.string().optional() });
export type PagePayload = z.infer<typeof PagePayloadSchema>;

const ConfigSchema = z.object({ seeds: z.array(SeedSchema).min(1), pagesPerSeed: z.number().int().min(1).default(1), seedsPerRun: z.number().int().min(1).default(3), maxPagesPerSeed: z.number().int().min(1).default(50) });

type Rec = Record<string, unknown>;

/** Relay normalized store → dereferenced view (bounded depth). */
export function makeDeref(store: Record<string, Rec>) {
  const deref = (v: unknown, depth = 0): unknown => {
    if (depth > 4 || v === null || typeof v !== 'object') return v;
    if (Array.isArray(v)) return v.map((x) => deref(x, depth + 1));
    const o = v as Rec;
    if (typeof o.__ref === 'string') return deref(store[o.__ref] ?? null, depth + 1);
    if (Array.isArray(o.__refs)) return o.__refs.map((r) => deref(store[String(r)] ?? null, depth + 1));
    const out: Rec = {};
    for (const [k, x] of Object.entries(o)) if (k !== '__id') out[k] = deref(x, depth + 1);
    return out;
  };
  return deref;
}

function firstKey(o: Rec, prefix: string): unknown {
  const k = Object.keys(o).find((x) => x === prefix || x.startsWith(`${prefix}(`));
  return k ? o[k] : undefined;
}

const str = (v: unknown): string | null => (typeof v === 'string' && v.trim() ? v.trim() : null);

/** Parse the serverVars_data bootstrap of a browse page. Exported for tests. */
export function parseBrowseHtml(htmlText: string): { items: Item[]; totalResults: number | null; maxPages: number | null } | null {
  const m = htmlText.match(/<script id="serverVars_data" type="application\/json">([\s\S]*?)<\/script>/);
  if (!m) return null;
  let root: Rec;
  try {
    root = JSON.parse(m[1]!) as Rec;
  } catch {
    return null;
  }
  const store = ((root.dbl as Rec | undefined)?.relayData ?? (root.relay as Rec | undefined)?.store ?? null) as Record<string, Rec> | null;
  if (!store || typeof store !== 'object') return null;
  const deref = makeDeref(store);
  const items: Item[] = [];
  let totalResults: number | null = null;
  let maxPages: number | null = null;
  for (const rec of Object.values(store)) {
    if (!rec || typeof rec !== 'object') continue;
    if (rec.__typename === 'ItemSearchQueryConnection') {
      if (typeof rec.totalResults === 'number') totalResults = rec.totalResults;
      if (typeof rec.displayMaxNumberOfPages === 'number') maxPages = rec.displayMaxNumberOfPages;
      continue;
    }
    if (rec.__typename !== 'Item' || typeof rec.serviceId !== 'string' || typeof rec.title !== 'string') continue;
    const dp = deref(firstKey(rec, 'displayPrice')) as Array<{ convertedAmountList?: Array<{ amount?: number; currency?: string }>; amountType?: string }> | undefined;
    const prices: Record<string, number> = {};
    let amountType: string | null = null;
    for (const d of dp ?? []) {
      amountType ??= d.amountType ?? null;
      for (const c of d.convertedAmountList ?? []) if (c.currency && typeof c.amount === 'number' && c.amount > 0) prices[c.currency] ??= c.amount;
    }
    const track = rec.ecommerceTrackingParams as { price?: number; convertedAmounts?: Record<string, number> } | undefined;
    if (!Object.keys(prices).length && track?.convertedAmounts) for (const [k, v] of Object.entries(track.convertedAmounts)) if (typeof v === 'number' && v > 0) prices[k] = v;
    const seller = deref(rec.seller) as { serviceId?: string; sellerProfile?: { company?: string } } | null;
    const creators = (deref(rec.creators) as Array<{ creator?: { displayName?: string } }> | null) ?? [];
    const address = deref(rec.address) as { englishCountryName?: string } | null;
    const qv = deref(rec.quickViewDisplay) as { paragraphs?: Array<{ key?: string; text?: string }> } | null;
    const para = (key: string) => str(qv?.paragraphs?.find((p) => p.key === key)?.text);
    const meas = deref(rec.measurement) as Rec | null;
    const measList = meas ? (firstKey(meas, 'display') as Array<{ unit?: string; value?: string }> | undefined) : undefined;
    const photos = (deref(firstKey(rec, 'photos')) as Array<{ masterOrZoomPath?: string; versions?: Array<{ webPath?: string }> }> | null) ?? [];
    const images = photos.map((p) => p.versions?.find((v) => v.webPath?.includes('width=768'))?.webPath ?? p.masterOrZoomPath ?? null).filter((x): x is string => Boolean(x));
    const link = deref(rec.linkData) as { path?: string } | null;
    const path = str(rec.localizedPdpUrl) ?? str(link?.path);
    if (!path) continue;
    items.push({
      serviceId: rec.serviceId,
      title: rec.title,
      url: path.startsWith('http') ? path : `${BASE}${path}`,
      prices,
      amountType,
      isSold: rec.isSold === true,
      isOnHold: rec.isOnHold === true,
      isUnavailable: rec.isUnavailable === true,
      isNewListing: typeof rec.isNewListing === 'boolean' ? rec.isNewListing : null,
      seller: { serviceId: str(seller?.serviceId), company: str(seller?.sellerProfile?.company) },
      creators: creators.map((c) => str(c?.creator?.displayName)).filter((x): x is string => Boolean(x)),
      country: str(address?.englishCountryName),
      location: para('location'),
      attributesText: para('attributes'),
      materials: para('materials'),
      description: plainText(para('description'), 1200),
      measurement: str(measList?.find((x) => x.unit === 'IN')?.value ?? measList?.[0]?.value),
      categoryCode: str(rec.categoryCode),
      browseUrl: str(rec.browseUrl),
      vertical: str(rec.vertical),
      images: [...new Set(images)].slice(0, 4),
    });
  }
  return { items, totalResults, maxPages };
}

export function pageUrl(seedPath: string, page: number): string {
  const p = seedPath.endsWith('/') ? seedPath : `${seedPath}/`;
  return `${BASE}${p}${page > 1 ? `?page=${page}` : ''}`;
}

/**
 * Fixture helper: rebuild a minimal page whose serverVars_data store only holds the search connection
 * record plus the first `n` Item records and everything reachable from them through __ref/__refs.
 */
export function trimStoreHtml(htmlText: string, n = 3): string {
  const m = htmlText.match(/<script id="serverVars_data" type="application\/json">([\s\S]*?)<\/script>/);
  if (!m) return '';
  const root = JSON.parse(m[1]!) as Rec;
  const store = ((root.dbl as Rec | undefined)?.relayData ?? {}) as Record<string, Rec>;
  const keep = new Set<string>();
  const queue: string[] = [];
  for (const [k, v] of Object.entries(store)) {
    if (v?.__typename === 'ItemSearchQueryConnection') keep.add(k);
  }
  let picked = 0;
  for (const [k, v] of Object.entries(store)) {
    if (v?.__typename === 'Item' && picked < n) {
      queue.push(k);
      picked++;
    }
  }
  const collect = (v: unknown) => {
    if (!v || typeof v !== 'object') return;
    if (Array.isArray(v)) return v.forEach(collect);
    const o = v as Rec;
    if (typeof o.__ref === 'string') queue.push(o.__ref);
    if (Array.isArray(o.__refs)) for (const r of o.__refs) queue.push(String(r));
    for (const [k, x] of Object.entries(o)) if (k !== '__ref' && k !== '__refs') collect(x);
  };
  while (queue.length) {
    const k = queue.shift()!;
    if (keep.has(k) || !store[k]) continue;
    keep.add(k);
    collect(store[k]);
  }
  const small: Record<string, Rec> = {};
  for (const k of keep) {
    const rec = store[k]!;
    // the connection record references every item on the page; keep only its scalar fields
    small[k] = rec.__typename === 'ItemSearchQueryConnection' ? Object.fromEntries(Object.entries(rec).filter(([, v]) => v === null || typeof v !== 'object')) : rec;
  }
  return `<!doctype html><html><head><script id="serverVars_data" type="application/json">${JSON.stringify({ dbl: { relayData: small } })}</script></head><body></body></html>`;
}

function verticalFor(seed: Seed, item: Item): DesignVertical {
  if (seed.vertical !== 'unknown') return seed.vertical;
  const v = item.vertical ?? '';
  const code = item.categoryCode ?? '';
  if (v === 'jewelry') return code.startsWith('J_WAT') ? 'watches' : 'jewelry';
  if (v === 'fashion') return 'fashion';
  if (v === 'art') return 'art';
  if (code.startsWith('F_LIG')) return 'lighting';
  if (code.startsWith('F_DEC') || code.startsWith('F_SER')) return 'decor';
  if (code.startsWith('F_RUG') || code.startsWith('F_TEX')) return 'rugs';
  return v === 'furniture' ? 'furniture' : 'unknown';
}

export class FirstDibsConnector extends BaseConnector {
  readonly version = '1.0.0';
  readonly parserVersion = PARSER_VERSION;
  protected override minIntervalMs = 5000;
  override readonly urlPatterns = [/^https?:\/\/(www\.)?1stdibs\.com\/(?:furniture|jewelry|fashion|art)\/.+\/id-([a-z]_\d+)\/?/i];
  private readonly cfg: z.infer<typeof ConfigSchema>;

  constructor(meta: ConnectorMeta) {
    super(meta);
    this.cfg = ConfigSchema.parse(meta.config);
  }

  async *crawl(ctx: CrawlContext): AsyncIterable<RawRecordInput> {
    const seeds = ctx.options.seeds?.length ? ctx.options.seeds.map((s) => SeedSchema.parse({ path: s.startsWith('/') ? s : new URL(s).pathname })) : this.cfg.seeds;
    const backfill = ctx.options.mode === 'backfill';
    const maxPages = backfill ? Math.min(this.policy.backfillMaxPages, this.cfg.maxPagesPerSeed) : this.cfg.pagesPerSeed;
    const start = readSeedCursor(ctx.options.cursor, seeds.length);
    const seedsThisRun = backfill ? seeds.length : Math.min(seeds.length, this.cfg.seedsPerRun);
    let count = 0;
    let items = 0;
    for (let k = 0; k < seedsThisRun; k++) {
      const seedIndex = (start.seedIndex + k) % seeds.length;
      const seed = seeds[seedIndex]!;
      let page = k === 0 ? start.page : 1;
      for (; page <= maxPages; page++) {
        if (ctx.signal?.aborted || this.reached(ctx, count)) return;
        const url = pageUrl(seed.path, page);
        await this.throttle(url);
        const res = await ctx.fetch(url, {
          engines: ['api'],
          responseType: 'text',
          timeoutMs: 90_000,
          expect: ['title', 'price', 'currency'],
          parse: (r) => {
            const p = r.html ? parseBrowseHtml(r.html) : null;
            const priced = p?.items.find((i) => i.prices.USD);
            return p?.items.length ? { title: p.items[0]!.title, price: priced?.prices.USD ?? null, currency: priced ? 'USD' : null } : null;
          },
          minQuality: 0.3,
        });
        const parsed = res.success && res.html ? parseBrowseHtml(res.html) : null;
        if (!parsed) {
          ctx.anomaly(res.success ? 'schema_drift' : 'page_fetch_failed', `${url}: ${res.error ?? res.httpStatus ?? 'serverVars_data missing'}`);
          break;
        }
        if (!parsed.items.length) {
          if (page === 1) ctx.anomaly('parse_failure_page', `${url}: no Item records`);
          break;
        }
        count++;
        items += parsed.items.length;
        const payload: PagePayload = { kind: 'listing_page', url, seed, page, totalResults: parsed.totalResults, maxPages: parsed.maxPages, items: parsed.items };
        yield { url, externalId: `${seed.path}:p${page}`, kind: 'listing', engine: res.engine, httpStatus: res.httpStatus, payload, fetchedAt: res.fetchedAt };
        await ctx.setCursor({ seedIndex, page: page + 1, at: new Date().toISOString() });
        await ctx.progress({ page, totalPages: parsed.maxPages, itemsProcessed: items });
        if (parsed.items.length < PAGE_SIZE || (parsed.maxPages !== null && page >= parsed.maxPages)) break;
      }
      const nextSeed = (seedIndex + 1) % seeds.length;
      await ctx.setCursor({ seedIndex: nextSeed, page: 1, at: new Date().toISOString(), ...(backfill && nextSeed === 0 ? { done: true } : {}) });
    }
  }

  async normalize(raw: RawRecordLike): Promise<NormalizedRecord[]> {
    const p = PagePayloadSchema.parse(raw.payload);
    const out: NormalizedRecord[] = [];
    for (const it of p.items) {
      const vertical = verticalFor(p.seed, it);
      const categorySlug = p.seed.slug ?? designSlug(it.attributesText ?? it.browseUrl, `${it.title} ${it.attributesText ?? ''}`, vertical);
      if (!categorySlug) continue;
      const currency = it.prices.USD ? 'USD' : Object.keys(it.prices)[0] ?? null;
      const price = currency ? it.prices[currency]! : null;
      const { year, decade } = yearOrDecade(`${it.title} ${it.attributesText ?? ''}`);
      const period = it.attributesText?.match(/\b(1[5-9]th Century|20th Century|21st Century|Antique|Vintage|Mid-Century Modern|Art Deco|Art Nouveau|Victorian|Georgian|Regency|Louis X[VI]+|Bauhaus|Scandinavian Modern|Hollywood Regency|Brutalist|Space Age|Postmodern|Memphis)\b/i)?.[0] ?? null;
      const attributes = AssetAttributesSchema.parse({
        categorySlug,
        brand: it.creators[0] ?? null,
        name: it.title,
        year,
        material: it.materials,
        size: it.measurement,
        country: null,
        identifiers: { firstdibs_item_id: it.serviceId, ...(it.seller.serviceId ? { firstdibs_seller_id: it.seller.serviceId } : {}) },
        metadata: { decade, period, creators: it.creators, attributes_text: it.attributesText, category_code: it.categoryCode, browse_url: it.browseUrl, vertical: it.vertical, converted_prices: it.prices, amount_type: it.amountType, item_country: it.country, is_new_listing: it.isNewListing },
      });
      out.push(
        NormalizedListingSchema.parse({
          kind: 'listing',
          connectorId: this.meta.id,
          sourceId: this.meta.sourceId,
          sourceUrl: it.url,
          externalId: it.serviceId,
          rawTitle: it.title,
          description: it.description,
          imageUrls: it.images,
          attributes,
          grade: { grader: null, grade: null, qualifier: null, certificationNumber: null },
          condition: { condition: null, conditionRaw: null, completeness: null },
          observedAt: raw.fetchedAt,
          confidence: price ? 0.82 : 0.6,
          parserVersion: PARSER_VERSION,
          listingType: 'fixed_price',
          price,
          currency,
          seller: it.seller.company,
          location: it.location ?? it.country,
          availability: it.isSold ? 'sold' : it.isOnHold || it.isUnavailable ? 'ended' : 'available',
        }),
      );
    }
    return out;
  }
}

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