import { useQuery } from "@tanstack/react-query";
import { supabase } from "@/integrations/supabase/client";
import { useTranslation } from "react-i18next";
import { isPublicCaseSlug } from "@/lib/publicCasePolicy";

export interface CaseStudy {
  id: string;
  title: string;
  subtitle: string;
  client: string;
  agency?: string;
  categories: string[];
  image: string;
  imageAlt: string;
  video?: string;
  inlineImage?: string;
  inlineImageAlt?: string;
  gallery?: { src: string; alt: string }[];

  date: string;
  summary: string;
  challenge: string | string[];
  solution: string;
  results: string[];
  experience?: string;
  businessImpact?: string | string[];
  whyMatters?: string;
  adaptableFor?: string[];
  technologies?: string[];
  process?: string[];
  technicalImplementation?: string;
  lessons?: string[];
  closingCta?: {
    text: string;
    buttonText?: string;
    buttonLink?: string;
  };
  sourceLink?: { label: string; url: string };
  series?: { title: string; body: string; links?: { label: string; slug: string }[] };
}

export const filterCategories = [
  "All",
  "VR",
  "VR Training",
  "VR Showroom",
  "AI",
  "Hologram",
  "3D Hologram",
  "Transparent LED",
  "WebAR",
  "HoloSpin",
  "HoloNet",
  "Föreläsning",
];

function mapCase(row: any, lang: string): CaseStudy {
  const isSv = lang === "sv";
  const content = isSv ? (row.content_sv || {}) : (row.content_en || row.content_sv || {});

  const caseStudy: CaseStudy = {
    id: row.slug,
    title: content.title || row.slug,
    subtitle: content.subtitle || "",
    client: row.client,
    agency: row.agency || undefined,
    categories: row.categories || [],
    image: row.hero_image_path || "",
    imageAlt: row.image_alt || "",
    video: row.video_url || undefined,
    inlineImage: row.inline_image_path || undefined,
    inlineImageAlt: row.inline_image_alt || undefined,
    gallery: Array.isArray(content.gallery) && content.gallery.length > 0 ? content.gallery : undefined,

    date: row.case_date || "",
    summary: content.summary || "",
    challenge: Array.isArray(content.challenge) ? content.challenge : (content.challenge || ""),
    solution: content.solution || "",
    results: content.results || [],
    experience: content.experience || undefined,
    businessImpact: content.businessImpact || undefined,
    whyMatters: content.whyMatters || undefined,
    adaptableFor: content.adaptableFor || undefined,
    technologies: content.technologies || undefined,
    process: content.process || undefined,
    technicalImplementation: content.technicalImplementation || undefined,
    lessons: content.lessons || undefined,
    closingCta: content.closingCta ? {
      text: content.closingCta.text || "",
      buttonText: content.closingCta.buttonText || "",
      buttonLink: content.closingCta.buttonLink || "https://calendly.com/sutekistudios/strategic-project-discussion",
    } : undefined,
    sourceLink: content.sourceLink?.url ? { label: content.sourceLink.label || content.sourceLink.url, url: content.sourceLink.url } : undefined,
    series: content.series?.title ? {
      title: content.series.title,
      body: content.series.body || "",
      links: Array.isArray(content.series.links) ? content.series.links : [],
    } : undefined,
  };

  return caseStudy;
}

export type CaseLang = "sv" | "en";

export function useCases(lang?: CaseLang) {
  const { i18n } = useTranslation();
  const language: string = lang ?? i18n.language;
  return useQuery({
    queryKey: ["cases", language],
    queryFn: async () => {
      const { data, error } = await supabase
        .from("cases")
        .select("*")
        .eq("published", true)
        .order("case_date", { ascending: false });
      if (error) throw error;
      return (data || []).filter((row) => isPublicCaseSlug(row.slug)).map((row) => mapCase(row, language));
    },
    staleTime: 5 * 60 * 1000,
  });
}

export function useCaseBySlug(slug: string | undefined, lang?: CaseLang) {
  const { i18n } = useTranslation();
  const language: string = lang ?? i18n.language;
  return useQuery({
    queryKey: ["case", slug, language],
    queryFn: async () => {
      if (!slug || !isPublicCaseSlug(slug)) return null;
      const { data, error } = await supabase
        .from("cases")
        .select("*")
        .eq("slug", slug)
        .eq("published", true)
        .maybeSingle();
      if (error) throw error;
      return data && isPublicCaseSlug(data.slug) ? mapCase(data, language) : null;
    },
    enabled: !!slug,
    staleTime: 5 * 60 * 1000,
  });
}
