LocaleUtils.kt

/*
 * WiFiAnalyzer
 * Copyright (C) 2015 - 2026 VREM Software Development <VREMSoftwareDevelopment@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 */
package com.vrem.util

import java.util.Locale
import java.util.SortedMap

private val currentLocale: Locale get() = Locale.getDefault()
private val countryCodes: Set<String> = Locale.getISOCountries().toSet()
private val availableLocales: List<Locale> = Locale.getAvailableLocales().filter { countryCodes.contains(it.country) }
private val countriesLocales: SortedMap<String, Locale>
    get() =
        availableLocales
            .associateBy { it.country.toCapitalize(currentLocale) }
            .toSortedMap()

val BULGARIAN: Locale = Locale.forLanguageTag("bg")
val CHINESE: Locale = Locale.forLanguageTag("zh")
val CHINESE_SIMPLIFIED: Locale = Locale.forLanguageTag("zh-Hans")
val CHINESE_TRADITIONAL: Locale = Locale.forLanguageTag("zh-Hant")
val DUTCH: Locale = Locale.forLanguageTag("nl")
val ENGLISH: Locale = Locale.forLanguageTag("en")
val FRENCH: Locale = Locale.forLanguageTag("fr")
val GERMAN: Locale = Locale.forLanguageTag("de")
val GREEK: Locale = Locale.forLanguageTag("el")
val HUNGARIAN: Locale = Locale.forLanguageTag("hu")
val ITALIAN: Locale = Locale.forLanguageTag("it")
val JAPANESE: Locale = Locale.forLanguageTag("ja")
val POLISH: Locale = Locale.forLanguageTag("pl")
val PORTUGUESE_BRAZIL: Locale = Locale.forLanguageTag("pt-BR")
val PORTUGUESE_PORTUGAL: Locale = Locale.forLanguageTag("pt-PT")
val RUSSIAN: Locale = Locale.forLanguageTag("ru")
val SPANISH: Locale = Locale.forLanguageTag("es")
val TURKISH: Locale = Locale.forLanguageTag("tr")
val UKRAINIAN: Locale = Locale.forLanguageTag("uk")

val baseSupportedLocales: List<Locale> =
    listOf(
        BULGARIAN,
        CHINESE_SIMPLIFIED,
        CHINESE_TRADITIONAL,
        DUTCH,
        ENGLISH,
        FRENCH,
        GERMAN,
        GREEK,
        HUNGARIAN,
        ITALIAN,
        JAPANESE,
        POLISH,
        PORTUGUESE_BRAZIL,
        PORTUGUESE_PORTUGAL,
        RUSSIAN,
        SPANISH,
        TURKISH,
        UKRAINIAN,
    )

fun findByCountryCode(countryCode: String): Locale =
    availableLocales.firstOrNull { countryCode.uppercase(Locale.ROOT) == it.country }
        ?: currentLocale

fun allCountries(): List<Locale> = countriesLocales.values.toList()

fun supportedLanguages(): List<Locale> = (baseSupportedLocales + currentLocale).distinct()

fun supportedLanguageTags(): List<String> = listOf("") + baseSupportedLocales.map { it.toLanguageTag() }

private fun normalizeLanguageTag(languageTag: String): String = languageTag.replace('_', '-').trim()

private val chineseCountryToLocale: Map<String, Locale> =
    mapOf(
        "CN" to CHINESE_SIMPLIFIED,
        "SG" to CHINESE_SIMPLIFIED,
        "TW" to CHINESE_TRADITIONAL,
        "HK" to CHINESE_TRADITIONAL,
        "MO" to CHINESE_TRADITIONAL,
    )

fun findByLanguageTag(languageTag: String): Locale {
    val normalizedLanguageTag = normalizeLanguageTag(languageTag)
    if (normalizedLanguageTag.isEmpty()) return currentLocale
    return findSupportedLocale(Locale.forLanguageTag(normalizedLanguageTag))
}

fun findSupportedLocale(target: Locale): Locale {
    if (target.language.isEmpty()) return currentLocale

    if (target.language == "zh" && target.script.isEmpty()) {
        if (target.country.isEmpty()) return CHINESE
        return chineseCountryToLocale[target.country] ?: CHINESE
    }

    return baseSupportedLocales.find { it == target }
        ?: baseSupportedLocales.find { it.language == target.language && it.script == target.script }
        ?: baseSupportedLocales.find { it.language == target.language && it.country == target.country }
        ?: baseSupportedLocales.find { it.language == target.language }
        ?: currentLocale
}

fun currentCountryCode(): String = currentLocale.country

fun currentLanguageTag(): String = currentLocale.toLanguageTag()

fun toLanguageTag(locale: Locale): String = locale.toLanguageTag()

fun Locale.toSupportedLocaleTag(): String = findSupportedLocale(this).toLanguageTag()