//import Foundation
//import XCTest
//@testable import bitchat
//
//private let localizationTestsDirectoryURL = URL(fileURLWithPath: #filePath).deletingLastPathComponent()
//private let testsRootURL = localizationTestsDirectoryURL.deletingLastPathComponent()
//private let repoRootURL = testsRootURL.deletingLastPathComponent()
//
//final class LocalizationCatalogTests: XCTestCase {
//  // Ensures every app locale includes exactly the same keys as Base.
//  func testAppCatalogLocaleParity() throws {
//    let context = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
//    assertLocaleParity(context: context, catalogName: "App")
//  }
//
//  // Verifies format placeholders stay consistent across app locales.
//  func testAppCatalogPlaceholderConsistency() throws {
//    let context = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
//    assertPlaceholderConsistency(context: context, catalogName: "App")
//  }
//
//  // Guards a core set of app strings from going empty per locale.
//  func testAppPrimaryKeysNonEmpty() throws {
//    let context = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
//    let primaryKeys = try loadPrimaryKeys().app
//    assertPrimaryKeysPresent(context: context, keys: primaryKeys, catalogName: "App")
//  }
//
//  // Ensures every share extension locale matches Base key coverage.
//  func testShareExtensionCatalogLocaleParity() throws {
//    let context = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
//    assertLocaleParity(context: context, catalogName: "ShareExtension")
//  }
//
//  // Verifies share extension placeholders align across locales.
//  func testShareExtensionCatalogPlaceholderConsistency() throws {
//    let context = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
//    assertPlaceholderConsistency(context: context, catalogName: "ShareExtension")
//  }
//
//  // Confirms critical share extension strings remain non-empty per locale.
//  func testShareExtensionPrimaryKeysNonEmpty() throws {
//    let context = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
//    let primaryKeys = try loadPrimaryKeys().shareExtension
//    assertPrimaryKeysPresent(context: context, keys: primaryKeys, catalogName: "ShareExtension")
//  }
//
//  // Validates that configured locales contain expected string values.
//  func testLocalizationExpectedValues() throws {
//    let appContext = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
//    let shareContext = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
//    let config = try loadPrimaryKeys()
//    
//    guard let testLocales = config.testLocales else {
//      // If no testLocales specified, skip this test
//      return
//    }
//    
//    guard let expectedValues = config.expectedValues else {
//      XCTFail("No expectedValues configured in PrimaryLocalizationKeys.json")
//      return
//    }
//    
//    // Loop through each locale to test
//    for locale in testLocales {
//      guard let localeExpectedValues = expectedValues[locale] else {
//        XCTFail("No expected values configured for locale '\(locale)' in PrimaryLocalizationKeys.json")
//        continue
//      }
//      
//      // Test each expected key/value pair for this locale
//      for (key, expectedValue) in localeExpectedValues {
//        if config.app.contains(key) {
//          assertLocaleStringValue(context: appContext, locale: locale, key: key, expectedValue: expectedValue, catalogName: "App")
//        } else if config.shareExtension.contains(key) {
//          assertLocaleStringValue(context: shareContext, locale: locale, key: key, expectedValue: expectedValue, catalogName: "ShareExtension")
//        }
//      }
//    }
//  }
//
//  // Ensures configured test locales are present and complete.
//  func testConfiguredLocalesCompleteness() throws {
//    let appContext = try loadContext(relativePath: "bitchat/Localizable.xcstrings")
//    let shareContext = try loadContext(relativePath: "bitchatShareExtension/Localization/Localizable.xcstrings")
//    let config = try loadPrimaryKeys()
//    
//    guard let testLocales = config.testLocales else {
//      // If no testLocales specified, skip this test
//      return
//    }
//    
//    let baseLocale = appContext.baseLocale
//    let baseAppKeys = appContext.keysByLocale[baseLocale] ?? Set()
//    let baseShareKeys = shareContext.keysByLocale[baseLocale] ?? Set()
//    
//    for locale in testLocales {
//      // Skip base locale comparison with itself
//      if locale == baseLocale { continue }
//      
//      // Verify locale is present in both catalogs
//      XCTAssertTrue(appContext.locales.contains(locale), "Locale '\(locale)' missing from app catalog")
//      XCTAssertTrue(shareContext.locales.contains(locale), "Locale '\(locale)' missing from share extension catalog")
//      
//      // Verify locale has same number of keys as base locale
//      let appLocaleKeys = appContext.keysByLocale[locale] ?? Set()
//      XCTAssertEqual(appLocaleKeys.count, baseAppKeys.count, "Locale '\(locale)' app catalog missing keys compared to \(baseLocale)")
//      
//      let shareLocaleKeys = shareContext.keysByLocale[locale] ?? Set()
//      XCTAssertEqual(shareLocaleKeys.count, baseShareKeys.count, "Locale '\(locale)' share extension catalog missing keys compared to \(baseLocale)")
//    }
//  }
//
//  // MARK: - Assertions
//
//  private func assertLocaleParity(context: CatalogContext, catalogName: String, file: StaticString = #filePath, line: UInt = #line) {
//    let baseLocale = context.baseLocale
//    guard let baseKeys = context.keysByLocale[baseLocale] else {
//      return XCTFail("Missing base locale \(baseLocale) in \(catalogName) catalog", file: file, line: line)
//    }
//
//    for (locale, keys) in context.keysByLocale.sorted(by: { $0.key < $1.key }) {
//      XCTAssertEqual(keys, baseKeys, "Locale \(locale) has key mismatch in \(catalogName) catalog", file: file, line: line)
//    }
//  }
//
//  private func assertPlaceholderConsistency(context: CatalogContext, catalogName: String, file: StaticString = #filePath, line: UInt = #line) {
//    let baseLocale = context.baseLocale
//    guard let baseSignatures = context.placeholderSignature[baseLocale] else {
//      return XCTFail("Missing base placeholder signature for \(catalogName)", file: file, line: line)
//    }
//
//    for (locale, localeSignatures) in context.placeholderSignature.sorted(by: { $0.key < $1.key }) {
//      guard locale != baseLocale else { continue }
//      for key in baseSignatures.keys.sorted() {
//        guard let baseMap = baseSignatures[key] else {
//          continue
//        }
//        guard let localeMap = localeSignatures[key] else {
//          return XCTFail("Key \(key) missing for locale \(locale) in \(catalogName) catalog", file: file, line: line)
//        }
//        for path in baseMap.keys.sorted() {
//          let expected = normalizedPlaceholders(baseMap[path, default: []])
//          let actual = normalizedPlaceholders(localeMap[path, default: []])
//          XCTAssertEqual(actual, expected, "Placeholder mismatch for key \(key) at \(path) in locale \(locale) (\(catalogName))", file: file, line: line)
//        }
//        for (localePath, localeTokens) in localeMap {
//          guard baseMap[localePath] == nil else { continue }
//          guard let fallback = fallbackPath(for: localePath, baseMap: baseMap) else {
//            XCTFail("Unexpected variation \(localePath) for key \(key) in locale \(locale) (\(catalogName))", file: file, line: line)
//            continue
//          }
//          let expected = normalizedPlaceholders(baseMap[fallback, default: []])
//          let actual = normalizedPlaceholders(localeTokens)
//          XCTAssertEqual(actual, expected, "Placeholder mismatch for key \(key) at \(localePath) (fallback \(fallback)) in locale \(locale) (\(catalogName))", file: file, line: line)
//        }
//      }
//    }
//  }
//
//  private func assertPrimaryKeysPresent(context: CatalogContext, keys: [String], catalogName: String, file: StaticString = #filePath, line: UInt = #line) {
//    for key in keys {
//      guard let entry = context.catalog.strings[key] else {
//        XCTFail("Missing primary key \(key) in \(catalogName) catalog", file: file, line: line)
//        continue
//      }
//      for locale in context.locales.sorted() {
//        guard let localization = entry.localizations[locale], let unit = localization.stringUnit else {
//          XCTFail("Missing localization for key \(key) in locale \(locale) (\(catalogName))", file: file, line: line)
//          continue
//        }
//        let segments = gatherSegments(from: unit)
//        XCTAssertFalse(segments.isEmpty, "No content for key \(key) in locale \(locale) (\(catalogName))", file: file, line: line)
//        for segment in segments {
//          let trimmed = segment.value.trimmingCharacters(in: .whitespacesAndNewlines)
//          XCTAssertFalse(trimmed.isEmpty, "Empty translation for key \(key) at \(segment.path) in locale \(locale) (\(catalogName))", file: file, line: line)
//        }
//      }
//    }
//  }
//
//  private func assertLocaleStringValue(context: CatalogContext, locale: String, key: String, expectedValue: String, catalogName: String, file: StaticString = #filePath, line: UInt = #line) {
//    guard let entry = context.catalog.strings[key] else {
//      XCTFail("Missing key \(key) in \(catalogName) catalog", file: file, line: line)
//      return
//    }
//    
//    guard let localization = entry.localizations[locale], let unit = localization.stringUnit else {
//      XCTFail("Missing \(locale) localization for key \(key) in \(catalogName) catalog", file: file, line: line)
//      return
//    }
//    
//    // For simple strings (non-pluralized)
//    if let actualValue = unit.value {
//      XCTAssertEqual(actualValue, expectedValue, "\(locale) translation mismatch for key \(key) in \(catalogName) catalog. Expected: '\(expectedValue)', Actual: '\(actualValue)'", file: file, line: line)
//    } else {
//      XCTFail("Key \(key) has no value in \(locale) localization for \(catalogName) catalog", file: file, line: line)
//    }
//  }
//
//  // MARK: - Loading
//
//  private func loadContext(relativePath: String) throws -> CatalogContext {
//    let catalog = try loadCatalog(relativePath: relativePath)
//    let locales = catalog.locales
//    let baseLocale = catalog.sourceLanguage
//    var keysByLocale: [String: Set<String>] = [:]
//    var placeholderSignature: [String: [String: [String: [String]]]] = [:]
//
//    for locale in locales {
//      var localeKeys: Set<String> = []
//      var localePlaceholders: [String: [String: [String]]] = [:]
//      for (key, entry) in catalog.strings {
//        guard let localization = entry.localizations[locale], let unit = localization.stringUnit else {
//          continue
//        }
//        localeKeys.insert(key)
//        let segments = gatherSegments(from: unit)
//        var pathMap: [String: [String]] = [:]
//        for segment in segments {
//          pathMap[segment.path] = placeholders(in: segment.value)
//        }
//        localePlaceholders[key] = pathMap
//      }
//      keysByLocale[locale] = localeKeys
//      placeholderSignature[locale] = localePlaceholders
//    }
//
//    return CatalogContext(catalog: catalog, locales: locales, baseLocale: baseLocale, keysByLocale: keysByLocale, placeholderSignature: placeholderSignature)
//  }
//
//  private func loadCatalog(relativePath: String) throws -> StringCatalog {
//    let url = repoRootURL.appendingPathComponent(relativePath)
//    let data = try Data(contentsOf: url)
//    return try JSONDecoder().decode(StringCatalog.self, from: data)
//  }
//
//  private func loadPrimaryKeys() throws -> PrimaryKeyConfig {
//    let url = localizationTestsDirectoryURL.appendingPathComponent("PrimaryLocalizationKeys.json")
//    let data = try Data(contentsOf: url)
//    return try JSONDecoder().decode(PrimaryKeyConfig.self, from: data)
//  }
//
//  // MARK: - Regression Tests
//  
//  /// Helper method to access the app bundle for localization testing.
//  /// This ensures tests use the actual app's Localizable.xcstrings instead of 
//  /// the test bundle, preventing false positives where localization keys are 
//  /// returned instead of translated strings.
//  private func appBundle() -> Bundle {
//    Bundle(for: ChatViewModel.self)
//  }
//
//  /// Tests to prevent regression of the pluralization format string issue
//  /// These tests ensure that String(localized:) properly handles
//  /// pluralized format strings with %#@variable@ syntax
//  func testPluralizedFormatStringsDoNotCrash() {
//    // These are the exact calls that were causing runtime errors
//    
//    // Test 1: content.accessibility.people_count with Int argument
//    XCTAssertNoThrow({
//      let result = String(
//        localized: "content.accessibility.people_count",
//        bundle: appBundle(),
//        comment: "Accessibility label announcing number of people in header"
//      )
//      XCTAssertFalse(result.isEmpty, "Should return formatted string")
//      // Verify we're getting actual localized content, not just the key
//      XCTAssertNotEqual(result, "content.accessibility.people_count", "Should return localized string, not key")
//    }(), "People count localization should not throw")
//    
//    // Test 2: location_notes.header with String and Int arguments  
//    XCTAssertNoThrow({
//      let result = String(
//        localized: "location_notes.header",
//        bundle: appBundle(),
//        comment: "Header displaying the geohash and localized note count"
//      )
//      XCTAssertFalse(result.isEmpty, "Should return formatted string")
//      // Verify we're getting actual localized content, not just the key
//      XCTAssertNotEqual(result, "location_notes.header", "Should return localized string, not key")
//    }(), "Location notes header localization should not throw")
//  }
//
//  func testFormatStringArgumentMatching() {
//    // Verify that the format strings properly handle their expected arguments
//    
//    // People count expects: %#@people@ format with Int
//    let peopleResult = String(
//      localized: "content.accessibility.people_count",
//      bundle: appBundle(),
//      comment: "Test"
//    )
//    
//    // Should not show format specifiers in the base string
//    XCTAssertFalse(peopleResult.isEmpty, "Should return non-empty string")
//    
//    // Location notes expects: #%@ • %#@note_count@ format with String, Int
//    let notesResult = String(
//      localized: "location_notes.header",
//      bundle: appBundle(),
//      comment: "Test"
//    )
//    
//    XCTAssertFalse(notesResult.isEmpty, "Should return non-empty string")
//  }
//
//  func testPluralizedStringsWithArguments() {
//    // Test the pluralized strings with actual format arguments
//    
//    // Test people count with different values
//    let testCases = [0, 1, 2, 5]
//    
//    for count in testCases {
//      let result = String(
//        format: String(localized: "content.accessibility.people_count", bundle: appBundle(), comment: "Test"),
//        locale: .current,
//        count
//      )
//      
//      // Just verify it doesn't crash and returns a reasonable string
//      XCTAssertFalse(result.isEmpty, 
//        "People count should return non-empty string for count \(count)")
//      XCTAssertTrue(result.contains("\(count)"), 
//        "Result should contain the count number for count \(count)")
//    }
//  }
//
//  func testLocationNotesHeaderWithArguments() {
//    let geohash = "abc123"
//    let testCases = [0, 1, 2, 10]
//    
//    for count in testCases {
//      let result = String(
//        format: String(localized: "location_notes.header", bundle: appBundle(), comment: "Test"),
//        locale: .current,
//        geohash, count
//      )
//      
//      // Verify basic structure is maintained
//      XCTAssertTrue(result.contains(geohash), 
//        "Result should contain geohash for count \(count)")
//      XCTAssertTrue(result.contains("\(count)"), 
//        "Result should contain count for count \(count)")
//    }
//  }
//
//  func testLocationChannelsRowTitleWithArguments() {
//    let label = "test-channel"
//    let testCases = [0, 1, 2, 5]
//    
//    for count in testCases {
//      let result = String(
//        format: String(localized: "location_channels.row_title", bundle: appBundle(), comment: "Test"),
//        locale: .current,
//        label, count
//      )
//      
//      // Verify basic structure is maintained
//      XCTAssertTrue(result.contains(label), 
//        "Result should contain label for count \(count)")
//      XCTAssertTrue(result.contains("\(count)"), 
//        "Result should contain count for count \(count)")
//    }
//  }
//
//  func testNoArgumentsLocalization() {
//    // Test that strings without arguments still work
//    let result = String(
//      localized: "common.ok",
//      bundle: appBundle(),
//      comment: "OK button text"
//    )
//    
//    XCTAssertFalse(result.isEmpty, "Simple localization should work")
//  }
//
//  func testLocalizationEdgeCases() {
//    // Test edge cases that might cause issues
//    
//    // Large numbers
//    let largeNumberResult = String(
//      format: String(localized: "content.accessibility.people_count", bundle: appBundle(), comment: "Test"),
//      locale: .current,
//      1000000
//    )
//    XCTAssertTrue(largeNumberResult.contains("1000000"), "Should handle large numbers")
//    
//    // Zero
//    let zeroResult = String(
//      format: String(localized: "content.accessibility.people_count", bundle: appBundle(), comment: "Test"),
//      locale: .current,
//      0
//    )
//    XCTAssertTrue(zeroResult.contains("0"), "Should handle zero")
//    
//    // Empty geohash (edge case)
//    let emptyGeohashResult = String(
//      format: String(localized: "location_notes.header", bundle: appBundle(), comment: "Test"),
//      locale: .current,
//      "", 1
//    )
//    XCTAssertFalse(emptyGeohashResult.isEmpty, "Should handle empty geohash")
//  }
//}
//
//// MARK: - Helpers
//
//private struct CatalogContext {
//  let catalog: StringCatalog
//  let locales: [String]
//  let baseLocale: String
//  let keysByLocale: [String: Set<String>]
//  let placeholderSignature: [String: [String: [String: [String]]]]
//}
//
//private struct StringCatalog: Decodable {
//  let sourceLanguage: String
//  let strings: [String: CatalogEntry]
//
//  var locales: [String] {
//    var localeSet: Set<String> = []
//    for entry in strings.values {
//      localeSet.formUnion(entry.localizations.keys)
//    }
//    return localeSet.sorted()
//  }
//}
//
//private struct CatalogEntry: Decodable {
//  let localizations: [String: CatalogLocalization]
//}
//
//private struct CatalogLocalization: Decodable {
//  let stringUnit: CatalogStringUnit?
//}
//
//private struct CatalogStringUnit: Decodable {
//  let state: String
//  let value: String?
//  let variations: CatalogVariations?
//  let comment: String?
//}
//
//private struct CatalogVariations: Decodable {
//  let plural: [String: [String: CatalogVariationValue]]?
//}
//
//private struct CatalogVariationValue: Decodable {
//  let stringUnit: CatalogStringUnit?
//}
//
//private struct Segment {
//  let components: [String]
//  let value: String
//
//  var path: String {
//    components.isEmpty ? "base" : components.joined(separator: ".")
//  }
//}
//
//private func gatherSegments(from unit: CatalogStringUnit, prefix: [String] = []) -> [Segment] {
//  var segments: [Segment] = []
//  if let value = unit.value {
//    segments.append(Segment(components: prefix, value: value))
//  } else if prefix.isEmpty {
//    segments.append(Segment(components: [], value: ""))
//  }
//  if let plural = unit.variations?.plural {
//    for (variable, categories) in plural.sorted(by: { $0.key < $1.key }) {
//      for (category, variation) in categories.sorted(by: { $0.key < $1.key }) {
//        if let nested = variation.stringUnit {
//          var nextPrefix = prefix
//          nextPrefix.append("plural")
//          nextPrefix.append(variable)
//          nextPrefix.append(category)
//          segments.append(contentsOf: gatherSegments(from: nested, prefix: nextPrefix))
//        }
//      }
//    }
//  }
//  return segments
//}
//
//private func normalizedPlaceholders(_ tokens: [String]) -> [String] {
//  tokens.sorted()
//}
//
//private func fallbackPath(for localePath: String, baseMap: [String: [String]]) -> String? {
//  let parts = localePath.split(separator: ".")
//  guard parts.count == 3, parts.first == "plural" else {
//    return nil
//  }
//  let variable = parts[1]
//  let otherKey = "plural.\(variable).other"
//  if baseMap[otherKey] != nil {
//    return otherKey
//  }
//  let oneKey = "plural.\(variable).one"
//  if baseMap[oneKey] != nil {
//    return oneKey
//  }
//  return nil
//}
//
//private let placeholderRegex: NSRegularExpression = {
//  let pattern = "%(?:\\d+\\$)?#@[A-Za-z0-9_]+@|%(?:\\d+\\$)?[#0\\- +'\"]*(?:\\d+|\\*)?(?:\\.\\d+)?(?:hh|h|ll|l|z|t|L)?[a-zA-Z@]"
//  return try! NSRegularExpression(pattern: pattern, options: [])
//}()
//
//private func placeholders(in string: String) -> [String] {
//  let range = NSRange(location: 0, length: (string as NSString).length)
//  let matches = placeholderRegex.matches(in: string, options: [], range: range)
//  var tokens: [String] = []
//  for match in matches {
//    if let range = Range(match.range, in: string) {
//      let token = String(string[range])
//      if token == "%%" { continue }
//      tokens.append(token)
//    }
//  }
//  return tokens
//}
//
//private struct PrimaryKeyConfig: Decodable {
//  let app: [String]
//  let shareExtension: [String]
//  let expectedValues: [String: [String: String]]?
//  let testLocales: [String]?
//}