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

/**
 * Sotheby's — results (price incl. premium) and upcoming lots from the public auction pages and the
 * page's own GraphQL lot-card pagination. Engine: plain HTTPS (+ Firecrawl for link discovery).
 */

const SITE = 'https://www.sothebys.com';
const GRAPHQL = 'https://clientapi.prod.sothelabs.com/graphql';

export const AuctionSchema = z.object({
  auctionId: z.string(),
  url: z.string(),
  title: z.string(),
  saleNumber: z.string().nullable(),
  state: z.string().nullable(), // Opened | Closed | Published…
  type: z.string().nullable(), // Timed | Live
  departments: z.array(z.string()),
  currency: z.string().nullable(),
  location: z.string().nullable(),
  startsAt: z.string().nullable(),
  endsAt: z.string().nullable(),
  closedAt: z.string().nullable(),
  totalLots: z.number().nullable(),
});
export type Auction = z.infer<typeof AuctionSchema>;

export const LotSchema = z.object({
  lotId: z.string(),
  lotNumber: z.string().nullable(),
  title: z.string(),
  creators: z.string().nullable(),
  slug: z.string().nullable(),
  estimateLow: z.number().nullable(),
  estimateHigh: z.number().nullable(),
  isClosed: z.boolean().nullable(),
  closingTime: z.string().nullable(),
  currentBid: z.number().nullable(),
  bidCurrency: z.string().nullable(),
  isSold: z.boolean().nullable(),
  finalPrice: z.number().nullable(),
  finalCurrency: z.string().nullable(),
  numberOfBids: z.number().nullable(),
  imageUrl: z.string().nullable(),
  withdrawn: z.boolean(),
});
export type Lot = z.infer<typeof LotSchema>;

export const PagePayloadSchema = z.object({
  kind: z.literal('auction_page'),
  auction: AuctionSchema,
  offset: z.number().int(),
  lots: z.array(LotSchema),
});
export type PagePayload = z.infer<typeof PagePayloadSchema>;

const ConfigSchema = z.object({
  seeds: z.array(z.string()).default([]),
  discoveryPages: z.array(z.string()).default([]),
  departments: z.array(z.string()).default([]),
  maxAuctionsPerRun: z.number().int().default(25),
  pageSize: z.number().int().min(1).max(48).default(48),
});

const LOT_QUERY = `query LotCardsFilterByPaginated($id: String!, $limit: Int, $offset: Int) {
  auction(id: $id, language: ENGLISH) {
    id
    lotCards: lotCardsConnection(offset: $offset, limit: $limit, filter: ALL) {
      totalCount
      hasNextPage
      lots {
        lotId
        title
        creatorsDisplayTitle
        lotNumber { ... on VisibleLotNumber { lotDisplayNumber } }
        slug { lotSlug }
        withdrawnState { state }
        estimateV2 { ... on LowHighEstimateV2 { lowEstimate { amount } highEstimate { amount } } }
        bidState {
          isClosed
          closingTime
          numberOfBids
          currentBidV2 { amount currency }
          sold { __typename ... on ResultVisible { isSold premiums { finalPriceV2 { amount currency } } } }
        }
        media(imageSizes: [Small]) { images { renditions { url } } }
      }
    }
  }
}`;

function num(v: unknown): number | null {
  if (v === null || v === undefined || v === '') return null;
  const n = typeof v === 'number' ? v : Number.parseFloat(String(v));
  return Number.isFinite(n) ? n : null;
}

/** Build a Lot from a GraphQL lot card or from the SSR Apollo cache (refs resolved by caller). */
function lotFrom(card: Record<string, any>, bidState: Record<string, any> | null): Lot {
  const est = card.estimateV2 ?? {};
  const sold = bidState?.sold ?? {};
  const fp = sold.premiums?.finalPriceV2 ?? null;
  const cb = bidState?.currentBidV2 ?? null;
  const mediaKey = Object.keys(card).find((k) => k.startsWith('media'));
  const img = mediaKey ? card[mediaKey]?.images?.[0]?.renditions?.[0]?.url ?? null : null;
  return LotSchema.parse({
    lotId: String(card.lotId),
    lotNumber: card.lotNumber?.lotDisplayNumber ?? null,
    title: String(card.title ?? ''),
    creators: card.creatorsDisplayTitle ?? null,
    slug: card.slug?.lotSlug ?? null,
    estimateLow: num(est.lowEstimate?.amount),
    estimateHigh: num(est.highEstimate?.amount),
    isClosed: typeof bidState?.isClosed === 'boolean' ? bidState.isClosed : null,
    closingTime: bidState?.closingTime ?? null,
    currentBid: num(cb?.amount),
    bidCurrency: cb?.currency ?? null,
    isSold: typeof sold.isSold === 'boolean' ? sold.isSold : null,
    finalPrice: num(fp?.amount),
    finalCurrency: fp?.currency ?? null,
    numberOfBids: num(bidState?.numberOfBids),
    imageUrl: typeof img === 'string' ? img : null,
    withdrawn: card.withdrawnState?.state ? card.withdrawnState.state !== 'NotAffected' : false,
  });
}

/** Parse an SSR auction page: auction + first lot cards from the Apollo cache. */
export function parseAuctionPage(html: string, url: string): { auction: Auction; lots: Lot[] } | null {
  const m = html.match(/<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/);
  if (!m) return null;
  let cache: Record<string, any>;
  let pp: Record<string, any>;
  try {
    pp = (JSON.parse(m[1]!) as { props: { pageProps: Record<string, any> } }).props.pageProps;
    cache = pp.apolloCache ?? {};
  } catch {
    return null;
  }
  const aKey = Object.keys(cache).find((k) => k.startsWith('Auction:'));
  if (!aKey) return null;
  const a = cache[aKey];
  const dates = a.dates ?? {};
  const cards = Object.keys(cache)
    .filter((k) => k.startsWith('LotCard:'))
    .map((k) => cache[k])
    .filter((c) => !c.auction || c.auction.auctionId === a.auctionId || c.auction.sapSaleNumber === a.sapSaleNumber);
  const lots = cards.map((c) => lotFrom(c, c.bidState?.__ref ? cache[c.bidState.__ref] ?? null : c.bidState ?? null));
  const currency = a.currencyV2 ?? a.currency ?? cards[0]?.auction?.currency ?? lots.find((l) => l.finalCurrency)?.finalCurrency ?? null;
  const auction = AuctionSchema.parse({
    auctionId: String(a.auctionId),
    url,
    title: String(a.title ?? ''),
    saleNumber: a.sapSaleNumber ?? null,
    state: a.state ?? null,
    type: a.type ?? null,
    departments: Array.isArray(a.departmentNames) ? a.departmentNames.map((d: string) => d.trim()) : [],
    currency,
    location: a.locationV2?.name ?? null,
    startsAt: dates.goesLive ?? dates.acceptsBids ?? null,
    endsAt: dates.startsToClose ?? dates.goesLive ?? null,
    closedAt: dates.closed ?? null,
    totalLots: num(pp.totalLotCount),
  });
  return { auction, lots };
}

export function parseGraphqlLots(json: any): { lots: Lot[]; hasNextPage: boolean; totalCount: number | null } | null {
  const conn = json?.data?.auction?.lotCards;
  if (!conn) return null;
  return { lots: (conn.lots ?? []).map((c: Record<string, any>) => lotFrom(c, c.bidState ?? null)), hasNextPage: Boolean(conn.hasNextPage), totalCount: num(conn.totalCount) };
}

export function auctionLinks(html: string): string[] {
  return [...new Set([...html.matchAll(/https?:\/\/www\.sothebys\.com\/en\/buy\/auction\/(20\d{2})\/([a-z0-9-]+)/g)].map((m) => `${SITE}/en/buy/auction/${m[1]}/${m[2]}`))];
}

export function lotUrl(auctionUrl: string, lotSlug: string | null, lotId: string): string {
  return lotSlug ? `${auctionUrl}/${lotSlug}` : `${auctionUrl}?lotId=${lotId}`;
}

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

/** Ordered hints for an auction: a single-department sale is a strong hint; a mixed "Arcade"-style sale is not. */
export function hintsForAuction(a: Auction): DeptHint[] {
  const hints = a.departments.map((d) => hintFromLabel(d)).filter((h) => h !== 'unknown');
  const titleHint = hintFromLabel(a.title);
  // Mixed multi-department sales (e.g. "Arcade"): only title keywords are trusted; no department guess.
  if (a.departments.length > 3) return ['unknown', ...(titleHint !== 'unknown' ? [titleHint] : [])];
  return [...(hints.length ? hints : []), ...(titleHint !== 'unknown' ? [titleHint] : []), 'unknown'];
}

export function classifyTitle(title: string, hints: DeptHint[]): string | null {
  for (const h of hints) {
    const slug = slugFromTitle(title, h);
    if (slug) return slug;
  }
  return null;
}

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

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

export class SothebysConnector extends BaseConnector {
  readonly version = '1.0.0';
  readonly parserVersion = '1.0.0';
  override readonly urlPatterns = [/^https?:\/\/(www\.)?sothebys\.com\/en\/buy\/auction\/20\d{2}\/[a-z0-9-]+/i];
  protected override minIntervalMs = 1500;
  private readonly config = ConfigSchema.parse(this.meta.config ?? {});

  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;
  }

  private async graphql(ctx: CrawlContext, auctionId: string, offset: number): Promise<ReturnType<typeof parseGraphqlLots>> {
    await this.throttle();
    const res = await ctx.fetch(GRAPHQL, {
      engines: ['api'],
      method: 'POST',
      body: { operationName: 'LotCardsFilterByPaginated', query: LOT_QUERY, variables: { id: auctionId, limit: this.config.pageSize, offset } },
      headers: { origin: SITE, referer: `${SITE}/`, accept: 'application/json' },
      responseType: 'json',
      minQuality: 0,
    });
    if (!res.success || !res.json) {
      ctx.anomaly('page_fetch_failed', `graphql ${auctionId}@${offset}: ${res.error ?? res.httpStatus}`);
      return null;
    }
    const parsed = parseGraphqlLots(res.json);
    if (!parsed) ctx.anomaly('parse_failure', `graphql ${auctionId}@${offset}: ${JSON.stringify((res.json as { errors?: unknown }).errors ?? '').slice(0, 200)}`);
    return parsed;
  }

  private async discover(ctx: CrawlContext): Promise<string[]> {
    const found = new Set<string>(this.config.seeds);
    for (const page of this.config.discoveryPages) {
      const res = await ctx.fetch(page, { engines: ['firecrawl'], waitForMs: 4000, minQuality: 0 });
      if (!res.success || !res.html) {
        ctx.anomaly('page_fetch_failed', `${page}: ${res.error ?? res.httpStatus}`);
        continue;
      }
      for (const u of auctionLinks(res.html)) found.add(u);
    }
    return [...found];
  }

  private async *crawlAuction(ctx: CrawlContext, url: string, probe: boolean): AsyncIterable<RawRecordInput> {
    const html = await this.page(ctx, url);
    if (!html) return;
    const parsed = parseAuctionPage(html, url);
    if (!parsed) {
      ctx.anomaly('parse_failure', `${url}: no Auction in __NEXT_DATA__`);
      return;
    }
    const a = parsed.auction;
    if (this.config.departments.length && !a.departments.some((d) => this.config.departments.includes(d))) return;
    const kind = a.state === 'Closed' ? 'sale' : 'auction_lot';
    const first: PagePayload = { kind: 'auction_page', auction: a, offset: 0, lots: parsed.lots };
    yield { url, externalId: `${a.auctionId}#0`, kind, engine: 'api', httpStatus: 200, payload: first, fetchedAt: new Date() };
    if (probe) return;
    let offset = parsed.lots.length;
    const total = a.totalLots ?? Infinity;
    for (let guard = 0; offset < total && guard < 60; guard++) {
      const gl = await this.graphql(ctx, a.auctionId, offset);
      if (!gl || !gl.lots.length) break;
      const payload: PagePayload = { kind: 'auction_page', auction: a, offset, lots: gl.lots };
      yield { url: `${url}#offset=${offset}`, externalId: `${a.auctionId}#${offset}`, kind, engine: 'api', httpStatus: 200, payload, fetchedAt: new Date() };
      offset += gl.lots.length;
      if (!gl.hasNextPage) break;
    }
  }

  async *crawl(ctx: CrawlContext): AsyncIterable<RawRecordInput> {
    const cursor = { auctions: {}, ...(ctx.options.cursor ?? {}) } as { auctions: Record<string, { state: string | null; checkedAt: string }> };
    const probe = ctx.options.mode === 'probe';
    const urls = ctx.options.seeds?.length ? ctx.options.seeds : await this.discover(ctx);
    // Re-check auctions previously seen open (their results become visible after close).
    for (const [u, s] of Object.entries(cursor.auctions)) if (s.state !== 'Closed' && !urls.includes(u)) urls.push(u);
    let n = 0;
    for (const url of urls) {
      if (ctx.signal?.aborted) return;
      const prev = cursor.auctions[url];
      if (prev?.state === 'Closed' && ctx.options.mode !== 'backfill') continue;
      if (n++ >= (probe ? 1 : this.config.maxAuctionsPerRun)) break;
      let state: string | null = prev?.state ?? null;
      for await (const raw of this.crawlAuction(ctx, url, probe)) {
        state = (raw.payload as PagePayload).auction.state;
        yield raw;
      }
      cursor.auctions[url] = { state, checkedAt: new Date().toISOString() };
      const entries = Object.entries(cursor.auctions);
      if (entries.length > 400) cursor.auctions = Object.fromEntries(entries.slice(-400));
      await ctx.setCursor(cursor);
    }
  }

  async lookup(url: string, ctx: CrawlContext): Promise<RawRecordInput[]> {
    const m = url.match(/^(https?:\/\/(?:www\.)?sothebys\.com\/en\/buy\/auction\/20\d{2}\/[a-z0-9-]+)(?:\/([a-z0-9-]+))?/i);
    if (!m) return [];
    const out: RawRecordInput[] = [];
    for await (const raw of this.crawlAuction(ctx, m[1]!, true)) {
      if (m[2]) {
        const p = raw.payload as PagePayload;
        p.lots = p.lots.filter((l) => l.slug === m[2]);
      }
      out.push(raw);
    }
    return out;
  }

  async normalize(raw: RawRecordLike): Promise<NormalizedRecord[]> {
    const page = PagePayloadSchema.parse(raw.payload);
    const a = page.auction;
    const hints = hintsForAuction(a);
    const out: NormalizedRecord[] = [];
    for (const lot of page.lots) {
      if (lot.withdrawn) continue;
      const title = lot.creators && !lot.title.toLowerCase().includes(lot.creators.toLowerCase()) ? `${lot.creators} — ${lot.title}` : lot.title;
      const categorySlug = classifyTitle(title, hints);
      if (!categorySlug) continue;
      const cur = currency(lot.finalCurrency ?? lot.bidCurrency ?? a.currency);
      if (!cur) continue;
      const grade = parseGradeFromTitle(title);
      const isWatch = ['rolex', 'patek_philippe', 'audemars_piguet', 'omega', 'other_watches'].includes(categorySlug);
      const reference = isWatch ? watchReference(title) : null;
      const identifiers: Record<string, string> = { sothebys_lot_id: lot.lotId };
      if (a.saleNumber) identifiers.sothebys_sale_number = a.saleNumber;
      if (reference) identifiers.reference = reference;
      if (categorySlug === 'lego_sets') {
        const n = legoSetNumber(title);
        if (n) identifiers.lego_set_number = n;
      }
      const base = {
        connectorId: this.meta.id,
        sourceId: this.meta.sourceId,
        sourceUrl: lotUrl(a.url, lot.slug, lot.lotId),
        externalId: lot.lotId,
        rawTitle: title,
        description: null,
        imageUrls: lot.imageUrl ? [lot.imageUrl] : [],
        attributes: {
          categorySlug,
          name: lot.title,
          brand: brandFromSlug(categorySlug, title) ?? (isWatch ? lot.creators : null),
          reference,
          year: safeYear(title),
          identifiers,
          metadata: { auction_id: a.auctionId, sale_number: a.saleNumber, auction_title: a.title, auction_type: a.type, departments: a.departments, estimate_low: lot.estimateLow, estimate_high: lot.estimateHigh, hammer_price: lot.currentBid, bids: lot.numberOfBids },
        },
        grade: { grader: grade.grader, grade: grade.grade, qualifier: grade.qualifier, certificationNumber: null },
        condition: {},
        observedAt: raw.fetchedAt,
        parserVersion: this.parserVersion,
      };
      const closed = a.state === 'Closed' || lot.isClosed === true;
      if (closed) {
        if (!lot.isSold || !lot.finalPrice || lot.finalPrice <= 0) continue;
        const saleDate = iso(lot.closingTime) ?? iso(a.closedAt) ?? iso(a.endsAt);
        if (!saleDate || saleDate.getTime() > Date.now() + 86_400_000) continue;
        out.push(
          NormalizedSaleSchema.parse({
            ...base,
            kind: 'sale',
            confidence: 0.9,
            saleType: 'auction',
            saleDate,
            price: lot.finalPrice,
            currency: cur,
            buyerPremiumIncluded: true,
            quantity: 1,
            isBundle: isBundleTitle(title),
            location: a.location,
            auctionHouse: "Sotheby's",
            lotNumber: lot.lotNumber,
          }),
        );
      } else {
        const startsAt = iso(a.startsAt);
        out.push(
          NormalizedAuctionLotSchema.parse({
            ...base,
            kind: 'auction_lot',
            confidence: 0.85,
            auctionHouse: "Sotheby's",
            auctionName: a.title,
            lotNumber: lot.lotNumber,
            startsAt,
            endsAt: iso(lot.closingTime) ?? iso(a.endsAt),
            estimateLow: lot.estimateLow,
            estimateHigh: lot.estimateHigh,
            currentBid: lot.currentBid,
            currency: cur,
            status: a.state === 'Opened' && startsAt && startsAt.getTime() <= Date.now() ? 'live' : 'upcoming',
            location: a.location,
          }),
        );
      }
    }
    return out;
  }
}