import { prisma } from "./prisma";
import { ProductData, CorridorDataParsed } from "./types";

export function parseProduct(raw: any): ProductData {
  return {
    id: raw.id,
    slug: raw.slug,
    name: raw.name,
    categoryId: raw.categoryId,
    industryType: raw.industryType || "general",
    category: raw.category ? { slug: raw.category.slug, name: raw.category.name } : undefined,
    shortDescription: raw.shortDescription,
    fullDescription: raw.fullDescription,
    hsCode: raw.hsCode,
    operatingTemp: raw.operatingTemp,
    pressureRating: raw.pressureRating,
    hardnessShore: raw.hardnessShore,
    materials: JSON.parse(raw.materialsJson || "[]"),
    certifications: JSON.parse(raw.certificationsJson || "[]"),
    specs: JSON.parse(raw.specsJson || "{}"),
    features: JSON.parse(raw.featuresJson || "[]"),
    image: raw.image,
    featured: raw.featured,
    order: raw.order,
  };
}

export function parseCorridor(raw: any): CorridorDataParsed {
  return {
    id: raw.id,
    slug: raw.slug,
    countryName: raw.countryName,
    countryCode: raw.countryCode,
    region: raw.region,
    capitalCity: raw.capitalCity,
    flag: raw.flag,
    seaports: JSON.parse(raw.seaportsJson || "[]"),
    airports: JSON.parse(raw.airportsJson || "[]"),
    complianceStandards: JSON.parse(raw.complianceStandards || "[]"),
    industrialClusters: JSON.parse(raw.industrialClusters || "[]"),
    b2bTerms: JSON.parse(raw.b2bTermsJson || "{}"),
    customsNote: raw.customsNote,
    faqs: JSON.parse(raw.faqsJson || "[]"),
    active: raw.active,
  };
}

export async function getAllProducts(): Promise<ProductData[]> {
  const items = await prisma.product.findMany({
    include: { category: true },
    orderBy: { order: "asc" },
  });
  return items.map(parseProduct);
}

export async function getProductBySlug(slug: string): Promise<ProductData | null> {
  const item = await prisma.product.findUnique({
    where: { slug },
    include: { category: true },
  });
  if (!item) return null;
  return parseProduct(item);
}

export async function getAllCorridors(): Promise<CorridorDataParsed[]> {
  const items = await prisma.corridor.findMany({
    where: { active: true },
    orderBy: { countryName: "asc" },
  });
  return items.map(parseCorridor);
}

export async function getCorridorBySlug(slug: string): Promise<CorridorDataParsed | null> {
  const item = await prisma.corridor.findUnique({
    where: { slug },
  });
  if (!item) return null;
  return parseCorridor(item);
}

export async function getAllCategories() {
  return await prisma.category.findMany({
    include: { products: true },
    orderBy: { order: "asc" },
  });
}

export async function getCategoryBySlug(slug: string) {
  return await prisma.category.findUnique({
    where: { slug },
    include: { products: true },
  });
}

export async function getGlobalSettings() {
  const list = await prisma.setting.findMany();
  const map: Record<string, string> = {};
  for (const item of list) {
    map[item.key] = item.value;
  }
  return map;
}

export async function getSitePagesContent() {
  try {
    const setting = await prisma.setting.findUnique({
      where: { key: "site_pages_content" },
    });
    if (setting && setting.value) {
      return JSON.parse(setting.value);
    }
  } catch (e) {
    console.error("Error reading site_pages_content", e);
  }
  return null;
}
