import type { Metadata } from "next";
import { notFound, permanentRedirect } from "next/navigation";
import ProductDetail from "@/features/shop/product-detail";
import ProductVisitTracker from "@/components/shop/product-visit-tracker";
import {
  effectivePrice,
  getPublicProductBySlug,
  resolvePublicMediaUrl,
} from "@/lib/public-product";
import { resolveProductFaqs } from "@/lib/content-faqs";
import { DEFAULT_OG_IMAGE } from "@/lib/site-og-image";

const SITE_URL = (process.env.NEXT_PUBLIC_SITE_URL || "https://nizamify.com").replace(/\/$/, "");

function getDescription(raw?: string | null) {
  const text = String(raw || "")
    .replace(/<[^>]+>/g, " ")
    .replace(/&nbsp;/gi, " ")
    .replace(/\s+/g, " ")
    .trim();
  if (!text) return "Explore product details, price, and variants on Nizamify.";
  return text.slice(0, 180);
}

export async function generateMetadata({
  params,
}: {
  params: { slug: string };
}): Promise<Metadata> {
  const product = await getPublicProductBySlug(params.slug);
  if (!product) {
    return {
      title: "Product Not Found",
      robots: { index: false, follow: false },
    };
  }

  const title = product.metaTitle?.trim() || product.title;
  const description = product.metaDescription?.trim() || getDescription(product.description);
  const canonical = `/products/${product.slug}`;
  const image = resolvePublicMediaUrl(product.images?.[0]);
  const keywords =
    Array.isArray(product.metaKeywords) && product.metaKeywords.length > 0
      ? product.metaKeywords
      : ["Nizamify product", product.title, "buy online"];

  return {
    title,
    description,
    keywords,
    alternates: { canonical },
    openGraph: {
      title,
      description,
      type: "website",
      url: `${SITE_URL}${canonical}`,
      images: [
        {
          url: image || DEFAULT_OG_IMAGE,
          alt: product.title,
        },
      ],
    },
    twitter: {
      card: "summary_large_image",
      title,
      description,
      images: [image || DEFAULT_OG_IMAGE],
    },
  };
}

export default async function ProductDetailPage({
  params,
}: {
  params: { slug: string };
}) {
  const product = await getPublicProductBySlug(params.slug);
  if (!product) {
    // Was rendering "Product Not Found" with a 200 status (soft 404) — Google
    // never drops these from the index. Return a real 404 instead.
    notFound();
  }
  if (product.canonicalSlug && product.canonicalSlug !== params.slug) {
    // Slug was renamed since this URL was indexed — 308 to the current slug instead of 404ing.
    permanentRedirect(`/products/${product.canonicalSlug}`);
  }
  const image = resolvePublicMediaUrl(product?.images?.[0]);
  const description = product?.metaDescription?.trim() || getDescription(product?.description);

  // Only emit ratings backed by real review data — never fabricate stars.
  const hasRealRating =
    product != null &&
    product.ratingValue != null &&
    product.ratingValue > 0 &&
    product.reviewCount != null &&
    product.reviewCount > 0;

  // Give the price a validity window so the Offer stays in good standing with Google.
  const priceValidUntil = `${new Date().getFullYear() + 1}-12-31`;

  const productSchema = product
    ? {
        "@context": "https://schema.org",
        "@type": "Product",
        name: product.title,
        description,
        image: [image || DEFAULT_OG_IMAGE],
        sku: product._id,
        category: product.categories?.map((c) => c.name).join(", ") || undefined,
        url: `${SITE_URL}/products/${product.slug}`,
        brand: {
          "@type": "Brand",
          name: "Nizamify",
        },
        ...(hasRealRating
          ? {
              aggregateRating: {
                "@type": "AggregateRating",
                ratingValue: product.ratingValue,
                reviewCount: product.reviewCount,
              },
            }
          : {}),
        offers: {
          "@type": "Offer",
          url: `${SITE_URL}/products/${product.slug}`,
          priceCurrency: "PKR",
          price: effectivePrice(product),
          priceValidUntil,
          itemCondition: "https://schema.org/NewCondition",
          availability:
            product.stock != null && product.stock <= 0
              ? "https://schema.org/OutOfStock"
              : "https://schema.org/InStock",
          seller: {
            "@type": "Organization",
            name: "Nizamify",
          },
          shippingDetails: {
            "@type": "OfferShippingDetails",
            shippingRate: {
              "@type": "MonetaryAmount",
              value: product.freeShipping ? 0 : product.shippingCost ?? 0,
              currency: "PKR",
            },
            shippingDestination: {
              "@type": "DefinedRegion",
              addressCountry: "PK",
            },
          },
          // No returns accepted today — confirmed by the business, not guessed.
          // Revisit if/when a real return window is introduced.
          hasMerchantReturnPolicy: {
            "@type": "MerchantReturnPolicy",
            returnPolicyCategory: "https://schema.org/MerchantReturnNotPermitted",
            applicableCountry: "PK",
          },
        },
      }
    : null;

  const { faqs } = resolveProductFaqs(product);
  const faqSchema =
    faqs.length > 0
      ? {
          "@context": "https://schema.org",
          "@type": "FAQPage",
          mainEntity: faqs.map((faq) => ({
            "@type": "Question",
            name: faq.question,
            acceptedAnswer: {
              "@type": "Answer",
              text: faq.answerText,
            },
          })),
        }
      : null;

  const primaryCategory = product?.categories?.[0];
  const breadcrumbSchema = product
    ? {
        "@context": "https://schema.org",
        "@type": "BreadcrumbList",
        itemListElement: [
          {
            "@type": "ListItem",
            position: 1,
            name: "Home",
            item: `${SITE_URL}/`,
          },
          ...(primaryCategory
            ? [
                {
                  "@type": "ListItem",
                  position: 2,
                  name: primaryCategory.name,
                  item: `${SITE_URL}/products/category/${primaryCategory.slug}`,
                },
              ]
            : []),
          {
            "@type": "ListItem",
            position: primaryCategory ? 3 : 2,
            name: product.title,
            item: `${SITE_URL}/products/${product.slug}`,
          },
        ],
      }
    : null;

  return (
    <>
      <ProductVisitTracker slug={params.slug} />
      {productSchema ? (
        <script
          type="application/ld+json"
          dangerouslySetInnerHTML={{ __html: JSON.stringify(productSchema) }}
        />
      ) : null}
      {breadcrumbSchema ? (
        <script
          type="application/ld+json"
          dangerouslySetInnerHTML={{ __html: JSON.stringify(breadcrumbSchema) }}
        />
      ) : null}
      {faqSchema ? (
        <script
          type="application/ld+json"
          dangerouslySetInnerHTML={{ __html: JSON.stringify(faqSchema) }}
        />
      ) : null}
      <ProductDetail slug={params.slug} />
    </>
  );
}