Under the Hood

export const usageLogs = pgTable(
  'usage_logs',
  {
    id: bigserial('id', { mode: 'number' }).primaryKey(),
    timestamp: timestamp('timestamp', { withTimezone: true }).defaultNow().notNull(),
    characterId: bigint('character_id', { mode: 'number' }).references(
      () => characters.characterId,
      { onDelete: 'set null' },
    ),
    action: text('action').notNull(),
    metadata: jsonb('metadata').$type<Record<string, unknown>>().default({}).notNull(),
  },
  (t) => [
    index('usage_logs_timestamp_idx').on(t.timestamp.desc()),
    index('usage_logs_action_timestamp_idx').on(t.action, t.timestamp.desc()),
    index('usage_logs_character_timestamp_idx').on(t.characterId, t.timestamp.desc()),
  ],
);

export const CLIENT_USAGE_ACTIONS = ['page_view', 'terminal_search'] as const;

export const SERVER_USAGE_ACTIONS = [
  'auth_login',
  'auth_logout',
  'role_change',
  'character_switch',
  'character_unlink',
  'admin_character_unlink',
  'admin_force_logout',
  'admin_character_reassign',
  'feedback_submitted',
  'price_source_degraded',
  'cron_prices',
  'cron_industry_indices',
  'cron_sde',
  'cron_gsc',
  'cron_sync_sweeper',
  'cron_affiliations',
  'eve_token_refresh_race',
  'account_purge',
] as const;

export const USAGE_ACTIONS = [
  ...CLIENT_USAGE_ACTIONS,
  ...SERVER_USAGE_ACTIONS,
] as const;

export type UsageAction = (typeof USAGE_ACTIONS)[number];

// Validates against CLIENT_USAGE_ACTIONS, not the full set: server-only
// actions (cron health signals, auth/admin audit) must not be forgeable by a
// client POST, or the health/audit rows they write could be polluted.
export const telemetryRequestSchema = z.object({
  action: z.enum(CLIENT_USAGE_ACTIONS),
  metadata: z.record(z.string(), z.unknown()).optional(),
});

export const telemetryEndpoint: ApiEndpoint<z.input<typeof telemetryRequestSchema>, undefined> = {
  method: 'POST',
  path: '/api/telemetry',
  request: telemetryRequestSchema,
  response: null,
};

<Suspense fallback={null}>
  <TelemetryReporter />
</Suspense>
{/* Only on Vercel (prod/preview), where the script is served same-origin. */}
{process.env.NODE_ENV === "production" && <SpeedInsights />}

const SKIP_PREFIXES = ['/admin', '/api/'];
const VISITOR_KEY = 'lgi:visitor_id';
const SESSION_FLAG_KEY = 'lgi:session_started';

function shouldSkip(path: string): boolean {
  return SKIP_PREFIXES.some((prefix) => path === prefix || path.startsWith(prefix));
}

function getOrCreateVisitorId(): string | null {
  try {
    if (typeof window === 'undefined') return null;
    const existing = window.localStorage.getItem(VISITOR_KEY);
    if (existing) return existing;
    const fresh = crypto.randomUUID();
    window.localStorage.setItem(VISITOR_KEY, fresh);
    return fresh;
  } catch {
    return null;
  }
}

function takeIsEntry(): boolean {
  try {
    if (typeof window === 'undefined') return false;
    const flagged = window.sessionStorage.getItem(SESSION_FLAG_KEY);
    if (flagged) return false;
    window.sessionStorage.setItem(SESSION_FLAG_KEY, '1');
    return true;
  } catch {
    return false;
  }
}

export function TelemetryReporter(): null {
  const pathname = usePathname();
  const searchParams = useSearchParams();
  const search = searchParams.toString();

  useEffect(() => {
    if (!pathname || shouldSkip(pathname)) return;
    const metadata: Record<string, unknown> = { path: pathname, search };
    const referrer = readReferrerHost();
    if (referrer) metadata.referrer = referrer;
    const utm = readUtmTags(searchParams);
    if (utm) metadata.utm = utm;
    const visitorId = getOrCreateVisitorId();
    if (visitorId) metadata.visitor_id = visitorId;
    metadata.is_entry = takeIsEntry();
    postTelemetry({ action: 'page_view', metadata });
  }, [pathname, search, searchParams]);

  return null;
}

export function postTelemetry({ action, metadata }: PostInput): void {
  const payload = { action, metadata: metadata ?? {} };

  if (typeof navigator !== 'undefined' && 'sendBeacon' in navigator) {
    const blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
    const ok = navigator.sendBeacon(telemetryEndpoint.path, blob);
    if (ok) return;
  }

  void apiFetch(telemetryEndpoint, { body: payload, keepalive: true }).catch(() => {});
}

const MAX_METADATA_BYTES = 2048;

export async function POST(request: NextRequest): Promise<Response> {
  const parsed = telemetryRequestSchema.safeParse(body);
  if (!parsed.success) {
    const issue = parsed.error.issues[0];
    const detail = issue ? `${issue.path.join('.') || 'body'}: ${issue.message}` : 'invalid body';
    return new Response(detail, { status: 400 });
  }

  const safeMetadata = parsed.data.metadata ?? {};
  if (parsed.data.metadata !== undefined) {
    const serialised = JSON.stringify(safeMetadata);
    if (new TextEncoder().encode(serialised).length > MAX_METADATA_BYTES) {
      return new Response('metadata too large', { status: 400 });
    }
  }

  const limit = await rateLimit(clientIdentifier(request.headers), {
    name: 'telemetry',
    perMinute: TELEMETRY_LIMIT_PER_MINUTE,
  });
  if (!limit.ok) return Response.json({ error: 'rate_limited', retryAfter: limit.retryAfter }, { status: 429 });

  void getSessionCharacterId()
    .then((characterId) =>
      logUsageEvent({ action: parsed.data.action, characterId, metadata: safeMetadata }),
    )
    .catch((err) => console.error('[telemetry] failed to record usage event', err));

  return new Response(null, { status: 204 });
}

export async function logUsageEvent(input: LogEventInput): Promise<void> {
  await db.insert(usageLogs).values({
    action: input.action,
    characterId: input.characterId ?? null,
    metadata: input.metadata ?? {},
  });
}

export async function pruneUsageLogs(retentionDays: number, now: Date = new Date()): Promise<void> {
  const cutoff = new Date(now.getTime() - retentionDays * 24 * 60 * 60 * 1000);
  await db.delete(usageLogs).where(lt(usageLogs.timestamp, cutoff));
}

function topByMetadataKeyQuery(metaKey: string, action: UsageAction, range: DateRange, limit: number) {
  const col = sql<string>`${usageLogs.metadata} ->> ${metaKey}`;
  return db
    .select({ value: col, count: count() })
    .from(usageLogs)
    .where(and(inRange(range), eq(usageLogs.action, action), isNotNull(col)))
    .groupBy(sql`1`)
    .orderBy(desc(count()))
    .limit(limit);
}

export async function getFallbackRate(range: DateRange): Promise<FallbackRateData> {
  const esi = sql<number>`coalesce(sum(${jsonInt('esiCount')}), 0)`.mapWith(Number);
  const fallback = sql<number>`coalesce(sum(${jsonInt('fuzzworkFallbackCount')}), 0)`.mapWith(Number);
  // returns totals plus per-day split for the dashboard trend
}

export async function getLastCronRuns(): Promise<CronLastRun[]> {
  const outcome = sql<string | null>`${usageLogs.metadata} ->> 'outcome'`;
  const rows = await db
    .selectDistinctOn([usageLogs.action], { action: usageLogs.action, timestamp: usageLogs.timestamp, outcome })
    .from(usageLogs)
    .where(inArray(usageLogs.action, ['cron_prices', 'cron_sde', 'cron_gsc']))
    .orderBy(usageLogs.action, desc(usageLogs.timestamp));
  return rows.map((r) => ({ action: r.action as UsageAction, timestamp: r.timestamp, outcome: r.outcome }));
}

export function ratio(num: number, denom: number): number | null {
  return denom === 0 ? null : num / denom;
}

export function fallbackSummary({ esi, fallback }: FallbackRateData): string {
  const denom = esi + fallback;
  if (denom === 0) return 'No price refreshes recorded this period.';
  if (fallback === 0) return 'ESI served every priced item this period.';
  const pct = Math.round((fallback / denom) * 100);
  return `Fuzzwork covered ${pct}% of priced items when ESI was unavailable.`;
}

export function deriveCronStatus(input: CronStatusInput): SubsystemStatus {
  const { lastRun, outcomes, expectedEveryHours, now } = input;
  if (!lastRun) return { level: 'red', headline: 'never ran' };
  const ageHours = (now.getTime() - lastRun.timestamp.getTime()) / 3_600_000;
  const lastKind = classifyOutcome(lastRun.outcome, input);
  if (lastKind === 'unhealthy') return { level: 'red', headline: `failing · ${lastRun.outcome ?? 'unknown outcome'}` };
  if (ageHours > expectedEveryHours * STALE_RED_FACTOR) return { level: 'red', headline: 'stale' };
  if (lastKind === 'degraded') return { level: 'amber', headline: `degraded · ${lastRun.outcome}` };
  if (ageHours > expectedEveryHours * STALE_AMBER_FACTOR) return { level: 'amber', headline: 'late' };
  const failures = outcomes.filter((o) => classifyOutcome(o.outcome, input) === 'unhealthy').reduce((s, o) => s + o.count, 0);
  if (failures > 0) return { level: 'amber', headline: `recovered · ${failures} failed runs this period` };
  return { level: 'green', headline: 'healthy' };
}

export function deriveEsiSourceStatus({ fallback, budgetExhaustions }: EsiSourceStatusInput): SubsystemStatus {
  const denom = fallback.esi + fallback.fallback;
  if (denom === 0) return { level: 'neutral', headline: 'no price refreshes this period' };
  const rate = fallback.fallback / denom;
  if (rate > FALLBACK_RED_RATE) return { level: 'red', headline: 'degraded' };
  if (fallback.fallback > 0 || budgetExhaustions > 0) return { level: 'amber', headline: 'partial' };
  return { level: 'green', headline: 'ESI served every priced item this period' };
}

export const gscSearchAnalytics = pgTable(
  'gsc_search_analytics',
  {
    date: date('date').notNull(),
    dimension: text('dimension').notNull(),
    key: text('key').notNull(),
    clicks: integer('clicks').notNull(),
    impressions: integer('impressions').notNull(),
    position: doublePrecision('position').notNull(),
    syncedAt: timestamp('synced_at', { withTimezone: true }).notNull(),
  },
  (t) => [
    primaryKey({ columns: [t.date, t.dimension, t.key] }),
    index('gsc_search_analytics_dimension_date_idx').on(t.dimension, t.date),
  ],
);

export const gscSitemaps = pgTable('gsc_sitemaps', {
  path: text('path').primaryKey(),
  warnings: bigint('warnings', { mode: 'number' }).notNull().default(0),
  errors: bigint('errors', { mode: 'number' }).notNull().default(0),
  submitted: bigint('submitted', { mode: 'number' }).notNull().default(0),
  indexed: bigint('indexed', { mode: 'number' }).notNull().default(0),
  syncedAt: timestamp('synced_at', { withTimezone: true }).notNull(),
});

export const gscUrlInspection = pgTable('gsc_url_inspection', {
  url: text('url').primaryKey(),
  verdict: text('verdict'),
  coverageState: text('coverage_state'),
  robotsTxtState: text('robots_txt_state'),
  indexingState: text('indexing_state'),
  pageFetchState: text('page_fetch_state'),
  lastCrawlTime: timestamp('last_crawl_time', { withTimezone: true }),
  syncedAt: timestamp('synced_at', { withTimezone: true }).notNull(),
});

export async function GET(req: Request): Promise<Response> {
  const denied = await requireCronAuth(req);
  if (denied) return denied;

  const start = Date.now();
  const reserved = await directClient.reserve();
  let lockHeld = false;
  try {
    const lockResult = await reserved<{ got: boolean }[]>`
      SELECT pg_try_advisory_lock(${LOCK_KEY_NUM}) AS got
    `;
    if (!lockResult[0].got) {
      await swallow('[cron:gsc] telemetry write failed', logUsageEvent({ action: 'cron_gsc', metadata: { outcome: 'skipped', reason: 'busy' } }));
      return Response.json({ status: 'skipped', reason: 'busy', durationMs: Date.now() - start });
    }
    lockHeld = true;

    const summary = await syncGsc(directClient);
    await swallow('[cron:gsc] usage_logs prune failed', pruneUsageLogs(USAGE_LOG_RETENTION_DAYS));
    await swallow('[cron:gsc] telemetry write failed', logUsageEvent({
      action: 'cron_gsc',
      metadata: { outcome: summary.status, reason: summary.reason, errorCount: summary.errors.length, durationMs: summary.durationMs },
    }));
    return Response.json(summary);
  } finally {
    try {
      if (lockHeld) await reserved`SELECT pg_advisory_unlock(${LOCK_KEY_NUM})`;
    } finally {
      reserved.release();
    }
  }
}

async function syncSearchAnalytics(db: AnyPgDb, startDate: string, endDate: string, syncedAt: Date): Promise<SurfaceResult> {
  try {
    const perPull = await Promise.all(
      SEARCH_PULLS.map(async (pull) =>
        searchRowsToRecords(
          await querySearchAnalytics({ startDate, endDate, dimensions: pull.apiDimensions }),
          pull.storage,
          syncedAt,
        ),
      ),
    );
    const records = perPull.flat();
    await upsertSearchAnalytics(db, records);
    return { count: records.length, error: null };
  } catch (err) {
    return { count: 0, error: `search-analytics: ${errText(err)}` };
  }
}

async function syncUrlInspections(db: AnyPgDb, syncedAt: Date): Promise<{ count: number; errors: string[] }> {
  let count = 0;
  const errors: string[] = [];
  for (const url of inspectionUrls()) {
    try {
      const status = await inspectUrl(url);
      if (!status) continue;
      await db.insert(gscUrlInspection).values(indexStatusToRecord(url, status, syncedAt)).onConflictDoUpdate({ target: gscUrlInspection.url, set: { syncedAt: excluded('synced_at') } });
      count++;
    } catch (err) {
      errors.push(`url-inspection ${url}: ${errText(err)}`);
    }
  }
  return { count, errors };
}

export async function syncGsc(client: Sql): Promise<GscSyncSummary> {
  if (!isGscConfigured()) return { status: 'skipped', reason: 'not_configured', searchRows: 0, sitemaps: 0, urlsInspected: 0, errors: [], durationMs: 0 };
  const search = await syncSearchAnalytics(db, startDate, endDate, syncedAt);
  const sitemap = await syncSitemaps(db, syncedAt);
  const urls = await syncUrlInspections(db, syncedAt);
  const errors = [search.error, sitemap.error, ...urls.errors].filter((e): e is string => e !== null);
  const anyLanded = search.count + sitemap.count + urls.count > 0;
  const status = errors.length === 0 ? 'synced' : anyLanded ? 'partial' : 'failed';
  return { status, reason: status === 'failed' ? errors[0] : undefined, searchRows: search.count, sitemaps: sitemap.count, urlsInspected: urls.count, errors, durationMs: Date.now() - start };
}

export const USAGE_LOG_RETENTION_DAYS = 180;

async function AdminContent({ searchParams }: { searchParams: Promise<{ range?: string | string[] }> }) {
  const session = await getSession();
  if (!isAdmin(session)) {
    redirect('/?auth_error=admin_required');
  }

  const raw = await searchParams;
  const rangeKey = parseRange(raw.range);
  const range = rangeFor(rangeKey);

  return (
    <>
      <PageHead
        crumb="admin"
        title="Admin"
        subtitle={`${formatDate(range.from)} → ${formatDate(range.to)}`}
        meta={<><RangeSelector range={rangeKey} /><Link href="/admin/access">Access →</Link><PrintButton /></>}
      />
      <Suspense fallback={<SectionFallback />}><KpiRow rangeKey={rangeKey} range={range} /></Suspense>
      <Suspense fallback={<SectionFallback />}><StatusStrip range={range} /></Suspense>
      <Suspense fallback={<SectionFallback />}><TrafficSection range={range} /></Suspense>
      <Suspense fallback={<SectionFallback />}><UsersSection range={range} /></Suspense>
    </>
  );
}

export default function AdminPage({ searchParams }: { searchParams: Promise<{ range?: string | string[] }> }) {
  return <PageShell><Suspense fallback={<AdminLoading />}><AdminContent searchParams={searchParams} /></Suspense></PageShell>;
}

export async function StatusStrip({ range }: { range: DateRange }) {
  const gscConfigured = isGscConfigured();
  const fetched = await loadSection('system-health', () =>
    Promise.all([
      getLastCronRuns(),
      getPriceCronOutcomes(range),
      getSdeCronOutcomes(range),
      getGscCronOutcomes(range),
      getFallbackRate(range),
      getBudgetExhaustionCount(range),
      getDegradationByCaller(range),
      getRefreshVolume(range),
      gscConfigured ? getLastSyncedAtShared() : Promise.resolve(null),
    ]),
  );
  if (fetched === SECTION_LOAD_FAILED) return <SectionUnavailable label="System health" />;

  const priceStatus = deriveCronStatus({ lastRun: lastFor('cron_prices'), outcomes: priceOutcomes, healthy: PRICES_HEALTHY_OUTCOMES, expectedEveryHours: 24, now });
  const sdeStatus = deriveCronStatus({ lastRun: lastFor('cron_sde'), outcomes: sdeOutcomes, healthy: SDE_HEALTHY_OUTCOMES, neutral: SDE_NEUTRAL_OUTCOMES, expectedEveryHours: 24, now });
  const gscStatus = deriveGscStatus({ configured: gscConfigured, lastRun: lastFor('cron_gsc'), outcomes: gscOutcomes, lastSyncedAt, now });
  const esiStatus = deriveEsiSourceStatus({ fallback, budgetExhaustions });

  return (
    <Card>
      <StatusRow name="Price cron" status={priceStatus}>{/* details */}</StatusRow>
      <StatusRow name="SDE cron" status={sdeStatus}>{/* details */}</StatusRow>
      <StatusRow name="GSC sync" status={gscStatus}>{/* details */}</StatusRow>
      <StatusRow name="ESI source" status={esiStatus}>{/* details */}</StatusRow>
    </Card>
  );
}

export const SECTION_LOAD_FAILED = Symbol('admin.section-load-failed');

export async function loadSection<T>(
  label: string,
  load: () => Promise<T>,
): Promise<T | typeof SECTION_LOAD_FAILED> {
  try {
    return await load();
  } catch (err) {
    unstable_rethrow(err);
    console.error(`[admin] ${label} section unavailable`, err);
    return SECTION_LOAD_FAILED;
  }
}

async function buildAdminList(): Promise<Array<{ user: AdminUser; isSuperadmin: boolean }>> {
  const dbAdmins = await listAdminUsers();
  const superId = Number(readEnv('SUPERADMIN_CHARACTER_ID'));
  const superUser = Number.isFinite(superId) && superId > 0 ? await getUserByCharacterId(superId) : null;
  const superUserId = superUser?.userId ?? null;
  const rows = dbAdmins.map(u => ({ user: u, isSuperadmin: u.userId === superUserId }));
  if (superUser && !dbAdmins.some(a => a.userId === superUserId)) {
    rows.unshift({ user: superUser, isSuperadmin: true });
  }
  return rows;
}

async function AccessContent({ searchParams }: { searchParams: Promise<{ q?: string | string[] }> }) {
  const session = await auth.api.getSession({ headers: await headers() });
  if (!session?.isAdmin) redirect('/?auth_error=admin_required');
  const viewerUserId = session.user.id;
  const raw = await searchParams;
  const query = sanitiseQuery(raw.q);
  const [adminRows, searchResults, audit] = await Promise.all([
    buildAdminList(),
    query ? searchUsersByLinkedCharacterName(query) : Promise.resolve([] as AdminUser[]),
    getRoleChangeAudit(lastNDaysRange(AUDIT_WINDOW_DAYS), 50),
  ]);
  return <PageHead crumb="access" title="Access" />;
}

export async function POST(request: NextRequest): Promise<Response> {
  const session = await auth.api.getSession({ headers: await headers() });
  if (!session?.isAdmin) return new Response('Forbidden', { status: 403 });
  const viewerUserId = session.user.id;
  const actorCharacterId = session.characterId;

  const form = await request.formData();
  const parsed = adminRoleFormSchema.safeParse({
    userId: form.get('userId'),
    nextRole: form.get('nextRole'),
    q: form.get('q') ?? undefined,
  });
  if (!parsed.success) return new Response('Invalid form', { status: 400 });

  const { userId, nextRole } = parsed.data;
  if (userId === viewerUserId) return new Response('Cannot toggle your own role', { status: 400 });
  const target = await getUserById(userId);
  if (!target) return new Response('User not found', { status: 404 });

  const previousRole = target.role;
  await setUserRole(userId, nextRole);
  void logUsageEvent({
    action: 'role_change',
    characterId: actorCharacterId,
    metadata: { actorUserId: viewerUserId, targetUserId: userId, targetCharacterId: target.characterId, from: previousRole, to: nextRole },
  }).catch((err) => console.error('[admin/role] telemetry write failed', err));

  return Response.redirect(buildRedirect(request, sanitiseQuery(parsed.data.q)), 303);
}