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

/**
 * Bonhams — realized prices + upcoming lots from the public, server-rendered Next.js pages.
 * Engine: plain HTTPS (no credits). See meta.json accessNotes.
 */

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

export const AuctionSummarySchema = z.object({
  id: z.string(),
  title: z.string(),
  slug: z.string(),
  status: z.string().nullable(),
  type: z.string().nullable(),
  departments: z.array(z.string()),
  categories: z.array(z.string()),
  currency: z.string().nullable(),
  country: z.string().nullable(),
  venue: z.string().nullable(),
  start: z.string().nullable(),
  end: z.string().nullable(),
  isEnded: z.boolean(),
  numberOfLots: z.number().nullable(),
});
export type AuctionSummary = z.infer<typeof AuctionSummarySchema>;

export const LotSchema = z.object({
  lotId: z.string(),
  lotUniqueId: z.string().nullable(),
  lotNo: z.string(),
  title: z.string(),
  heading: z.string().nullable(),
  slug: z.string().nullable(),
  imageUrl: z.string().nullable(),
  estimateLow: z.number().nullable(),
  estimateHigh: z.number().nullable(),
  hammerPrice: z.number().nullable(),
  hammerPremium: z.number().nullable(),
  startingBid: z.number().nullable(),
  currency: z.string().nullable(),
  status: z.string().nullable(),
  hammerTime: z.string().nullable(),
  endDate: z.string().nullable(),
  department: z.string().nullable(),
  categories: z.array(z.string()),
  isEnded: z.boolean(),
  isWithoutReserve: z.boolean().nullable(),
});
export type Lot = z.infer<typeof LotSchema>;

export const PagePayloadSchema = z.object({
  kind: z.literal('auction_lots'),
  auction: AuctionSummarySchema,
  page: z.number().int(),
  nbHits: z.number().nullable(),
  lots: z.array(LotSchema),
});
export type PagePayload = z.infer<typeof PagePayloadSchema>;

const ConfigSchema = z.object({
  departments: z.array(z.string()).default([]),
  maxResultsPages: z.number().int().min(1).default(20),
  maxAuctionsPerRun: z.number().int().min(1).default(40),
  upcomingAuctionsPerRun: z.number().int().min(0).default(12),
  lotsPerPage: z.number().int().default(48),
});

type NextData = { props?: { pageProps?: Record<string, unknown> } };

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

function str(v: unknown): string | null {
  return typeof v === 'string' && v.length ? v : v === null || v === undefined ? null : typeof v === 'number' ? String(v) : null;
}
function numOrNull(v: unknown): number | null {
  return typeof v === 'number' && Number.isFinite(v) ? v : null;
}

/** Summaries from a results/upcoming listing page (pagesOfAuctions) or from an auction page (auction + lots). */
export function parseAuctionList(html: string): { auctions: AuctionSummary[]; nbHits: number | null } {
  const nd = extractNextData(html);
  const pp = nd?.props?.pageProps ?? {};
  const pages = (pp.pagesOfAuctions as unknown[][] | undefined) ?? [];
  const auctions: AuctionSummary[] = [];
  for (const page of pages) {
    for (const a of page as Array<Record<string, any>>) {
      const dates = a.dates ?? {};
      auctions.push(
        AuctionSummarySchema.parse({
          id: String(a.id),
          title: a.auctionTitle ?? a.auctionHeading ?? '',
          slug: a.slug ?? '',
          status: str(a.auctionStatus),
          type: str(a.auctionType),
          departments: ((a.departments as Array<{ name?: string }> | undefined) ?? []).map((d) => d.name ?? '').filter(Boolean),
          categories: ((a.categories as Array<{ name?: string }> | undefined) ?? []).map((d) => d.name ?? '').filter(Boolean),
          currency: str(a.currency?.iso_code),
          country: str(a.country?.code),
          venue: str(a.venue ?? a.location?.name),
          start: str(dates.start?.datetime),
          end: str(dates.end?.datetime ?? a.hammerTime?.datetime),
          isEnded: Boolean(a.flags?.isAuctionEnded),
          numberOfLots: numOrNull(a.numberOfLots ?? a.number_of_lots),
        }),
      );
    }
  }
  return { auctions, nbHits: numOrNull(pp.nbHits) };
}

/** Lots + auction metadata from an auction page (or its _next/data JSON pageProps). */
export function parseAuctionPage(html: string, fallback?: Partial<AuctionSummary>): { auction: AuctionSummary; lots: Lot[]; nbHits: number | null } | null {
  const nd = extractNextData(html);
  const pp = nd?.props?.pageProps as Record<string, any> | undefined;
  if (!pp?.lotData) return null;
  const a = pp.auction ?? {};
  const rawLots = (pp.lotData.auctionLots as Array<Record<string, any>> | undefined) ?? [];
  const first = rawLots[0];
  const auction = AuctionSummarySchema.parse({
    id: String(first?.auctionId ?? fallback?.id ?? a.iSaleNo ?? ''),
    title: a.sSaleName ?? fallback?.title ?? '',
    slug: a.slug ?? fallback?.slug ?? '',
    status: str(first?.auctionStatus) ?? fallback?.status ?? null,
    type: str(first?.auctionType) ?? str(a.sSaleType) ?? fallback?.type ?? null,
    departments: ((a.departments as Array<{ sDepartmentName?: string }> | undefined) ?? []).map((d) => d.sDepartmentName ?? '').filter(Boolean),
    categories: fallback?.categories ?? [],
    currency: str(first?.currency?.iso_code) ?? fallback?.currency ?? null,
    country: str(first?.country?.code) ?? fallback?.country ?? null,
    venue: str(a.sVenue) ?? fallback?.venue ?? null,
    start: str(a.dates?.start?.[0]?.date?.datetime) ?? fallback?.start ?? null,
    end: str(a.dates?.end?.datetime) ?? str(first?.auctionEndDate?.datetime) ?? fallback?.end ?? null,
    isEnded: Boolean(first?.flags?.isAuctionEnded ?? fallback?.isEnded ?? false),
    numberOfLots: numOrNull(a.number_of_lots) ?? fallback?.numberOfLots ?? null,
  });
  const lots: Lot[] = rawLots.map((l) =>
    LotSchema.parse({
      lotId: String(l.lotId ?? l.id ?? ''),
      lotUniqueId: str(l.lotUniqueId),
      lotNo: String(l.lotNo?.full ?? l.lotNo?.number ?? l.lotId ?? ''),
      title: String(l.title ?? l.image?.caption ?? '').replace(/\s+/g, ' ').trim(),
      heading: str(l.heading) || null,
      slug: str(l.slug),
      imageUrl: str(l.image?.url),
      estimateLow: numOrNull(l.price?.estimateLow),
      estimateHigh: numOrNull(l.price?.estimateHigh),
      hammerPrice: numOrNull(l.price?.hammerPrice),
      hammerPremium: numOrNull(l.price?.hammerPremium),
      startingBid: numOrNull(l.price?.startingBidAmount),
      currency: str(l.currency?.iso_code),
      status: str(l.status),
      hammerTime: str(l.hammerTime?.datetime),
      endDate: str(l.auctionEndDate?.datetime),
      department: str(l.department?.name),
      categories: ((l.categories as Array<{ name?: string }> | undefined) ?? []).map((c) => c.name ?? '').filter(Boolean),
      isEnded: Boolean(l.flags?.isAuctionEnded),
      isWithoutReserve: typeof l.flags?.isWithoutReserve === 'boolean' ? l.flags.isWithoutReserve : null,
    }),
  );
  return { auction, lots, nbHits: numOrNull(pp.lotData.nbHits) };
}

export function lotUrl(auctionId: string, lotNo: string, slug: string | null): string {
  return `${SITE}/auction/${auctionId}/lot/${lotNo}/${slug ? `${slug}/` : ''}`;
}
export function auctionPageUrl(a: { id: string; slug: string }, page: number): string {
  return `${SITE}/auction/${a.id}/${a.slug}/${page > 1 ? `?page=${page}` : ''}`;
}

function currency(code: string | null | undefined): CurrencyCode | null {
  return code && (SUPPORTED_CURRENCIES as readonly string[]).includes(code) ? (code as CurrencyCode) : null;
}

function parseDate(s: string | null | undefined): Date | null {
  if (!s) return null;
  const d = new Date(s);
  return Number.isNaN(d.getTime()) ? null : d;
}

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

export class BonhamsConnector extends BaseConnector {
  readonly version = '1.0.0';
  readonly parserVersion = '1.0.0';
  override readonly urlPatterns = [/^https?:\/\/(www\.)?bonhams\.com\/auction\/\d+\//i];
  protected override minIntervalMs = 1500;
  private readonly config = ConfigSchema.parse(this.meta.config ?? {});

  private wanted(a: AuctionSummary): boolean {
    if (!this.config.departments.length) return true;
    return a.departments.some((d) => this.config.departments.includes(d));
  }

  private async page(ctx: CrawlContext, url: string): Promise<string | null> {
    await this.throttle();
    const res = await ctx.fetch(url, { engines: ['api'], responseType: 'text', minQuality: 0, headers: { accept: 'text/html' } });
    if (!res.success || !res.html) {
      ctx.anomaly('page_fetch_failed', `${url}: ${res.error ?? res.httpStatus}`);
      return null;
    }
    return res.html;
  }

  /** Iterate listing pages (results or upcoming) yielding whitelisted auctions until `stop` says so. */
  private async *listAuctions(ctx: CrawlContext, path: string, maxPages: number, stop: (a: AuctionSummary) => boolean): AsyncIterable<AuctionSummary> {
    for (let page = 1; page <= maxPages; page++) {
      const html = await this.page(ctx, `${SITE}${path}${page > 1 ? `?page=${page}` : ''}`);
      if (!html) return;
      const { auctions } = parseAuctionList(html);
      if (!auctions.length) {
        if (page === 1) ctx.anomaly('empty_page', `${path}: no auctions parsed (redesign?)`);
        return;
      }
      for (const a of auctions) {
        if (stop(a)) return;
        if (this.wanted(a)) yield a;
      }
    }
  }

  private async *crawlAuction(ctx: CrawlContext, a: AuctionSummary, kind: 'sale' | 'auction_lot', maxPages = 60): AsyncIterable<RawRecordInput> {
    for (let page = 1; page <= maxPages; page++) {
      const url = auctionPageUrl(a, page);
      const html = await this.page(ctx, url);
      if (!html) return;
      const parsed = parseAuctionPage(html, a);
      if (!parsed) {
        ctx.anomaly('parse_failure', `${url}: no lotData in __NEXT_DATA__`);
        return;
      }
      if (!parsed.lots.length) return;
      const payload: PagePayload = { kind: 'auction_lots', auction: { ...parsed.auction, categories: a.categories }, page, nbHits: parsed.nbHits, lots: parsed.lots };
      yield { url, externalId: `${a.id}#${page}`, kind, engine: 'api', httpStatus: 200, payload, fetchedAt: new Date() };
      if (parsed.nbHits !== null && page * this.config.lotsPerPage >= parsed.nbHits) return;
      if (ctx.signal?.aborted) return;
    }
  }

  async *crawl(ctx: CrawlContext): AsyncIterable<RawRecordInput> {
    const cursor = { ...(ctx.options.cursor ?? {}) } as { lastEnd?: string; done?: string[] };
    const done = new Set(cursor.done ?? []);
    const probe = ctx.options.mode === 'probe';
    const backfill = ctx.options.mode === 'backfill';
    const maxAuctions = probe ? 1 : this.config.maxAuctionsPerRun;
    let yielded = 0;
    let newestEnd: string | undefined = cursor.lastEnd;
    let count = 0;

    // 1. Past results (sold)
    const stop = (a: AuctionSummary) => !backfill && !!cursor.lastEnd && !!a.end && a.end < cursor.lastEnd && !probe;
    for await (const a of this.listAuctions(ctx, '/auctions/results/', probe ? 1 : this.config.maxResultsPages, stop)) {
      if (done.has(a.id)) continue;
      if (count >= maxAuctions) break;
      count++;
      for await (const raw of this.crawlAuction(ctx, a, 'sale', probe ? 1 : 60)) {
        yield raw;
        yielded += (raw.payload as PagePayload).lots.length;
        if (this.reached(ctx, yielded)) return;
      }
      done.add(a.id);
      if (a.end && (!newestEnd || a.end > newestEnd)) newestEnd = a.end;
      cursor.done = [...done].slice(-500);
      if (!backfill) cursor.lastEnd = newestEnd;
      await ctx.setCursor(cursor);
    }

    // 2. Upcoming / live lots for the auction calendar (incremental runs only)
    if (!probe && !backfill && this.config.upcomingAuctionsPerRun > 0) {
      let up = 0;
      for await (const a of this.listAuctions(ctx, '/auctions/upcoming/', 3, () => false)) {
        if (a.type === 'EXHIBITION') continue;
        if (up++ >= this.config.upcomingAuctionsPerRun) break;
        for await (const raw of this.crawlAuction(ctx, a, 'auction_lot', 10)) yield raw;
      }
    }
  }

  async lookup(url: string, ctx: CrawlContext): Promise<RawRecordInput[]> {
    const m = url.match(/\/auction\/(\d+)\/(?:lot\/(\d+[A-Za-z]?)\/)?([^/?#]*)/);
    if (!m) return [];
    const auctionId = m[1]!;
    const lotNo = m[2];
    // The auction page lists lots 48 at a time; find the page containing the lot number when given.
    const first = await this.page(ctx, `${SITE}/auction/${auctionId}/`);
    if (!first) return [];
    const parsed = parseAuctionPage(first);
    if (!parsed) return [];
    let lots = parsed.lots;
    if (lotNo && !lots.some((l) => l.lotNo === lotNo) && parsed.nbHits) {
      const pages = Math.ceil(parsed.nbHits / this.config.lotsPerPage);
      for (let p = 2; p <= pages; p++) {
        const html = await this.page(ctx, auctionPageUrl({ id: auctionId, slug: parsed.auction.slug }, p));
        const pg = html ? parseAuctionPage(html, parsed.auction) : null;
        if (pg?.lots.some((l) => l.lotNo === lotNo)) {
          lots = pg.lots;
          break;
        }
      }
    }
    if (lotNo) lots = lots.filter((l) => l.lotNo === lotNo);
    const payload: PagePayload = { kind: 'auction_lots', auction: parsed.auction, page: 0, nbHits: parsed.nbHits, lots };
    return [{ url, externalId: lotNo ? `${auctionId}-${lotNo}` : auctionId, kind: parsed.auction.isEnded ? 'sale' : 'auction_lot', engine: 'api', httpStatus: 200, payload, fetchedAt: new Date() }];
  }

  async normalize(raw: RawRecordLike): Promise<NormalizedRecord[]> {
    const page = PagePayloadSchema.parse(raw.payload);
    const out: NormalizedRecord[] = [];
    const a = page.auction;
    const observedAt = raw.fetchedAt;
    for (const lot of page.lots) {
      const dept = lot.department ?? a.departments[0] ?? null;
      // A lot's own department is authoritative; fall back to the sale's departments when the lot has none.
      if (this.config.departments.length && (dept ? !this.config.departments.includes(dept) : !a.departments.some((d) => this.config.departments.includes(d)))) continue;
      const hint = hintFromLabel(dept);
      const categorySlug = slugFromTitle(lot.title, hint);
      if (!categorySlug) continue; // unmapped department/title → skip rather than guess
      const cur = currency(lot.currency ?? a.currency);
      if (!cur) continue;
      const grade = parseGradeFromTitle(lot.title);
      const brand = brandFromSlug(categorySlug, lot.title);
      const reference = categorySlug.endsWith('watches') || ['rolex', 'patek_philippe', 'audemars_piguet', 'omega'].includes(categorySlug) ? watchReference(lot.title) : null;
      const identifiers: Record<string, string> = { bonhams_lot: `${a.id}-${lot.lotNo}` };
      if (lot.lotUniqueId) identifiers.bonhams_lot_unique_id = lot.lotUniqueId;
      if (reference) identifiers.reference = reference;
      if (categorySlug === 'lego_sets') {
        const n = legoSetNumber(lot.title);
        if (n) identifiers.lego_set_number = n;
      }
      const base = {
        connectorId: this.meta.id,
        sourceId: this.meta.sourceId,
        sourceUrl: lotUrl(a.id, lot.lotNo, lot.slug),
        externalId: `${a.id}-${lot.lotNo}`,
        rawTitle: lot.title,
        description: lot.heading,
        imageUrls: lot.imageUrl ? [lot.imageUrl] : [],
        attributes: {
          categorySlug,
          name: lot.title,
          brand,
          reference,
          year: safeYear(lot.title),
          country: a.country,
          identifiers,
          metadata: { department: dept, auction_id: a.id, auction_title: a.title, auction_type: a.type, venue: a.venue, estimate_low: lot.estimateLow, estimate_high: lot.estimateHigh, hammer_price: lot.hammerPrice, without_reserve: lot.isWithoutReserve },
        },
        grade: { grader: grade.grader, grade: grade.grade, qualifier: grade.qualifier, certificationNumber: null },
        condition: {},
        observedAt,
        parserVersion: this.parserVersion,
      };
      const saleDate = parseDate(lot.hammerTime ?? lot.endDate ?? a.end);
      const sold = lot.status === 'SOLD' && (lot.hammerPremium ?? lot.hammerPrice ?? 0) > 0;
      const endDate = parseDate(lot.endDate ?? a.end);
      const ended = sold || lot.isEnded || a.isEnded || lot.status === 'UNSOLD' || lot.status === 'WITHDRAWN' || (endDate !== null && endDate.getTime() < Date.now());
      if (ended) {
        // Only published results (status SOLD with a price) become sales; unsold/withdrawn lots are skipped.
        if (!sold || !saleDate || saleDate.getTime() > Date.now() + 86_400_000) continue;
        const price = lot.hammerPremium ?? lot.hammerPrice!;
        out.push(
          NormalizedSaleSchema.parse({
            ...base,
            kind: 'sale',
            confidence: 0.9,
            saleType: 'auction',
            saleDate,
            price,
            currency: cur,
            buyerPremiumIncluded: lot.hammerPremium !== null,
            quantity: 1,
            isBundle: isBundleTitle(lot.title),
            location: a.venue ?? a.country,
            auctionHouse: 'Bonhams',
            lotNumber: lot.lotNo,
          }),
        );
      } else {
        const endsAt = parseDate(lot.endDate ?? a.end);
        const startsAt = parseDate(a.start);
        const now = Date.now();
        const status = startsAt && startsAt.getTime() <= now ? 'live' : 'upcoming';
        out.push(
          NormalizedAuctionLotSchema.parse({
            ...base,
            kind: 'auction_lot',
            confidence: 0.85,
            auctionHouse: 'Bonhams',
            auctionName: a.title,
            lotNumber: lot.lotNo,
            startsAt,
            endsAt,
            estimateLow: lot.estimateLow,
            estimateHigh: lot.estimateHigh,
            currentBid: null,
            currency: cur,
            status,
            location: a.venue ?? a.country,
          }),
        );
      }
    }
    return out;
  }
}