import { courseOverviews } from "@/data/courseOverviews";
import { getTraitsForDimension, portraitDimensions } from "@/data/portraitData";
import type { HeroTab, HeroTabCourseGroup, HeroTabTraitGroup } from "./defaultContent";

const dimensionTitleToKey: Record<string, string> = {
  "Bold Visionary Leader": "boldVisionaryLeader",
  "Balanced Person": "balancedPerson",
  "Inspiring Communicator": "inspiringCommunicator",
  "Resilient Problem Solver": "resilientProblemSolver",
  "Respectful Relationship Builder": "respectfulRelationshipBuilder",
  "Caring Citizen": "caringCitizen",
};

const coreSubjectCategory: Record<string, string> = {
  Science: "STEM",
  Mathematics: "STEM",
  "ELA / Literacy": "Humanities & Language",
  Humanities: "Humanities & Language",
  "World Languages": "Humanities & Language",
  Entrepreneurship: "Leadership & Life Skills",
  "Path to Self-Efficacy": "Leadership & Life Skills",
  "Music / Performing Arts": "Arts & Wellness",
  "Physical Education / Health": "Arts & Wellness",
};

const defaultDesktopPositions: Record<string, string> = {
  boldVisionaryLeader: "top-0 left-1/2 -translate-x-1/2",
  respectfulRelationshipBuilder: "top-[25%] -left-4",
  resilientProblemSolver: "top-[25%] -right-4",
  inspiringCommunicator: "bottom-[25%] -left-4",
  caringCitizen: "bottom-[25%] -right-4",
  balancedPerson: "bottom-2 left-1/2 -translate-x-1/2",
};

function buildTraitGroups(dimensionKey: string): HeroTabTraitGroup[] {
  const traits = getTraitsForDimension(dimensionKey);
  const grouped = traits.reduce<Record<string, HeroTabTraitGroup["traits"]>>((acc, item) => {
    if (!acc[item.mindset]) acc[item.mindset] = [];
    acc[item.mindset].push({ trait: item.trait, pct: item.pct });
    return acc;
  }, {});

  return Object.entries(grouped).map(([mindset, traitItems]) => ({
    mindset,
    traits: traitItems,
  }));
}

function buildCourseGroups(dimensionKey: string): HeroTabCourseGroup[] {
  const courses = courseOverviews
    .map((course) => {
      const match = course.portraitDimensions.find((pd) => dimensionTitleToKey[pd.name] === dimensionKey);
      if (!match) return null;
      const category =
        course.type === "core" ? coreSubjectCategory[course.name] || "Core" : course.strand || "DNA Strand";
      return {
        name: course.name,
        emoji: course.emoji,
        slug: course.slug,
        href: `/course/${course.slug}`,
        pct: match.pct,
        category,
      };
    })
    .filter(Boolean) as Array<{
    name: string;
    emoji: string;
    slug: string;
    href: string;
    pct: number;
    category: string;
  }>;

  const grouped = courses.reduce<Record<string, HeroTabCourseGroup["courses"]>>((acc, course) => {
    if (!acc[course.category]) acc[course.category] = [];
    acc[course.category].push({
      name: course.name,
      emoji: course.emoji,
      slug: course.slug,
      href: course.href,
      pct: course.pct,
    });
    return acc;
  }, {});

  return Object.entries(grouped)
    .map(([category, categoryCourses]) => ({
      category,
      courses: [...categoryCourses].sort((a, b) => b.pct - a.pct),
    }))
    .sort((a, b) => Math.max(...b.courses.map((c) => c.pct)) - Math.max(...a.courses.map((c) => c.pct)));
}

/** Build the default interactive tab data from portrait + course catalogs. */
export function buildDefaultHeroTabs(): HeroTab[] {
  return portraitDimensions.map((dim, index) => ({
    key: dim.key,
    title: dim.title,
    emoji: dim.emoji,
    color: dim.color,
    desc: dim.desc,
    buttonLabel: dim.key === "balancedPerson" ? "Balanced Human" : dim.title,
    iconSrc: "",
    position: {
      desktop: defaultDesktopPositions[dim.key] ?? "top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2",
      mobileOrder: index,
    },
    traitGroups: buildTraitGroups(dim.key),
    courseGroups: buildCourseGroups(dim.key),
  }));
}

export function createEmptyHeroTab(order = 0): HeroTab {
  const key = `tab-${Date.now()}-${order}`;
  return {
    key,
    title: "New Tab",
    emoji: "✨",
    color: "valencia",
    desc: "",
    buttonLabel: "New Tab",
    iconSrc: "",
    position: {
      desktop: "top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2",
      mobileOrder: order,
    },
    traitGroups: [],
    courseGroups: [],
  };
}