import type { Metadata } from "next";
import { redirect } from "next/navigation";
import {
  VehiclePackagesClient,
  type VehiclePackage,
  type VehiclePackageModel,
} from "@/app/vehicle-packages/[vehicleType]/[manufacturerSlug]/[modelId]/VehiclePackagesClient";
import { serverApiBaseUrl } from "@/lib/api-url";
import { formatCompanyName, formatModelName } from "@/lib/vehicle-display";
import type { VehiclePackageType } from "@/lib/vehicle-model-navigation";
import { JsonLd, breadcrumbJsonLd, serviceJsonLd } from "@/lib/seo";

type ServicePackagesPageProps = {
  params: Promise<{
    serviceSlug: string;
    manufacturerSlug: string;
    modelSlug: string;
  }>;
  searchParams?: Promise<{
    packageType?: string;
    vehicleType?: string;
  }>;
};

type VehiclePackagesResponse = {
  model: VehiclePackageModel | null;
  packages?: VehiclePackage[];
  error?: string;
};

const serviceTitles: Record<string, string> = {
  "car-service": "Car Service",
  "bike-service": "Bike Service",
  "car-ac-service": "Car AC Service",
  "engine-repair": "Engine Repair",
  "battery-service": "Battery Service",
  "tyre-wheel": "Tyre & Wheel",
};

function getPackageTypeFromServiceSlug(serviceSlug: string): VehiclePackageType {
  if (serviceSlug === "car-ac-service") {
    return "car_ac";
  }

  if (serviceSlug === "engine-repair") {
    return "engine_repair";
  }

  if (serviceSlug === "battery-service") {
    return "battery_service";
  }

  if (serviceSlug === "tyre-wheel") {
    return "tyre_wheel_service";
  }

  return "service_package";
}

function getServiceName(serviceSlug: string) {
  return serviceTitles[serviceSlug] ?? "Vehicle Service";
}

function getRouteVehicleType(serviceSlug: string) {
  if (serviceSlug === "bike-service") {
    return "bike" as const;
  }

  if (serviceSlug === "car-service" || serviceSlug === "car-ac-service") {
    return "car" as const;
  }

  return undefined;
}

function getSearchVehicleType(vehicleType?: string) {
  return vehicleType === "bike" ? "bike" : vehicleType === "car" ? "car" : undefined;
}

function usesVehicleTypePath(serviceSlug: string) {
  return (
    serviceSlug === "engine-repair" ||
    serviceSlug === "battery-service" ||
    serviceSlug === "tyre-wheel"
  );
}

export async function generateMetadata({ params }: ServicePackagesPageProps): Promise<Metadata> {
  const { serviceSlug, manufacturerSlug, modelSlug } = await params;
  const modelName = formatModelName(decodeURIComponent(modelSlug));
  const serviceName = getServiceName(serviceSlug);

  return {
    title: `${modelName} ${serviceName} Packages`,
    description: `Choose a package for ${modelName} and book ${serviceName.toLowerCase()} on WhatsApp.`,
    alternates: {
      canonical: `/services/${serviceSlug}/${manufacturerSlug}/${modelSlug}`,
    },
  };
}

export async function renderServicePackagesPage(
  { params, searchParams }: ServicePackagesPageProps,
  shouldRedirectLegacyVehicleTypeUrl = true,
) {
  const { serviceSlug, manufacturerSlug, modelSlug } = await params;
  const resolvedSearchParams = await searchParams;
  const vehicleType =
    getRouteVehicleType(serviceSlug) ?? getSearchVehicleType(resolvedSearchParams?.vehicleType);
  const resolvedManufacturerSlug = decodeURIComponent(manufacturerSlug);
  const resolvedModelSlug = decodeURIComponent(modelSlug);
  const companyName = formatCompanyName(resolvedManufacturerSlug);
  const serviceName = getServiceName(serviceSlug);
  const resolvedPackageType =
    resolvedSearchParams?.packageType && resolvedSearchParams.packageType !== "service_package"
      ? resolvedSearchParams.packageType
      : getPackageTypeFromServiceSlug(serviceSlug);

  if (shouldRedirectLegacyVehicleTypeUrl && vehicleType && usesVehicleTypePath(serviceSlug)) {
    const nextParams = new URLSearchParams();

    if (resolvedSearchParams?.packageType) {
      nextParams.set("packageType", resolvedSearchParams.packageType);
    }

    const queryString = nextParams.toString();
    redirect(
      `/services/${serviceSlug}/${vehicleType}/${manufacturerSlug}/${modelSlug}${
        queryString ? `?${queryString}` : ""
      }`,
    );
  }

  let initialModel: VehiclePackageModel | null | undefined;
  let initialPackages: VehiclePackage[] | undefined;
  let initialErrorMessage = "";

  try {
    const response = await fetch(
      `${serverApiBaseUrl}/api/vehicle-packages?manufacturerSlug=${encodeURIComponent(
        resolvedManufacturerSlug,
      )}&modelSlug=${encodeURIComponent(resolvedModelSlug)}&serviceSlug=${encodeURIComponent(
        serviceSlug,
      )}&packageType=${encodeURIComponent(resolvedPackageType)}${
        vehicleType ? `&vehicleType=${vehicleType}` : ""
      }`,
      { cache: "no-store" },
    );
    const data = (await response.json().catch(() => ({}))) as VehiclePackagesResponse;

    if (!response.ok) {
      throw new Error(data.error ?? "Could not load packages");
    }

    initialModel = data.model;
    initialPackages = data.packages ?? [];
  } catch (error) {
    initialErrorMessage = error instanceof Error ? error.message : "Could not load packages";
  }

  const modelName = initialModel
    ? formatModelName(initialModel.name, initialModel.manufacturerName)
    : formatModelName(resolvedModelSlug, companyName);

  return (
    <>
      <JsonLd
        data={[
          serviceJsonLd({
            name: `${modelName} ${serviceName}`,
            description: `Book ${serviceName.toLowerCase()} packages for ${modelName} with Ride N Revive doorstep support.`,
            path: `/services/${serviceSlug}/${manufacturerSlug}/${modelSlug}/`,
            serviceType: serviceName,
          }),
          breadcrumbJsonLd([
            { name: "Home", path: "/" },
            { name: "Services", path: "/services/" },
            { name: serviceName, path: `/services/${serviceSlug}/` },
            { name: companyName, path: `/services/${serviceSlug}/${manufacturerSlug}/` },
            { name: modelName, path: `/services/${serviceSlug}/${manufacturerSlug}/${modelSlug}/` },
          ]),
        ]}
      />
      <VehiclePackagesClient
        vehicleType={vehicleType}
        manufacturerSlug={resolvedManufacturerSlug}
        modelSlug={resolvedModelSlug}
        packageType={resolvedPackageType}
        serviceSlug={serviceSlug}
        initialModel={initialModel}
        initialPackages={initialPackages}
        initialErrorMessage={initialErrorMessage}
      />
    </>
  );
}

export default async function ServicePackagesPage(props: ServicePackagesPageProps) {
  return renderServicePackagesPage(props);
}