House/street address format based on country specific about mapbox-search-android HOT 6 CLOSED

import com.mapbox.search.result.SearchAddress
import com.mapbox.search.result.SearchResult
import com.mapbox.search.result.SearchResultType
import com.mapbox.search.result.SearchSuggestion
import com.mapbox.search.result.SearchSuggestionType

val SearchResult.fullAddress: String
    get() = when (types.firstByType()) {
        SearchResultType.COUNTRY -> withName(address?.countryAddress) // usa
        SearchResultType.REGION -> withName(address?.regionAddress) // Liberecký kraj
        SearchResultType.POSTCODE,
        SearchResultType.BLOCK -> withName(address?.postcodeAddress) // 468 22
        SearchResultType.DISTRICT -> address?.districtAddress //
        SearchResultType.PLACE -> withName(address?.placeAddress) // Praha
        SearchResultType.LOCALITY -> withName(address?.localityAddress) // Manhattan / Písek Líšťany
        SearchResultType.NEIGHBORHOOD -> address?.neighborhoodAddress // ?
        SearchResultType.STREET -> address?.streetAddress // never used, SDK return error, if try to use STREET 🤦‍
        SearchResultType.ADDRESS -> address?.houseAddress // any czech street is returned as address 🤷‍
        SearchResultType.POI -> withName(address?.poiAddress) // Cross club
        null -> null
    }.orEmpty()
        .distinct()
        .filter { it.isNotBlank() }
        .joinToString(", ")
        .trim()

/**
 * Add name of suggestion, because address don't contains this info in some cases...
 */
private fun SearchResult.withName(address: List<String>?) = listOfNotNull(name) + address.orEmpty()

val SearchSuggestion.fullAddress: String
    get() = when (this.type.getSearchSuggestionType()) {
        SearchResultType.COUNTRY -> withName(address?.countryAddress) // usa
        SearchResultType.REGION -> withName(address?.regionAddress) // Liberecký kraj
        SearchResultType.POSTCODE,
        SearchResultType.BLOCK -> withName(address?.postcodeAddress) // 468 22
        SearchResultType.DISTRICT -> address?.districtAddress //
        SearchResultType.PLACE -> withName(address?.placeAddress) // Praha
        SearchResultType.LOCALITY -> withName(address?.localityAddress) // Manhattan / Písek Líšťany
        SearchResultType.NEIGHBORHOOD -> address?.neighborhoodAddress // ?
        SearchResultType.STREET -> address?.streetAddress // never used, SDK return error, if try to use STREET 🤦‍
        SearchResultType.ADDRESS -> address?.houseAddress // any czech street is returned as address 🤷‍
        SearchResultType.POI -> withName(address?.poiAddress) // Cross club
        null -> null
    }.orEmpty()
        .distinct()
        .filter { it.isNotBlank() }
        .joinToString(", ")
        .trim()

/**
 * Add name of suggestion, because address don't contains this info in some cases...
 */
private fun SearchSuggestion.withName(address: List<String>?) = listOfNotNull(name) + address.orEmpty()

/**
 * Generally recognized countries or, in some cases like Hong Kong, an area of quasi-national
 * administrative status that has been given a designated country code under ISO 3166-1.
 */
private val SearchAddress.countryAddress: List<String>
    get() = listOfNotNull(country)

/**
 * Top-level sub-national administrative features, such as states in the United States
 * or provinces in Canada or China.
 */
private val SearchAddress.regionAddress: List<String>
    get() = listOfNotNull(region, country)

/**
 * Postal codes used in country-specific national addressing systems.
 */
private val SearchAddress.postcodeAddress: List<String>
    get() = listOfNotNull(postcode, place, region)

/**
 * Features that are smaller than top-level administrative features but typically larger than cities,
 * in countries that use such an additional layer in postal addressing (for example, prefectures in China).
 */
private val SearchAddress.districtAddress: List<String>
    get() = listOfNotNull(district, postcode, region)

/**
 * Typically these are cities, villages, municipalities, etc.
 * They’re usually features used in postal addressing, and are suitable for display in ambient
 * end-user applications where current-location context is needed (for example, in weather displays).
 */
private val SearchAddress.placeAddress: List<String>
    get() = listOfNotNull(place, district, postcode, region)

/**
 * Official sub-city features present in countries where such an additional administrative layer
 * is used in postal addressing, or where such features are commonly referred to in local parlance.
 * Examples include city districts in Brazil and Chile and arrondissements in France.
 */
private val SearchAddress.localityAddress: List<String>
    get() = listOfNotNull(locality, place, district, postcode, region)

/**
 * Colloquial sub-city features often referred to in local parlance.
 * Unlike locality features, these typically lack official status and may lack universally agreed-upon boundaries.
 */
private val SearchAddress.neighborhoodAddress: List<String>
    get() = listOfNotNull(neighborhood, locality, place, district, postcode, region)

/**
 * Features that are smaller than places and that correspond to streets in cities, villages, etc.
 */
private val SearchAddress.streetAddress: List<String>
    get() = listOfNotNull(street, neighborhood, locality, place, district, postcode, region)

/**
 * Individual residential or business addresses.
 */
private val SearchAddress.houseAddress: List<String>
    get() = listOfNotNull(
        streetWithHouseNumber,
        neighborhood,
        locality,
        place,
        district,
        postcode,
        region
    )

/**
 * Points of interest.
 * These include restaurants, stores, concert venues, parks, museums, etc.
 */
private val SearchAddress.poiAddress: List<String>
    get() = listOfNotNull(
        streetWithHouseNumber,
        neighborhood,
        locality,
        place,
        district,
        postcode
    )

private fun SearchSuggestionType.getSearchSuggestionType(): SearchResultType? = when (this) {
    is SearchSuggestionType.SearchResultSuggestion -> this.types.firstByType()
    is SearchSuggestionType.Category, is SearchSuggestionType.Query -> null
    else -> error("Unknown SearchSuggestionType type: $this.")
}

/**
 * Get most weighted type from list of [SearchResultType].
 */
private fun List<SearchResultType>.firstByType(): SearchResultType? = this.maxByOrNull { it.weight }

/**
 * Ordering weight by priority (most precise address has highest weight).
 */
private val SearchResultType.weight: Int
    get() = when (this) {
        SearchResultType.COUNTRY -> 0
        SearchResultType.REGION -> 1
        SearchResultType.POSTCODE -> 2
        SearchResultType.BLOCK -> 3
        SearchResultType.PLACE -> 4
        SearchResultType.DISTRICT -> 5
        SearchResultType.LOCALITY -> 6
        SearchResultType.NEIGHBORHOOD -> 7
        SearchResultType.STREET -> 8
        SearchResultType.ADDRESS -> 9
        SearchResultType.POI -> 10
    }

/**
 * Format House number and Street name to most used European format (not at all EU countries).
 * https://qph.cf2.quoracdn.net/main-qimg-fed2c12535f9552efa214450c4c87881
 * Created issue on MapBox: https://github.com/mapbox/mapbox-search-android/issues/112
 */
private val SearchAddress.streetWithHouseNumber: String
    get() = "${street.orEmpty()} ${houseNumber.orEmpty()}".trim()