Under the Hood

export const sites = pgTable(
  'sites',
  {
    id: serial('id').primaryKey(),
    sourceTab: text('source_tab').notNull(),
    name: text('name').notNull(),
    siteType: siteTypeEnum('site_type').notNull(),
    signatureLabel: text('signature_label').notNull(),
    wormholeClass: wormholeClassEnum('wormhole_class'),
    blueLootIsk: bigint('blue_loot_isk', { mode: 'number' }),
    iskPerEhp: integer('isk_per_ehp'),
    resourceValueIsk: bigint('resource_value_isk', { mode: 'number' }),
  },
  (t) => ({
    sourceNameUnique: uniqueIndex('sites_source_tab_name_unique').on(t.sourceTab, t.name),
  }),
);

// Wave aggregates are recomputed live in queries.ts via npc-stats.
export const waves = pgTable('waves', {
  id: serial('id').primaryKey(),
  siteId: integer('site_id').notNull().references(() => sites.id, { onDelete: 'cascade' }),
  waveNumber: integer('wave_number').notNull(),
  waveLabel: text('wave_label').notNull(),
});

// Per-NPC combat stats are computed live from raw EVE SDE attributes.
// `type_id` is the join key.
export const npcs = pgTable('npcs', {
  id: serial('id').primaryKey(),
  waveId: integer('wave_id').notNull().references(() => waves.id, { onDelete: 'cascade' }),
  orderInWave: integer('order_in_wave').notNull(),
  triggerLabel: text('trigger_label'),
  quantity: integer('quantity').notNull(),
  sleeperName: text('sleeper_name').notNull(),
  sleeperClassCode: text('sleeper_class_code').notNull(),
  typeId: integer('type_id').notNull(),
});

export const siteResources = pgTable('site_resources', {
  id: serial('id').primaryKey(),
  siteId: integer('site_id').notNull().references(() => sites.id, { onDelete: 'cascade' }),
  orderInSite: integer('order_in_site').notNull(),
  resourceKind: text('resource_kind').notNull(),
  resourceName: text('resource_name').notNull(),
  units: bigint('units', { mode: 'number' }),
  volumeM3: bigint('volume_m3', { mode: 'number' }),
  totalIsk: bigint('total_isk', { mode: 'number' }),
  typeId: integer('type_id'),
});

export const sites = pgTable(
  'sites',
  {
    id: serial('id').primaryKey(),
    sourceTab: text('source_tab').notNull(),
    name: text('name').notNull(),
    siteType: siteTypeEnum('site_type').notNull(),
    signatureLabel: text('signature_label').notNull(),
    wormholeClass: wormholeClassEnum('wormhole_class'),
    blueLootIsk: bigint('blue_loot_isk', { mode: 'number' }),
    iskPerEhp: integer('isk_per_ehp'),
    resourceValueIsk: bigint('resource_value_isk', { mode: 'number' }),
  },
  (t) => ({
    sourceNameUnique: uniqueIndex('sites_source_tab_name_unique').on(t.sourceTab, t.name),
  }),
);

// Wave aggregates are recomputed live in queries.ts via npc-stats.
export const waves = pgTable('waves', {
  id: serial('id').primaryKey(),
  siteId: integer('site_id').notNull().references(() => sites.id, { onDelete: 'cascade' }),
  waveNumber: integer('wave_number').notNull(),
  waveLabel: text('wave_label').notNull(),
});

// Per-NPC combat stats are computed live from raw EVE SDE attributes.
// `type_id` is the join key.
export const npcs = pgTable('npcs', {
  id: serial('id').primaryKey(),
  waveId: integer('wave_id').notNull().references(() => waves.id, { onDelete: 'cascade' }),
  orderInWave: integer('order_in_wave').notNull(),
  triggerLabel: text('trigger_label'),
  quantity: integer('quantity').notNull(),
  sleeperName: text('sleeper_name').notNull(),
  sleeperClassCode: text('sleeper_class_code').notNull(),
  typeId: integer('type_id').notNull(),
});

export const siteResources = pgTable('site_resources', {
  id: serial('id').primaryKey(),
  siteId: integer('site_id').notNull().references(() => sites.id, { onDelete: 'cascade' }),
  orderInSite: integer('order_in_site').notNull(),
  resourceKind: text('resource_kind').notNull(),
  resourceName: text('resource_name').notNull(),
  units: bigint('units', { mode: 'number' }),
  volumeM3: bigint('volume_m3', { mode: 'number' }),
  totalIsk: bigint('total_isk', { mode: 'number' }),
  typeId: integer('type_id'),
});

function mergeNpc(base: NpcRow, stats: CombatStats | undefined): Npc {
  const { waveId: _waveId, typeId: _typeId, ...rest } = base;
  if (!stats) {
    return {
      ...rest,
      scram: null, web: null, neut: null, rrep: null,
      sig: null, speed: null, distance: null, velocity: null,
      dps: null, alpha: null, ehp: null,
    };
  }
  return {
    ...rest,
    scram: stats.ewar.scram,
    web: stats.ewar.web !== 0 ? 1 : 0,
    neut: -stats.ewar.neutCount,
    rrep: stats.ewar.rrepCount,
    sig: stats.movement.sigRadius,
    speed: stats.movement.maxVelocity,
    distance: stats.movement.orbitDistance,
    velocity: stats.movement.orbitVelocity,
    dps: Math.round(stats.total.dps),
    alpha: Math.round(stats.total.alpha),
    ehp: Math.round(stats.hp.ehp),
  };
}

function aggregateWave(
  row: WaveRow,
  npcRows: NpcRow[],
  statsByType: Map<number, CombatStats>,
): Wave {
  const enriched: Npc[] = npcRows.map((n) => mergeNpc(n, statsByType.get(n.typeId)));
  const contributing = npcRows
    .map((n) => ({ stats: statsByType.get(n.typeId), quantity: n.quantity }))
    .filter((x): x is { stats: CombatStats; quantity: number } => x.stats !== undefined);
  const totals = summariseWave(contributing);

  return {
    id: row.id,
    waveNumber: row.waveNumber,
    waveLabel: row.waveLabel,
    dpsTotal: totals.dpsTotal,
    alphaTotal: totals.alphaTotal,
    ehpTotal: totals.ehpTotal,
    npcs: enriched,
  };
}

export async function listSiteDetails(filters: {
  type?: SiteType;
  wormholeClass?: WormholeClass;
}): Promise<SiteDetail[]> {
  // The catalogue is deploy-static. Live prices are layered on separately.
  'use cache';
  cacheLife('max');

  return withColdStartRetry(async () => {
    const allRows = await db.select(SITE_LIST_COLUMNS).from(sites);
    const siteRows = filters.wormholeClass
      ? allRows.filter((s) => matchesClass(s, filters.wormholeClass!))
      : allRows;

    const siteIds = siteRows.map((s) => s.id);
    const [waveRows, resourceRows] = await Promise.all([
      db.select({ id: waves.id, siteId: waves.siteId, waveNumber: waves.waveNumber, waveLabel: waves.waveLabel })
        .from(waves)
        .where(inArray(waves.siteId, siteIds)),
      db.select({
        id: siteResources.id,
        siteId: siteResources.siteId,
        resourceName: siteResources.resourceName,
        units: siteResources.units,
        volumeM3: siteResources.volumeM3,
        totalIsk: siteResources.totalIsk,
        typeId: siteResources.typeId,
      })
        .from(siteResources)
        .where(inArray(siteResources.siteId, siteIds)),
    ]);

    const npcRows = waveIds.length > 0
      ? await db.select({ typeId: npcs.typeId, waveId: npcs.waveId, quantity: npcs.quantity })
          .from(npcs)
          .where(inArray(npcs.waveId, waveIds))
      : [];

    const distinctTypeIds = [...new Set(npcRows.map((n) => n.typeId))];
    const statsByType = await getCombatStatsBatch(distinctTypeIds);

    return siteRows.map((site) => ({
      ...site,
      waves: wavesBySiteId.get(site.id) ?? [],
      resources: resourcesBySiteId.get(site.id) ?? [],
    }));
  });
}

// Class match accounts for ordinary classed sites and gas sites whose
// `wormhole_class` is NULL but whose name encodes a class range.
function matchesClass(
  s: Pick<SiteListItem, 'name' | 'siteType' | 'wormholeClass'>,
  cls: WormholeClass,
): boolean {
  if (s.wormholeClass === cls) return true;
  if (s.siteType === 'gas') {
    const range = gasClassRange(s.name);
    return range !== null && classRangeIncludes(range, cls);
  }
  return false;
}

export async function listSites(filters: {
  type?: SiteType;
  wormholeClass?: WormholeClass;
}): Promise<SiteListItem[]> {
  'use cache';
  cacheLife('max');
  const rows = await withColdStartRetry(() =>
    db.select(SITE_LIST_COLUMNS).from(sites).orderBy(sites.sourceTab, sites.name),
  );

  return filters.wormholeClass
    ? rows.filter((s) => matchesClass(s, filters.wormholeClass!))
    : rows;
}

// Overlays live Jita 5%-percentile buy values onto a list of sites.
//
// Strategy:
// - Collect every non-null typeId across all sites' resources.
// - Batch-fetch market prices and SDE volumes.
// - For each resource: liveIsk = round(units × pct5Buy).
// - effectiveIsk = liveIsk ?? totalIsk per row.
// - At the site level, resourceValueIsk is recomputed as sum(effectiveIsk).

export async function overlayLivePrices(sites: SiteDetail[]): Promise<SiteDetail[]> {
  const allTypeIds = new Set<number>();
  for (const s of sites) {
    for (const r of s.resources) {
      if (r.typeId != null) allTypeIds.add(r.typeId);
    }
  }
  if (allTypeIds.size === 0) return sites;

  const typeIdList = [...allTypeIds];
  const [prices, types] = await Promise.all([
    getPrices(typeIdList),
    getTypesByIds(typeIdList),
  ]);
  const typeById = new Map(types.map((t) => [t.id, t]));

  return sites.map((site) => {
    const newResources = site.resources.map((r) => {
      const liveEligible = isLiveEligible(r, typeById);
      const liveIsk = liveEligible
        ? liveIskFor(r.units, prices.get(r.typeId!)?.pct5Buy ?? null)
        : null;
      const effectiveIsk = liveIsk ?? r.totalIsk;
      return { ...r, liveIsk, effectiveIsk, liveEligible };
    });

    return {
      ...site,
      resources: newResources,
      resourceValueIsk: newResources.reduce((sum, r) => sum + (r.effectiveIsk ?? 0), 0),
    };
  });
}

// Live ore/gas pricing for one site. The provider wraps the whole card so
// the card total and resource rows refresh from one engine call.

export function SiteLiveProvider({ resources, children }: {
  resources: SiteResource[];
  children: ReactNode;
}) {
  const eligibleTypeIds = useMemo(() => eligibleTypeIdsOf(resources), [resources]);
  const [enabled, setEnabled] = useState(false);
  const requestEnable = useCallback(() => setEnabled(true), []);
  const { prices, isPending } = useRefreshOnView(eligibleTypeIds, { enabled });

  const value = useMemo<SiteLiveValue>(
    () => ({ priceOf: (typeId) => prices.get(typeId), isPending, requestEnable }),
    [prices, isPending, requestEnable],
  );

  return <SiteLiveContext.Provider value={value}>{children}</SiteLiveContext.Provider>;
}

// Zero-height marker placed at the top of the collapsed-hidden body.
// Fires the first time it is opened and on screen.
function ViewSentinel() {
  const { requestEnable } = useSiteLive();
  const ref = useRef<HTMLDivElement>(null);
  useEffect(() => {
    const observer = new IntersectionObserver((entries) => {
      if (entries.some((e) => e.isIntersecting)) {
        requestEnable();
        observer.disconnect();
      }
    });
    observer.observe(ref.current!);
    return () => observer.disconnect();
  }, [requestEnable]);
  return <div ref={ref} aria-hidden className="h-0" />;
}

/**
 * Defers the large site detail body until the parent <details> is first opened.
 * The <details> element still owns open/closed state natively — this only gates
 * when the body mounts, listening to the same native `toggle` event UrlSync taps.
 *
 * The /sites/[id] detail page renders SiteDetailsBody directly server-side
 * instead, keeping that page's NPC content in the initial HTML for SEO.
 */
export function LazySiteDetails({ site, zoom = false }: { site: SiteDetail; zoom?: boolean }) {
  const ref = useRef<HTMLDivElement>(null);
  const [open, setOpen] = useState(false);

  useEffect(() => {
    if (open) return;
    const details = ref.current?.closest('details');
    if (!details) return;
    if (details.open) {
      setOpen(true);
      return;
    }
    const onToggle = () => {
      if (details.open) flushSync(() => setOpen(true));
    };
    details.addEventListener('toggle', onToggle);
    return () => details.removeEventListener('toggle', onToggle);
  }, [open]);

  return (
    <div ref={ref} className={zoom ? 'sites-detail-zoom' : 'contents'}>
      {open ? <SiteDetailsBody site={site} /> : null}
    </div>
  );
}

// Per-request memo for the whole priced catalogue. Filtering moved client-side,
// so the server loads ALL sites once and overlays live prices in a single pass.
const loadAllSites = cache(async (): Promise<SiteDetail[]> => {
  const rawSites = await listSiteDetails({});
  return overlayLivePrices(rawSites);
});

async function SitesContent({ searchParams }: {
  searchParams: Promise<SitesSearchParams>;
}) {
  const raw = await searchParams;
  const sortKey = parseSortKey(raw.sort);
  const sortDir = parseSortDir(raw.dir);
  const initialView = readPreferenceCookieValue(
    (await cookies()).get(cookieNameFor(sitesView))?.value,
    sitesView,
  );
  const sites = await loadAllSites();

  const cards = sites.map((site) => ({
    meta: { id: site.id, type: site.siteType, clsSet: siteClassSet(site) },
    node: (
      <UrlSync key={site.id} basePath="/sites" entityId={site.id}>
        <SiteCard site={site} />
      </UrlSync>
    ),
  }));

  const table = <SitesTable sites={sites} sortKey={sortKey} sortDir={sortDir} />;

  return <SitesFilterLayout cards={cards} table={table} total={sites.length} initialView={initialView} />;
}

export default function SitesPage({ searchParams }: { searchParams: Promise<SitesSearchParams> }) {
  return (
    <PageShell>
      <Suspense fallback={<SitesLoading />}>
        <SitesContent searchParams={searchParams} />
      </Suspense>
    </PageShell>
  );
}

// Client filter layout for /sites. Owns Class chips + Type rows, the Cards/Table
// toggle, and the persistent rail. The priced site cards and sortable table are
// rendered server-side and handed in as nodes.

export function SitesFilterLayout({ cards, table, total, initialView }: {
  cards: SiteCardItem[];
  table: ReactNode;
  total: number;
  initialView: 'cards' | 'table';
}) {
  const [cls, setCls] = useState<WormholeClass[]>([]);
  const [types, setTypes] = useState<SiteType[]>([]);
  const [view, setView] = usePreference(sitesView, { serverValue: initialView });
  const [detailMode, setDetailMode] = usePreference(sitesDetailMode);

  useEffect(() => {
    const root = tableRef.current;
    if (!root) return;
    root.querySelectorAll<HTMLElement>('.sites-table-row').forEach((details) => {
      const rowType = details.getAttribute('data-site-type') as SiteType | null;
      const rowCls = (details.getAttribute('data-site-cls') ?? '').split(',');
      const ok = matchesFilter({ type: rowType, clsSet: rowCls }, { cls, types });
      const wrapper = details.parentElement;
      if (wrapper) wrapper.hidden = !ok;
    });
  });

  return (
    <>
      <PageHead
        crumb="sites"
        title="Wormhole Sites"
        meta={<><b>{filteredCount}</b> of {total} sites · jita <b>live</b></>}
      />
      {/* filter rail, cards/table toggle, detail-mode toggle */}
      {view === 'cards'
        ? SECTION_ORDER.map((type) => (
            <section key={type}>
              <div className="sites-grid">{sectionCards.map((c) => c.node)}</div>
            </section>
          ))
        : <div ref={tableRef}>{table}</div>}
    </>
  );
}

export function summariseSiteShipClasses(site: SiteDetail): ShipClassSummary[] {
  const counts = new Map<SleeperClassCode, number>();

  for (const wave of site.waves) {
    for (const npc of wave.npcs) {
      const code = npc.sleeperClassCode;
      if (!isSleeperClassCode(code)) continue;
      counts.set(code, (counts.get(code) ?? 0) + npc.quantity);
    }
  }

  const summary: ShipClassSummary[] = [];
  for (const code of SLEEPER_CLASS_ORDER) {
    const count = counts.get(code);
    if (count) summary.push({ code, count });
  }
  return summary;
}

export function SiteShipClasses({ site }: { site: SiteDetail }) {
  const classes = summariseSiteShipClasses(site);
  if (classes.length === 0) return null;

  return (
    <div className="sites-card-ships">
      {classes.map((c) => (
        <span key={c.code} className="sites-card-ship">
          <ShipClassIcon code={c.code} size={18} />
          <span className="sites-card-ship-label">{SLEEPER_CLASS_LABEL[c.code]}</span>
          <span className="sites-card-ship-count">{c.count}</span>
        </span>
      ))}
    </div>
  );
}

// SiteCard owns the card chrome and collapsed summary. The expanded body lives
// in SiteDetailsBody so the table view and lightbox render identical detail.

export function SiteCard({ site, defaultOpen = false }: {
  site: SiteDetail;
  defaultOpen?: boolean;
}) {
  const liveResources = displayableResources(site.resources);

  return (
    <div className="sites-card">
      <SiteLiveProvider resources={liveResources}>
        <details data-collapsible {...(defaultOpen ? { open: true } : {})}>
          <summary className="sites-card-summary">
            <SiteCardHeader site={site} />
          </summary>
          {defaultOpen ? <SiteDetailsBody site={site} /> : <LazySiteDetails site={site} zoom />}
        </details>
        {!defaultOpen && <SiteCardLightbox site={site} />}
      </SiteLiveProvider>
    </div>
  );
}

export function SiteCardLightbox({ site }: { site: SiteDetail }) {
  const [mode] = usePreference(sitesDetailMode);
  return (
    <>
      {mode === 'lightbox' && (
        <Dialog className="sites-lightbox-dialog">
          <div className="sites-lightbox-panel">
            <div className="sites-lightbox-zoom">
              <div className="sites-card-summary">
                <SiteCardHeader site={site} />
              </div>
              <SiteDetailsBody site={site} />
            </div>
          </div>
        </Dialog>
      )}
    </>
  );
}

// src/app/api/sites/route.ts
// authz: public
export async function GET(request: NextRequest): Promise<Response> {
  const parsed = sitesQuerySchema.safeParse({
    type: request.nextUrl.searchParams.get('type') ?? undefined,
    class: request.nextUrl.searchParams.get('class') ?? undefined,
  });
  if (!parsed.success) {
    return Response.json({ error: 'Invalid query' } satisfies ApiError, { status: 400 });
  }

  const result = await listSites({
    type: parsed.data.type,
    wormholeClass: parsed.data.class,
  });

  return Response.json(result.map(toApiShape) satisfies SiteListApiItem[]);
}

// src/app/api/sites/[id]/route.ts
// authz: public
export async function GET(
  _request: Request,
  { params }: { params: Promise<{ id: string }> },
): Promise<Response> {
  const parsed = siteIdParamSchema.safeParse(await params);
  if (!parsed.success) {
    return Response.json({ error: 'Invalid id' } satisfies ApiError, { status: 400 });
  }

  const site: SiteDetail | null = await getPricedSiteDetail(parsed.data.id);
  if (!site) return Response.json({ error: 'Not found' } satisfies ApiError, { status: 404 });
  return Response.json(site satisfies SiteDetail);
}