// Template data model for a "city + service" pSEO page
interface LocationPageData {
  // Unique slots - must come from data source
  city: string;
  state: string;
  providerCount: number;
  averagePrice: number;
  topProviders: Provider[];
  localStat: string;         // e.g. "Austin has 340 licensed accountants"
  nearbyLocations: string[]; // for internal linking

  // Derived (computed, not boilerplate)
  slug: string;              // e.g. "accountants-austin-tx"
  canonicalUrl: string;
  metaDescription: string;   // dynamically composed from slots
}

// app/[city]/[service]/page.tsx - Next.js App Router
import { db } from '@/lib/db';

export async function generateStaticParams() {
  const locations = await db.locations.findMany({
    where: { providerCount: { gte: 5 } }, // quality gate: skip thin pages
    select: { citySlug: true, serviceSlug: true },
  });

  return locations.map((loc) => ({
    city: loc.citySlug,
    service: loc.serviceSlug,
  }));
}

export async function generateMetadata({ params }: Props) {
  const data = await getLocationPageData(params.city, params.service);
  return {
    title: `Best ${data.serviceLabel} in ${data.cityName} - Top ${data.providerCount} Providers`,
    description: data.metaDescription,
    alternates: { canonical: data.canonicalUrl },
  };
}

export default async function LocationPage({ params }: Props) {
  const data = await getLocationPageData(params.city, params.service);
  return <LocationTemplate data={data} />;
}

// lib/related-pages.ts
export async function getRelatedPages(
  currentPage: LocationPageData,
  limit = 6
): Promise<RelatedPage[]> {
  // Strategy 1: same service, nearby cities (geographic proximity)
  const nearbyCities = await db.locations.findMany({
    where: {
      serviceSlug: currentPage.serviceSlug,
      stateSlug: currentPage.stateSlug,
      citySlug: { not: currentPage.citySlug },
    },
    orderBy: { providerCount: 'desc' },
    take: limit,
    select: { cityName: true, citySlug: true, serviceSlug: true, providerCount: true },
  });

  return nearbyCities.map((loc) => ({
    title: `${currentPage.serviceLabel} in ${loc.cityName}`,
    href: `/${loc.citySlug}/${loc.serviceSlug}`,
    signal: `${loc.providerCount} providers`,
  }));
}

// lib/quality-gate.ts
interface QualityScore {
  passes: boolean;
  score: number;
  failReasons: string[];
}

export function scoreLocationPage(data: LocationPageData): QualityScore {
  const failReasons: string[] = [];
  let score = 0;

  if (data.providerCount >= 5) score += 30;
  else failReasons.push(`Too few providers: ${data.providerCount} (min 5)`);

  if (data.topProviders.length >= 3) score += 25;
  else failReasons.push('Not enough top provider data');

  if (data.localStat?.length > 20) score += 20;
  else failReasons.push('Missing or weak local stat');

  if (data.averagePrice > 0) score += 15;
  else failReasons.push('Missing average price data');

  if (data.nearbyLocations.length >= 3) score += 10;
  else failReasons.push('Not enough nearby locations for internal linking');

  return { passes: score >= 70, score, failReasons };
}

// In generateStaticParams - filter out pages below threshold
const locations = rawLocations.filter((loc) => {
  const { passes } = scoreLocationPage(loc);
  if (!passes) console.warn(`Skipping thin page: ${loc.slug}`);
  return passes;
});

// scripts/pSEO-health-check.ts
// Requires: npm install googleapis
import { google } from 'googleapis';

const searchconsole = google.searchconsole('v1');

export async function getPseoClusterMetrics(
  siteUrl: string,
  urlPattern: string, // e.g. '/city/' to filter pSEO cluster
  days = 28
): Promise<ClusterMetrics> {
  const endDate = new Date().toISOString().split('T')[0];
  const startDate = new Date(Date.now() - days * 86400000).toISOString().split('T')[0];

  const response = await searchconsole.searchanalytics.query({
    siteUrl,
    requestBody: {
      startDate,
      endDate,
      dimensions: ['page'],
      dimensionFilterGroups: [{
        filters: [{ dimension: 'page', operator: 'contains', expression: urlPattern }],
      }],
      rowLimit: 25000,
    },
  });

  const rows = response.data.rows ?? [];
  const zeroImpression = rows.filter((r) => (r.impressions ?? 0) === 0);

  return {
    totalPages: rows.length,
    pagesWithImpressions: rows.length - zeroImpression.length,
    zeroImpressionPages: zeroImpression.length,
    avgCtr: rows.reduce((sum, r) => sum + (r.ctr ?? 0), 0) / rows.length,
    avgPosition: rows.reduce((sum, r) => sum + (r.position ?? 0), 0) / rows.length,
  };
}

// app/sitemap-index.xml/route.ts
export async function GET() {
  const services = await db.services.findMany({ select: { slug: true } });

  const sitemapIndex = `<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  ${services.map((s) => `
  <sitemap>
    <loc>https://example.com/sitemaps/${s.slug}.xml</loc>
    <lastmod>${new Date().toISOString().split('T')[0]}</lastmod>
  </sitemap>`).join('')}
</sitemapindex>`;

  return new Response(sitemapIndex, {
    headers: { 'Content-Type': 'application/xml' },
  });
}