import { z } from 'zod';
import { BaseConnector, type ConnectorMeta, type CrawlContext, type RawRecordInput, type RawRecordLike } from '@rareindex/connectors';
import type { CurrencyCode, NormalizedRecord } from '@rareindex/shared';
import { amount, apolloRef, certFromTitle, hibidApolloState, isBundleTitle, isoDate, lotAttributes, makeSale, safeYear, saleGrade } from '../_g7-auctions-na-lib/index.js';
import { hibidCategory, isFirearm } from './categories.js';

const BASE = 'https://hibid.com';
const PARSER_VERSION = '1.0.0';
const PAST_PAGE_LENGTH = 25;
const ALLOWED_CURRENCIES = new Set<CurrencyCode>(['USD', 'CAD', 'GBP', 'EUR', 'AUD']);

export const AuctioneerSchema = z.object({ id: z.string().nullable(), name: z.string(), city: z.string().nullable(), state: z.string().nullable(), country: z.string().nullable() });
export const AuctionSchema = z.object({
  id: z.string(),
  eventName: z.string(),
  url: z.string(),
  bidCloseDateTime: z.string().nullable(),
  eventDateEnd: z.string().nullable(),
  currency: z.string().nullable(),
  buyerPremium: z.string().nullable(),
  buyerPremiumRate: z.number().nullable(),
  auctioneer: AuctioneerSchema,
});
export const LotSchema = z.object({
  id: z.string(),
  lotNumber: z.string().nullable(),
  title: z.string(),
  description: z.string().nullable(),
  estimateText: z.string().nullable(),
  image: z.string().nullable(),
  categoryPath: z.string().nullable(),
  categoryName: z.string().nullable(),
  priceRealized: z.number().nullable(),
  quantitySold: z.number().nullable(),
  quantity: z.number().nullable(),
  bidCount: z.number().nullable(),
  isClosed: z.boolean(),
  url: z.string(),
});
export const PayloadSchema = z.object({ kind: z.literal('hibid_catalog_page'), auction: AuctionSchema, page: z.number(), totalCount: z.number().nullable(), lots: z.array(LotSchema) });
export type Payload = z.infer<typeof PayloadSchema>;
export type ParsedLot = z.infer<typeof LotSchema> & { mappable: boolean };

type Cache = Record<string, Record<string, unknown>>;

export function slugify(s: string): string {
  return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 90);
}

function str(v: unknown): string | null {
  return typeof v === 'string' && v.trim() ? v.trim() : null;
}

function rootEntries(cache: Cache, prefix: string): Array<Record<string, unknown>> {
  const root = cache['ROOT_QUERY'] ?? {};
  return Object.entries(root)
    .filter(([k]) => k.startsWith(prefix))
    .map(([, v]) => apolloRef<Record<string, unknown>>(cache, v))
    .filter((v): v is Record<string, unknown> => v !== null);
}

export interface PastAuctionRef {
  id: string;
  eventName: string;
  url: string;
  bidCloseDateTime: string | null;
  eventDateEnd: string | null;
  lotCount: number | null;
  status: string | null;
}

/** /auctions/past?apage=N → archived auction references + paging. */
export function parsePastAuctions(html: string): { auctions: PastAuctionRef[]; pageNumber: number | null; totalCount: number | null; pageLength: number | null } | null {
  const cache = hibidApolloState(html);
  if (!cache) return null;
  const search = rootEntries(cache, 'auctionSearch(')[0];
  const paged = search ? apolloRef<Record<string, unknown>>(cache, search.pagedResults) : null;
  const results = Array.isArray(paged?.results) ? (paged!.results as unknown[]) : [];
  const auctions: PastAuctionRef[] = [];
  for (const r of results) {
    const match = apolloRef<Record<string, unknown>>(cache, r);
    const a = apolloRef<Record<string, unknown>>(cache, match?.auction ?? match);
    if (!a || typeof a.id !== 'number') continue;
    const name = str(a.eventName) ?? `Auction ${a.id}`;
    const state = apolloRef<Record<string, unknown>>(cache, a.auctionState);
    auctions.push({ id: String(a.id), eventName: name, url: `${BASE}/catalog/${a.id}/${slugify(name)}`, bidCloseDateTime: str(a.bidCloseDateTime), eventDateEnd: str(a.eventDateEnd), lotCount: typeof a.lotCount === 'number' ? a.lotCount : null, status: str(state?.auctionStatus) });
  }
  return { auctions, pageNumber: typeof paged?.pageNumber === 'number' ? paged.pageNumber : null, totalCount: typeof paged?.totalCount === 'number' ? paged.totalCount : null, pageLength: typeof paged?.pageLength === 'number' ? paged.pageLength : null };
}

/** /catalog/<id>/<slug>?apage=N → auction header + every lot on the page (with a `mappable` flag). */
export function parseCatalog(html: string, page: number): { auction: Payload['auction']; lots: ParsedLot[]; pageNumber: number | null; totalCount: number | null; pageLength: number | null } | null {
  const cache = hibidApolloState(html);
  if (!cache) return null;
  const auctionRaw = rootEntries(cache, 'auction(')[0] ?? Object.entries(cache).find(([k]) => k.startsWith('Auction:'))?.[1] ?? null;
  if (!auctionRaw || typeof auctionRaw.id !== 'number') return null;
  const auctioneer = apolloRef<Record<string, unknown>>(cache, auctionRaw.auctioneer);
  const name = str(auctionRaw.eventName) ?? `Auction ${auctionRaw.id}`;
  const auction: Payload['auction'] = {
    id: String(auctionRaw.id),
    eventName: name,
    url: `${BASE}/catalog/${auctionRaw.id}/${slugify(name)}`,
    bidCloseDateTime: str(auctionRaw.bidCloseDateTime),
    eventDateEnd: str(auctionRaw.eventDateEnd),
    currency: str(auctionRaw.currencyAbbreviation),
    buyerPremium: str(auctionRaw.buyerPremium),
    buyerPremiumRate: typeof auctionRaw.buyerPremiumRate === 'number' ? auctionRaw.buyerPremiumRate : null,
    auctioneer: { id: auctioneer && auctioneer.id !== undefined ? String(auctioneer.id) : null, name: str(auctioneer?.name) ?? 'HiBid auctioneer', city: str(auctioneer?.city), state: str(auctioneer?.state), country: str(auctioneer?.country) },
  };
  const search = rootEntries(cache, 'lotSearch(')[0];
  const paged = search ? apolloRef<Record<string, unknown>>(cache, search.pagedResults) : null;
  const refs = Array.isArray(paged?.results) ? (paged!.results as unknown[]) : Object.keys(cache).filter((k) => k.startsWith('Lot:')).map((k) => ({ __ref: k }));
  const lots: ParsedLot[] = [];
  const seen = new Set<string>();
  for (const r of refs) {
    const l = apolloRef<Record<string, unknown>>(cache, r);
    if (!l || typeof l.id !== 'number' || seen.has(String(l.id))) continue;
    seen.add(String(l.id));
    const title = str(l.lead) ?? str((apolloRef<Record<string, unknown>>(cache, l.featuredPicture) ?? {}).description);
    if (!title) continue;
    const state = apolloRef<Record<string, unknown>>(cache, l.lotState) ?? {};
    const cats = (Array.isArray(l.category) ? l.category : []).map((c) => apolloRef<Record<string, unknown>>(cache, c)).filter((c): c is Record<string, unknown> => c !== null);
    // Most specific category first (longest fullCategory path).
    cats.sort((a, b) => String(b.fullCategory ?? '').length - String(a.fullCategory ?? '').length);
    const categoryPath = str(cats[0]?.fullCategory);
    const categoryName = str(cats[0]?.categoryName);
    const picture = apolloRef<Record<string, unknown>>(cache, l.featuredPicture);
    const description = str(l.description);
    const slug = hibidCategory(categoryPath, title);
    const mappable = slug !== null && !isFirearm(`${categoryPath ?? ''} ${title} ${description ?? ''}`);
    lots.push({
      id: String(l.id),
      lotNumber: str(l.lotNumber),
      title,
      description: description ? description.slice(0, 1500) : null,
      estimateText: str(l.estimate),
      image: str(picture?.fullSizeLocation) ?? str(picture?.hdThumbnailLocation),
      categoryPath,
      categoryName,
      priceRealized: amount(state.priceRealized),
      quantitySold: typeof state.quantitySold === 'number' ? state.quantitySold : null,
      quantity: typeof l.quantity === 'number' ? l.quantity : null,
      bidCount: typeof state.bidCount === 'number' ? state.bidCount : null,
      isClosed: state.isClosed === true || state.isArchived === true,
      url: `${BASE}/lot/${l.id}/${slugify(title)}`,
      mappable,
    });
  }
  return { auction, lots, pageNumber: typeof paged?.pageNumber === 'number' ? paged.pageNumber : null, totalCount: typeof paged?.totalCount === 'number' ? paged.totalCount : null, pageLength: typeof paged?.pageLength === 'number' ? paged.pageLength : null };
}

/**
 * HiBid — public past catalogs of thousands of regional auctioneers. Plain HTTPS on hibid.com; the lot
 * data is read from the Apollo state the public Angular page embeds (`<script id="hibid-state">`).
 * Sales = closed lots whose auctioneer publishes the price realized (hammer; premium charged separately).
 */
export class HibidConnector extends BaseConnector {
  readonly version = '1.0.0';
  readonly parserVersion = PARSER_VERSION;
  protected override minIntervalMs = 3000;

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

  async *crawl(ctx: CrawlContext): AsyncIterable<RawRecordInput> {
    const cfg = this.meta.config;
    const mode = ctx.options.mode;
    const pastPagesPerRun = mode === 'probe' ? 1 : Number(cfg.pastPagesPerRun ?? 3);
    const auctionsPerRun = mode === 'probe' ? 3 : Number(cfg.auctionsPerRun ?? 6);
    const pagesPerAuction = mode === 'probe' ? 1 : Number(cfg.pagesPerAuction ?? 10);
    const cursor = ctx.options.cursor ?? {};
    const doneAuctions = new Set<number>(Array.isArray(cursor.doneAuctions) ? (cursor.doneAuctions as number[]) : []);
    let pastPage = mode === 'backfill' ? Number(cursor.pastPage ?? 1) : 1;
    let filtered = 0;
    let rawCount = 0;
    let items = 0;

    // Seeds (catalog URLs) or the past-auction list decide which catalogs to visit.
    const seeds = (ctx.options.seeds ?? []).map((s) => s.match(/\/catalog\/(\d+)/)?.[1]).filter((x): x is string => Boolean(x));
    const queue: PastAuctionRef[] = seeds.map((id) => ({ id, eventName: `Auction ${id}`, url: `${BASE}/catalog/${id}/x`, bidCloseDateTime: null, eventDateEnd: null, lotCount: null, status: null }));
    let totalPastPages: number | null = null;
    if (!seeds.length) {
      for (let i = 0; i < pastPagesPerRun; i++) {
        if (ctx.signal?.aborted) break;
        const url = `${BASE}/auctions/past${pastPage > 1 ? `?apage=${pastPage}` : ''}`;
        let r = await this.html(ctx, url);
        if (!r.html) break;
        let list = parsePastAuctions(r.html);
        if (list && list.auctions.length === 0 && list.pageNumber === null) {
          // The server occasionally renders the shell before the auction search resolves → one retry.
          ctx.log.warn({ url }, 'past-auction list rendered without results; retrying once');
          r = await this.html(ctx, `${url}${url.includes('?') ? '&' : '?'}apage=${pastPage}`);
          if (r.html) list = parsePastAuctions(r.html);
        }
        if (!list) {
          ctx.anomaly('parse_failure_page', `${url}: no hibid-state`);
          break;
        }
        if (list.totalCount !== null) totalPastPages = Math.max(1, Math.ceil(list.totalCount / (list.pageLength ?? PAST_PAGE_LENGTH)));
        if (list.auctions.length === 0) ctx.anomaly('pagination_failure', `${url}: past-auction list rendered without results (pageNumber ${list.pageNumber}, total ${list.totalCount})`);
        const fresh = list.auctions.filter((a) => !doneAuctions.has(Number(a.id)) && (a.status === null || a.status === 'ARCHIVED'));
        queue.push(...fresh);
        if (list.auctions.length === 0 || (totalPastPages !== null && pastPage >= totalPastPages)) {
          if (mode === 'backfill' && totalPastPages !== null && pastPage >= totalPastPages) {
            await ctx.setCursor({ doneAuctions: [...doneAuctions].slice(-3000), pastPage, done: true, updatedAt: new Date().toISOString() });
            pastPage = totalPastPages;
          }
          break;
        }
        pastPage++;
        if (queue.length >= auctionsPerRun) break;
      }
    }

    let processed = 0;
    for (const a of queue) {
      if (ctx.signal?.aborted || processed >= auctionsPerRun || this.reached(ctx, rawCount)) break;
      processed++;
      const idNum = Number(a.id);
      for (let page = 1; page <= pagesPerAuction; page++) {
        if (ctx.signal?.aborted || this.reached(ctx, rawCount)) break;
        const url = `${a.url}${page > 1 ? `?apage=${page}` : ''}`;
        const r = await this.html(ctx, url);
        if (!r.html) break;
        const cat = parseCatalog(r.html, page);
        if (!cat) {
          ctx.anomaly('parse_failure_page', `${url}: no catalog state`);
          break;
        }
        if (cat.lots.length === 0) break;
        const mappable = cat.lots.filter((l) => l.mappable);
        filtered += cat.lots.length - mappable.length;
        if (page === 1 && mappable.length === 0) {
          doneAuctions.add(idNum); // non-collectible sale (equipment, real estate, household…) — skip the rest
          break;
        }
        if (mappable.length) {
          const payload: Payload = { kind: 'hibid_catalog_page', auction: cat.auction, page, totalCount: cat.totalCount, lots: mappable.map(({ mappable: _m, ...rest }) => rest) };
          rawCount++;
          items += mappable.length;
          yield { url, externalId: `catalog:${a.id}:page:${page}`, kind: 'sale', engine: 'api', httpStatus: r.status, payload, fetchedAt: r.fetchedAt };
        }
        const pageLength = cat.pageLength ?? 100;
        if (cat.totalCount !== null && page * pageLength >= cat.totalCount) {
          doneAuctions.add(idNum);
          break;
        }
        if (page === pagesPerAuction) doneAuctions.add(idNum);
      }
      await ctx.setCursor({ doneAuctions: [...doneAuctions].slice(-3000), pastPage, updatedAt: new Date().toISOString() });
      await ctx.progress({ page: pastPage, totalPages: totalPastPages, itemsProcessed: items, cursor: { doneAuctions: [...doneAuctions].slice(-3000), pastPage } });
    }
    if (filtered) ctx.anomaly('filtered_non_collectible', `${filtered} lots outside the collectibles taxonomy skipped`);
    if (!seeds.length) await ctx.setCursor({ doneAuctions: [...doneAuctions].slice(-3000), pastPage, updatedAt: new Date().toISOString(), ...(mode === 'backfill' && totalPastPages !== null && pastPage >= totalPastPages ? { done: true } : {}) });
  }

  async normalize(raw: RawRecordLike): Promise<NormalizedRecord[]> {
    const p = PayloadSchema.parse(raw.payload);
    const out: NormalizedRecord[] = [];
    const currency = p.auction.currency as CurrencyCode | null;
    if (!currency || !ALLOWED_CURRENCIES.has(currency)) return out;
    const saleDate = isoDate(p.auction.bidCloseDateTime) ?? isoDate(p.auction.eventDateEnd);
    if (!saleDate || saleDate.getTime() > Date.now() + 86_400_000) return out;
    const house = `${p.auction.auctioneer.name} (HiBid)`;
    const location = [p.auction.auctioneer.city, p.auction.auctioneer.state, p.auction.auctioneer.country].filter(Boolean).join(', ') || null;
    for (const l of p.lots) {
      if (!l.isClosed || !l.priceRealized) continue;
      const slug = hibidCategory(l.categoryPath, l.title);
      if (!slug || isFirearm(`${l.categoryPath ?? ''} ${l.title} ${l.description ?? ''}`)) continue;
      const g = saleGrade(l.title);
      const attributes = lotAttributes({
        categorySlug: slug,
        name: l.title,
        year: safeYear(l.title),
        identifiers: { hibid_lot_id: l.id, hibid_auction_id: p.auction.id },
        metadata: { auction_id: p.auction.id, event_name: p.auction.eventName, auctioneer_id: p.auction.auctioneer.id, estimate_text: l.estimateText, category_path: l.categoryPath, bid_count: l.bidCount, buyer_premium_text: p.auction.buyerPremium, buyer_premium_rate: p.auction.buyerPremiumRate, quantity_sold: l.quantitySold },
      });
      const sale = makeSale({ meta: this.meta, sourceUrl: l.url, externalId: l.id, rawTitle: l.title, description: l.description, attributes, price: l.priceRealized, currency, saleDate, buyerPremiumIncluded: false, auctionHouse: house, lotNumber: l.lotNumber, imageUrls: l.image ? [l.image] : [], location, observedAt: raw.fetchedAt, parserVersion: PARSER_VERSION, grader: g.grader, grade: g.grade, isBundle: isBundleTitle(l.title) || (l.quantity ?? 1) > 1, confidence: g.grader ? 0.8 : 0.7 });
      sale.grade.qualifier = g.qualifier;
      sale.grade.certificationNumber = certFromTitle(l.title);
      sale.quantity = Math.max(1, l.quantitySold ?? l.quantity ?? 1);
      out.push(sale);
    }
    return out;
  }
}

export default (meta: ConnectorMeta) => new HibidConnector(meta);