Localization Setup

import Foundation
import SwiftUI

/// Manages app localization and language preferences.
///
/// Usage:
/// ```swift
/// // Access current language
/// let manager = LocalizationManager.shared
/// print(manager.currentLanguageCode)  // "en"
///
/// // Change language (requires app restart for full effect)
/// manager.setLanguage("es")
///
/// // Get display name
/// manager.displayName(for: "ja")  // "Japanese"
/// ```
@MainActor
@Observable
final class LocalizationManager {

    // MARK: - Singleton

    static let shared = LocalizationManager()

    // MARK: - Properties

    /// Current language code (e.g., "en", "es", "ja")
    private(set) var currentLanguageCode: String

    /// Current locale based on selected language
    var currentLocale: Locale {
        Locale(identifier: currentLanguageCode)
    }

    /// Languages supported by the app (from bundle localizations)
    var supportedLanguages: [String] {
        Bundle.main.localizations
            .filter { $0 != "Base" }
            .sorted()
    }

    /// Language codes with their display names
    var languageOptions: [(code: String, name: String)] {
        supportedLanguages.map { code in
            (code: code, name: displayName(for: code))
        }
    }

    // MARK: - Initialization

    private init() {
        // Get preferred language or default to English
        currentLanguageCode = Locale.preferredLanguages.first?.components(separatedBy: "-").first ?? "en"
    }

    // MARK: - Language Management

    /// Set the app language.
    ///
    /// - Parameter code: Language code (e.g., "en", "es", "ja")
    /// - Note: Full language change requires app restart.
    ///         For SwiftUI views, use `.environment(\.locale, locale)` modifier.
    func setLanguage(_ code: String) {
        guard supportedLanguages.contains(code) else {
            print("⚠️ Language '\(code)' not supported. Available: \(supportedLanguages)")
            return
        }

        currentLanguageCode = code

        // Update system preference (takes effect on next launch)
        UserDefaults.standard.set([code], forKey: "AppleLanguages")
        UserDefaults.standard.synchronize()
    }

    /// Get localized display name for a language code.
    ///
    /// - Parameter code: Language code (e.g., "en", "es")
    /// - Returns: Display name in current locale (e.g., "English", "Spanish")
    func displayName(for code: String) -> String {
        Locale.current.localizedString(forLanguageCode: code) ?? code
    }

    /// Get native display name for a language code.
    ///
    /// - Parameter code: Language code (e.g., "en", "es")
    /// - Returns: Display name in that language (e.g., "English", "Español")
    func nativeDisplayName(for code: String) -> String {
        Locale(identifier: code).localizedString(forLanguageCode: code) ?? code
    }

    /// Check if current language is RTL (right-to-left).
    var isRightToLeft: Bool {
        Locale.characterDirection(forLanguage: currentLanguageCode) == .rightToLeft
    }

    /// Get the layout direction for current language.
    var layoutDirection: LayoutDirection {
        isRightToLeft ? .rightToLeft : .leftToRight
    }
}

// MARK: - SwiftUI Environment Integration

/// Environment key for LocalizationManager
private struct LocalizationManagerKey: EnvironmentKey {
    @MainActor static let defaultValue = LocalizationManager.shared
}

extension EnvironmentValues {
    var localizationManager: LocalizationManager {
        get { self[LocalizationManagerKey.self] }
        set { self[LocalizationManagerKey.self] = newValue }
    }
}

// MARK: - Language Picker View

/// A picker for selecting the app language.
///
/// Usage:
/// ```swift
/// LanguagePickerView()
/// ```
struct LanguagePickerView: View {
    @Environment(\.localizationManager) private var manager

    @State private var selectedLanguage: String = ""

    var body: some View {
        Picker("Language", selection: $selectedLanguage) {
            ForEach(manager.languageOptions, id: \.code) { option in
                HStack {
                    Text(option.name)
                    if option.code != manager.currentLanguageCode {
                        Text("(\(manager.nativeDisplayName(for: option.code)))")
                            .foregroundStyle(.secondary)
                    }
                }
                .tag(option.code)
            }
        }
        .onAppear {
            selectedLanguage = manager.currentLanguageCode
        }
        .onChange(of: selectedLanguage) { _, newValue in
            if newValue != manager.currentLanguageCode {
                manager.setLanguage(newValue)
                showRestartAlert()
            }
        }
    }

    private func showRestartAlert() {
        // Note: In production, show an alert explaining restart is needed
        print("Language changed. Restart app to apply changes.")
    }
}

// MARK: - Locale Environment Modifier

extension View {
    /// Apply localization manager's locale to the view hierarchy.
    func withLocalization() -> some View {
        self.environment(\.locale, LocalizationManager.shared.currentLocale)
            .environment(\.layoutDirection, LocalizationManager.shared.layoutDirection)
    }
}

// MARK: - Preview Helpers

#if DEBUG
extension View {
    /// Preview this view in multiple locales.
    func previewInLocales(_ locales: [String] = ["en", "es", "ja", "ar"]) -> some View {
        ForEach(locales, id: \.self) { locale in
            self
                .environment(\.locale, Locale(identifier: locale))
                .environment(
                    \.layoutDirection,
                     Locale.characterDirection(forLanguage: locale) == .rightToLeft
                        ? .rightToLeft : .leftToRight
                )
                .previewDisplayName(Locale.current.localizedString(forIdentifier: locale) ?? locale)
        }
    }
}
#endif

import SwiftUI

// MARK: - Locale Preview Modifiers

#if DEBUG

/// Preview modifier for testing localization.
///
/// Usage:
/// ```swift
/// #Preview {
///     ContentView()
///         .localePreview("es")
/// }
/// ```
extension View {
    /// Preview in a specific locale.
    func localePreview(_ identifier: String) -> some View {
        let locale = Locale(identifier: identifier)
        let isRTL = Locale.characterDirection(forLanguage: identifier) == .rightToLeft

        return self
            .environment(\.locale, locale)
            .environment(\.layoutDirection, isRTL ? .rightToLeft : .leftToRight)
    }

    /// Preview in multiple locales at once.
    func multiLocalePreview(
        _ identifiers: [String] = ["en", "es", "de", "ja", "ar"]
    ) -> some View {
        ForEach(identifiers, id: \.self) { identifier in
            self.localePreview(identifier)
                .previewDisplayName(
                    Locale.current.localizedString(forIdentifier: identifier) ?? identifier
                )
        }
    }
}

// MARK: - Preview Providers

/// Preview wrapper for testing localization in different locales.
///
/// Usage:
/// ```swift
/// #Preview {
///     LocalizedPreview {
///         ContentView()
///     }
/// }
/// ```
struct LocalizedPreview<Content: View>: View {
    let content: Content
    let locales: [String]

    init(
        locales: [String] = ["en", "es", "ja", "ar"],
        @ViewBuilder content: () -> Content
    ) {
        self.locales = locales
        self.content = content()
    }

    var body: some View {
        NavigationStack {
            List {
                ForEach(locales, id: \.self) { locale in
                    Section(header: Text(localeName(for: locale))) {
                        content
                            .environment(\.locale, Locale(identifier: locale))
                            .environment(
                                \.layoutDirection,
                                 isRTL(locale) ? .rightToLeft : .leftToRight
                            )
                    }
                }
            }
        }
    }

    private func localeName(for identifier: String) -> String {
        let native = Locale(identifier: identifier)
            .localizedString(forLanguageCode: identifier) ?? identifier
        let english = Locale(identifier: "en")
            .localizedString(forLanguageCode: identifier) ?? identifier
        return "\(native) (\(english))"
    }

    private func isRTL(_ identifier: String) -> Bool {
        Locale.characterDirection(forLanguage: identifier) == .rightToLeft
    }
}

// MARK: - RTL Preview

/// Preview specifically for testing RTL layout.
///
/// Usage:
/// ```swift
/// #Preview {
///     RTLPreview {
///         MyView()
///     }
/// }
/// ```
struct RTLPreview<Content: View>: View {
    let content: Content

    init(@ViewBuilder content: () -> Content) {
        self.content = content()
    }

    var body: some View {
        HStack(spacing: 0) {
            VStack {
                Text("LTR (English)")
                    .font(.caption)
                    .padding(.bottom, 4)
                content
                    .environment(\.locale, Locale(identifier: "en"))
                    .environment(\.layoutDirection, .leftToRight)
            }
            .frame(maxWidth: .infinity)

            Divider()

            VStack {
                Text("RTL (Arabic)")
                    .font(.caption)
                    .padding(.bottom, 4)
                content
                    .environment(\.locale, Locale(identifier: "ar"))
                    .environment(\.layoutDirection, .rightToLeft)
            }
            .frame(maxWidth: .infinity)
        }
    }
}

// MARK: - Dynamic Type + Localization Preview

/// Preview for testing localization with different Dynamic Type sizes.
///
/// Usage:
/// ```swift
/// #Preview {
///     DynamicTypeLocalePreview(locale: "de") {
///         MyView()
///     }
/// }
/// ```
struct DynamicTypeLocalePreview<Content: View>: View {
    let content: Content
    let locale: String
    let sizes: [DynamicTypeSize]

    init(
        locale: String = "en",
        sizes: [DynamicTypeSize] = [.small, .large, .xxxLarge],
        @ViewBuilder content: () -> Content
    ) {
        self.content = content()
        self.locale = locale
        self.sizes = sizes
    }

    var body: some View {
        ForEach(sizes, id: \.self) { size in
            content
                .environment(\.locale, Locale(identifier: locale))
                .environment(\.dynamicTypeSize, size)
                .previewDisplayName("\(locale) - \(String(describing: size))")
        }
    }
}

// MARK: - Common Locale Sets

/// Predefined sets of locales for different testing scenarios.
enum LocalePresets {
    /// Common Western languages
    static let western = ["en", "es", "fr", "de", "it", "pt"]

    /// Asian languages
    static let asian = ["ja", "zh-Hans", "zh-Hant", "ko"]

    /// RTL languages
    static let rtl = ["ar", "he", "fa"]

    /// Comprehensive set
    static let comprehensive = western + asian + rtl

    /// Quick test set (one from each category)
    static let quick = ["en", "es", "ja", "ar"]

    /// Languages with long words (for layout testing)
    static let longWords = ["de", "fi", "hu"]
}

// MARK: - Example Previews

#Preview("Quick Locale Test") {
    VStack(spacing: 20) {
        Text("Hello, World!")
        Text(Date(), format: .dateTime)
        Text(1234.56, format: .currency(code: "USD"))
    }
    .multiLocalePreview(LocalePresets.quick)
}

#Preview("RTL Comparison") {
    RTLPreview {
        HStack {
            Image(systemName: "arrow.right")
            Text("Direction Test")
            Spacer()
            Image(systemName: "chevron.right")
        }
        .padding()
    }
}

#endif

import Foundation

/// Type-safe localized strings.
///
/// Usage:
/// ```swift
/// Text(L10n.appName)
/// Text(L10n.Onboarding.welcomeTitle)
/// Text(L10n.itemsCount(5))
/// ```
///
/// Generated structure mirrors String Catalog organization.
/// Add new strings to String Catalog and update this file.
enum L10n {

    // MARK: - General

    /// App name
    static let appName = String(localized: "app_name", defaultValue: "MyApp")

    /// Common button titles
    static let ok = String(localized: "ok", defaultValue: "OK")
    static let cancel = String(localized: "cancel", defaultValue: "Cancel")
    static let done = String(localized: "done", defaultValue: "Done")
    static let save = String(localized: "save", defaultValue: "Save")
    static let delete = String(localized: "delete", defaultValue: "Delete")
    static let edit = String(localized: "edit", defaultValue: "Edit")
    static let close = String(localized: "close", defaultValue: "Close")
    static let retry = String(localized: "retry", defaultValue: "Retry")

    // MARK: - Onboarding

    enum Onboarding {
        static let welcomeTitle = String(localized: "onboarding.welcome.title",
                                         defaultValue: "Welcome")
        static let welcomeMessage = String(localized: "onboarding.welcome.message",
                                           defaultValue: "Thanks for downloading our app!")
        static let getStarted = String(localized: "onboarding.get_started",
                                       defaultValue: "Get Started")
        static let skip = String(localized: "onboarding.skip",
                                 defaultValue: "Skip")
        static let next = String(localized: "onboarding.next",
                                 defaultValue: "Next")
    }

    // MARK: - Settings

    enum Settings {
        static let title = String(localized: "settings.title",
                                  defaultValue: "Settings")
        static let appearance = String(localized: "settings.appearance",
                                       defaultValue: "Appearance")
        static let notifications = String(localized: "settings.notifications",
                                          defaultValue: "Notifications")
        static let privacy = String(localized: "settings.privacy",
                                    defaultValue: "Privacy")
        static let about = String(localized: "settings.about",
                                  defaultValue: "About")
        static let language = String(localized: "settings.language",
                                     defaultValue: "Language")
        static let version = String(localized: "settings.version",
                                    defaultValue: "Version")
    }

    // MARK: - Errors

    enum Error {
        static let genericTitle = String(localized: "error.generic.title",
                                         defaultValue: "Error")
        static let genericMessage = String(localized: "error.generic.message",
                                           defaultValue: "Something went wrong. Please try again.")
        static let networkTitle = String(localized: "error.network.title",
                                         defaultValue: "Network Error")
        static let networkMessage = String(localized: "error.network.message",
                                           defaultValue: "Please check your internet connection.")
        static let saveFailed = String(localized: "error.save_failed",
                                       defaultValue: "Failed to save. Please try again.")
        static let loadFailed = String(localized: "error.load_failed",
                                       defaultValue: "Failed to load data.")

        /// Custom error message with interpolation
        static func custom(_ message: String) -> String {
            String(localized: "error.custom \(message)",
                   defaultValue: "Error: \(message)")
        }
    }

    // MARK: - Plurals

    /// Plural-aware item count
    /// Requires plural variations in String Catalog:
    /// - zero: "No items"
    /// - one: "1 item"
    /// - other: "%lld items"
    static func itemsCount(_ count: Int) -> String {
        String(localized: "items.count \(count)",
               defaultValue: "\(count) items")
    }

    /// Plural-aware file count
    static func filesCount(_ count: Int) -> String {
        String(localized: "files.count \(count)",
               defaultValue: "\(count) files")
    }

    /// Days remaining
    static func daysRemaining(_ count: Int) -> String {
        String(localized: "days.remaining \(count)",
               defaultValue: "\(count) days remaining")
    }

    // MARK: - Interpolation Examples

    /// Greeting with name
    static func greeting(_ name: String) -> String {
        String(localized: "greeting \(name)",
               defaultValue: "Hello, \(name)!")
    }

    /// Welcome back message
    static func welcomeBack(_ name: String) -> String {
        String(localized: "welcome_back \(name)",
               defaultValue: "Welcome back, \(name)")
    }

    /// Last updated timestamp
    static func lastUpdated(_ date: Date) -> String {
        String(localized: "last_updated \(date, format: .dateTime)",
               defaultValue: "Last updated: \(date.formatted())")
    }

    // MARK: - Accessibility

    enum Accessibility {
        static let closeButton = String(localized: "accessibility.close_button",
                                        defaultValue: "Close")
        static let backButton = String(localized: "accessibility.back_button",
                                       defaultValue: "Go back")
        static let menuButton = String(localized: "accessibility.menu_button",
                                       defaultValue: "Open menu")
        static let favoriteButton = String(localized: "accessibility.favorite_button",
                                           defaultValue: "Add to favorites")
        static let shareButton = String(localized: "accessibility.share_button",
                                        defaultValue: "Share")

        static func selected(_ isSelected: Bool) -> String {
            isSelected
                ? String(localized: "accessibility.selected", defaultValue: "Selected")
                : String(localized: "accessibility.not_selected", defaultValue: "Not selected")
        }
    }
}

// MARK: - String Catalog Key Reference

/*
 Add these keys to your Localizable.xcstrings file:

 General:
 - app_name
 - ok
 - cancel
 - done
 - save
 - delete
 - edit
 - close
 - retry

 Onboarding:
 - onboarding.welcome.title
 - onboarding.welcome.message
 - onboarding.get_started
 - onboarding.skip
 - onboarding.next

 Settings:
 - settings.title
 - settings.appearance
 - settings.notifications
 - settings.privacy
 - settings.about
 - settings.language
 - settings.version

 Errors:
 - error.generic.title
 - error.generic.message
 - error.network.title
 - error.network.message
 - error.save_failed
 - error.load_failed
 - error.custom %@

 Plurals (with variations):
 - items.count %lld
 - files.count %lld
 - days.remaining %lld

 Interpolation:
 - greeting %@
 - welcome_back %@
 - last_updated %@

 Accessibility:
 - accessibility.close_button
 - accessibility.back_button
 - accessibility.menu_button
 - accessibility.favorite_button
 - accessibility.share_button
 - accessibility.selected
 - accessibility.not_selected
 */