export const SUPPORTED_LOCALES = [
  "en", "tr", "fr", "de", "es", "pt-PT",
  "it", "nl", "ja", "ko", "ru", "zh-CN", "ar"
] as const;

export type SupportedLocaleCode = (typeof SUPPORTED_LOCALES)[number];

export const DEFAULT_LOCALE: SupportedLocaleCode = "en";
export const FALLBACK_LOCALE: SupportedLocaleCode = "en";

export const supportedLocales: Record<SupportedLocaleCode, Locale> = {
  en: {
    code: "en",
    name: "English",
    englishName: "English",
    flag: "🇺🇸",
    dir: "ltr",
  },
  ar: {
    code: "ar",
    name: "العربية",
    englishName: "Arabic",
    flag: "🇸🇦",
    dir: "rtl", // Right-to-left
  },
  // ... other locales
};

{
  "Navigation.Home": "Home",
  "Navigation.Articles": "Articles",
  "Navigation.Events": "Events",
  "Profile.Edit": "Edit Profile",
  "Profile.Follow": "Follow",
  "Profile.Following": "Following",
  "Story.ReadMore": "Read more",
  "Story.PublishedAt": "Published {{date}}",
  "Comment.Reply": "Reply",
  "Comment.Delete": "Delete"
}

{
  "Navigation.Home": "Ana Sayfa",
  "Navigation.Articles": "Makaleler",
  "Navigation.Events": "Etkinlikler",
  "Profile.Edit": "Profili Düzenle",
  "Profile.Follow": "Takip Et",
  "Profile.Following": "Takip Ediliyor",
  "Story.ReadMore": "Devamını oku",
  "Story.PublishedAt": "Yayınlanma {{date}}",
  "Comment.Reply": "Yanıtla",
  "Comment.Delete": "Sil"
}

import i18next from "i18next";
import { initReactI18next } from "react-i18next";
import en from "@/messages/en.json";
import tr from "@/messages/tr.json";
// ... import all locales

i18next
  .use(initReactI18next)
  .init({
    resources: {
      en: { translation: en },
      tr: { translation: tr },
      // ... all locales
    },
    lng: "en", // Default language
    fallbackLng: "en",
    interpolation: {
      escapeValue: false, // React already escapes
    },
  });

import { useNavigate, useParams } from "@tanstack/react-router";
import { SUPPORTED_LOCALES, supportedLocales } from "@/config";

export function LocaleSwitcher() {
  const { locale } = useParams({ from: "/$locale" });
  const navigate = useNavigate();

  const handleLocaleChange = (newLocale: string) => {
    // Redirect to same path with new locale
    navigate({
      to: window.location.pathname.replace(`/${locale}/`, `/${newLocale}/`),
    });
  };

  return (
    <select value={locale} onChange={(e) => handleLocaleChange(e.target.value)}>
      {SUPPORTED_LOCALES.map((code) => (
        <option key={code} value={code}>
          {supportedLocales[code].flag} {supportedLocales[code].name}
        </option>
      ))}
    </select>
  );
}

-- name: GetProfileBySlug :one
SELECT 
  p.id, p.slug, p.kind, p.profile_picture_uri,
  pt.locale_code, pt.title, pt.description
FROM "profile" p
JOIN "profile_tx" pt ON pt.profile_id = p.id
WHERE p.slug = sqlc.arg(slug)
  -- 3-TIER FALLBACK SUBQUERY
  AND pt.locale_code = (
    SELECT ptx.locale_code FROM "profile_tx" ptx
    WHERE ptx.profile_id = p.id
    ORDER BY CASE
      WHEN ptx.locale_code = sqlc.arg(locale_code) THEN 0  -- Tier 1: Requested locale
      WHEN ptx.locale_code = p.default_locale THEN 1       -- Tier 2: Entity's default
      ELSE 2                                                -- Tier 3: Any available
    END
    LIMIT 1
  )
LIMIT 1;

-- name: GetStoryBySlug :one
SELECT 
  s.id, s.slug, s.kind, s.cover_picture_uri,
  st.locale_code, st.title, st.summary, st.content
FROM "story" s
JOIN "story_tx" st ON st.story_id = s.id
WHERE s.slug = sqlc.arg(slug)
  AND st.locale_code = (
    SELECT stx.locale_code FROM "story_tx" stx
    WHERE stx.story_id = s.id
    ORDER BY CASE
      WHEN stx.locale_code = sqlc.arg(locale_code) THEN 0
      -- Use author profile's default locale as fallback
      WHEN stx.locale_code = (
        SELECT p.default_locale FROM "profile" p WHERE p.id = s.author_profile_id
      ) THEN 1
      ELSE 2
    END
    LIMIT 1
  )
LIMIT 1;

package profiles

import "context"

func AutoTranslatePage(
    ctx context.Context,
    repo Repository,
    aiService AIService,
    pageID string,
    sourceLocale string,
) error {
    page, _ := repo.GetPageByID(ctx, pageID, sourceLocale)

    targetLocales := []string{"en", "tr", "fr", "de", "es", "pt-PT", "it", "nl", "ja", "ko", "ru", "zh-CN", "ar"}

    for _, targetLocale := range targetLocales {
        if targetLocale == sourceLocale {
            continue // Skip source locale
        }

        // Call AI service for translation
        translated, _ := aiService.Translate(ctx, AITranslateRequest{
            SourceLocale: sourceLocale,
            TargetLocale: targetLocale,
            Title:        page.Title,
            Summary:      page.Summary,
            Content:      page.Content,
        })

        // Save translated version
        _ = repo.CreatePageTranslation(ctx, &ProfilePageTranslation{
            ProfilePageID: pageID,
            LocaleCode:    targetLocale,
            Title:         translated.Title,
            Summary:       translated.Summary,
            Content:       translated.Content,
        })
    }

    return nil
}

function detectPreferredLocale(requestContext: RequestContext | undefined): SupportedLocaleCode {
  // 1. Check cookie
  const cookieHeader = requestContext?.cookieHeader;
  if (cookieHeader !== undefined) {
    const match = cookieHeader.match(/(?:^|;\s*)SITE_LOCALE=([^;]+)/);
    if (match !== null && isValidLocale(match[1])) {
      return match[1];
    }
  }

  // 2. Check Accept-Language
  const acceptLanguage = requestContext?.acceptLanguageHeader;
  if (acceptLanguage !== undefined) {
    const matched = parseAcceptLanguage(acceptLanguage);
    if (matched !== null) return matched;
  }

  // 3. Domain default (if custom domain)
  const domainConfig = requestContext?.domainConfiguration;
  if (domainConfig?.defaultCulture !== undefined) {
    if (isValidLocale(domainConfig.defaultCulture)) {
      return domainConfig.defaultCulture;
    }
  }

  // 4. System default
  return DEFAULT_LOCALE;
}

export const Route = createFileRoute("/")({
  loader: async ({ context }) => {
    const preferredLocale = detectPreferredLocale(context.requestContext);

    // Redirect root to /{locale}
    throw redirect({
      to: "/$locale",
      params: { locale: preferredLocale },
    });
  },
});

export function formatDate(date: string | Date, locale: string): string {
  const dateObj = typeof date === "string" ? new Date(date) : date;

  return new Intl.DateTimeFormat(locale, {
    year: "numeric",
    month: "long",
    day: "numeric",
  }).format(dateObj);
}

export function formatRelativeTime(date: string | Date, locale: string): string {
  const dateObj = typeof date === "string" ? new Date(date) : date;
  const now = new Date();
  const diffInSeconds = (now.getTime() - dateObj.getTime()) / 1000;

  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });

  if (diffInSeconds < 60) return rtf.format(-Math.floor(diffInSeconds), "second");
  if (diffInSeconds < 3600) return rtf.format(-Math.floor(diffInSeconds / 60), "minute");
  if (diffInSeconds < 86400) return rtf.format(-Math.floor(diffInSeconds / 3600), "hour");
  return rtf.format(-Math.floor(diffInSeconds / 86400), "day");
}