import Foundation

// MARK: - Models

// This struct is used to decode the top-level array.
// We ignore the first element (metadata) and then decode the second element as an array of Country.
struct CountryResponse: Codable {
    let countries: [Country]
    
    // Custom initializer to decode the top-level array.
    init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        // Decode (and ignore) the metadata.
        _ = try container.decode(Meta.self)
        // Now decode the countries array.
        countries = try container.decode([Country].self)
    }
}

// Metadata about the response (we don't use it in this sample).
struct Meta: Codable {
    let page: Int
    let pages: Int
    let per_page: String
    let total: Int
}

// The Country model - note that we use the "id" field from the API as the unique identifier.
struct Country: Codable, Identifiable {
    // The API's "id" is the country code.
    let id: String
    let iso2Code: String
    let name: String
    let region: Category
    let incomeLevel: Category
    let lendingType: Category
    let capitalCity: String
    let longitude: String
    let latitude: String
}

// A helper type for nested category fields (like region, incomeLevel, etc.)
struct Category: Codable {
    let id: String
    let value: String
}

import Foundation
import SwiftUI

class CountriesViewModel: ObservableObject {
    @Published var countries: [Country] = []
    // Group countries by income level (or any category)
    @Published var groupedCountries: [String: [Country]] = [:]
    
    // Using async/await (requires iOS 15+)
    @MainActor
    func fetchCountries() async {
        // Request more than the default per_page (here 300) to get most of the countries.
        guard let url = URL(string: "https://api.worldbank.org/v2/country?format=json&per_page=300") else {
            print("Invalid URL")
            return
        }
        
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            let response = try JSONDecoder().decode(CountryResponse.self, from: data)
            countries = response.countries
            // Group by income level (for example, "High income", "Low income", etc.)
            groupedCountries = Dictionary(grouping: countries, by: { $0.incomeLevel.value })
        } catch {
            print("Error fetching countries: \(error)")
        }
    }
}

import SwiftUI

struct ContentView: View {
    @StateObject var viewModel = CountriesViewModel()
    
    var body: some View {
        NavigationView {
          List {
              // Sort the keys (income levels) alphabetically
              ForEach(viewModel.groupedCountries.keys.sorted(), id: \.self) { incomeLevel in
                 Section(header: Text(incomeLevel)) {
                     if let countries = viewModel.groupedCountries[incomeLevel] {
                       ForEach(countries) { country in
                          NavigationLink(destination: CountryDetailView(country: country)) {
                                    Text(country.name)
                          }
                       }
                     }
                 }
              }
          }
          .navigationTitle("World Countries")
          // Use the .task modifier to call our async fetch function on appear.
          .task {
              await viewModel.fetchCountries()
          }
        }
    }
}

Подробный CountryDetailView показывает дополнительную информацию о выбранной стране.

struct CountryDetailView: View {
    let country: Country
    
    var body: some View {
        Form {
            Section(header: Text("General")) {
                HStack {
                    Text("Capital:")
                    Spacer()
                    Text(country.capitalCity)
                }
                HStack {
                    Text("Region:")
                    Spacer()
                    Text(country.region.value)
                }
                HStack {
                    Text("Income Level:")
                    Spacer()
                    Text(country.incomeLevel.value)
                }
                HStack {
                    Text("ISO Code:")
                    Spacer()
                    Text(country.iso2Code)
                }
            }
            
            Section(header: Text("Location")) {
                HStack {
                    Text("Latitude:")
                    Spacer()
                    Text(country.latitude)
                }
                HStack {
                    Text("Longitude:")
                    Spacer()
                    Text(country.longitude)
                }
            }
        }
        .navigationTitle(country.name)
    }
}

import Foundation

// MARK: - Models

struct CountryResponse: Codable {
    let countries: [Country]
    
    // Custom initializer to decode the top-level array.
    init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        // Decode and ignore metadata.
        _ = try container.decode(Meta.self)
        // Decode the countries array.
        countries = try container.decode([Country].self)
    }
}

struct Meta: Codable {
    let page: Int
    let pages: Int
    let per_page: String
    let total: Int
}

struct Country: Codable, Identifiable {
    let id: String            // This is the country code.
    let iso2Code: String
    let name: String
    let region: Category
    let incomeLevel: Category
    let lendingType: Category
    let capitalCity: String
    let longitude: String
    let latitude: String
}

struct Category: Codable {
    let id: String
    let value: String
}

import Foundation
import SwiftUI

class CountriesViewModel: ObservableObject {
    @Published var countries: [Country] = []
    // Group real countries by region.
    @Published var groupedCountries: [String: [Country]] = [:]
    
    @MainActor
    func fetchCountries() async {
        // Use a per_page parameter high enough to include most countries.
        guard let url = URL(string: "https://api.worldbank.org/v2/country?format=json&per_page=300") else {
            print("Invalid URL")
            return
        }
        
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            let response = try JSONDecoder().decode(CountryResponse.self, from: data)
            
            // Filter out aggregates - only include countries whose region value is not "Aggregates"
            let realCountries = response.countries.filter { $0.region.value != "Aggregates" }
            self.countries = realCountries
            
            // Group the filtered countries by region.
            groupedCountries = Dictionary(grouping: realCountries, by: { $0.region.value })
        } catch {
            print("Error fetching countries: \(error)")
        }
    }
}

import SwiftUI

struct ContentView: View {
    @StateObject var viewModel = CountriesViewModel()
    
    var body: some View {
        NavigationView {
            List {
                // Sort region names alphabetically.
                ForEach(viewModel.groupedCountries.keys.sorted(), id: \.self) { region in
                   Section(header: Text(region)) {
                      if let countriesInRegion = viewModel.groupedCountries[region] {
                        ForEach(countriesInRegion) { country in
                          NavigationLink(destination: CountryDetailView(country: country)) {
                                    Text(country.name)
                          }
                        }
                      }
                   }
                }
            }
            .navigationTitle("World Countries")
            .task {
                await viewModel.fetchCountries()
            }
        }
    }
}

Подробный CountryDetailView: показывает дополнительную информацию о выбранной стране.

struct CountryDetailView: View {
    let country: Country
    
    var body: some View {
        Form {
            Section(header: Text("General")) {
                HStack {
                    Text("Capital:")
                    Spacer()
                    Text(country.capitalCity)
                }
                HStack {
                    Text("Region:")
                    Spacer()
                    Text(country.region.value)
                }
                HStack {
                    Text("Income Level:")
                    Spacer()
                    Text(country.incomeLevel.value)
                }
                HStack {
                    Text("ISO Code:")
                    Spacer()
                    Text(country.iso2Code)
                }
            }
            
            Section(header: Text("Location")) {
                HStack {
                    Text("Latitude:")
                    Spacer()
                    Text(country.latitude)
                }
                HStack {
                    Text("Longitude:")
                    Spacer()
                    Text(country.longitude)
                }
            }
        }
        .navigationTitle(country.name)
    }
}

Объяснение

1. Фильтрация реальных стран:

В методе View Model fetchCountries() после декодирования JSON мы отфильтровываем все страны, значение value региона region которых равно «Aggregates». Этот шаг гарантирует, что в вашем списке появятся только суверенные государства.

2. Группировка по региону:

Оставшиеся страны затем группируются в словарь с помощью Dictionary(grouping:by:) с ключом region.value.

3. Отображение данных:

SwiftUI  список List использует раздел Section для каждого региона region, а нажатие на строку показывает  подробное CountryDetailView c дополнительной информацией о стране.

В этом примере показано, как отображать только «реальные» страны, сгруппированные по региону. При необходимости вы можете дополнительно настроить критерии фильтрации. Удачного кодирования!

Версия 2.  Запускаем приложение. Получаем результат:

Сейчас в списке стран только реальные страны Мира, нет никаких агрегатов AGGREGATES. Кроме того, страны сгруппированы по географическим регионам region.

Что касается кода, то ChatGPT o3-mini справился прекрасно.

Добавляем численность населения population и ВВП gdp 

Теперь мы хотим добавить численность населения population и ВВП gdp для каждой страны:

В результате мы получаем рассуждения, которые длятся 25 секунд:

Ниже приведен обновленный полный пример. В этой версии мы:

• Получаем список «реальных» стран (фильтруя агрегаты «Aggregates»)

• В многопоточном режиме получаем последние данные о населении (индикатор «SP.POP.TOTL») и ВВП (индикатор «NY.GDP.MKTP.CD») для каждой страны (используя данные за последний год, например, 2022)

• Вычисляем эмодзи флага из двухбуквенного ISO кода страны

• Отображаем флаг, название, население и ВВП каждой страны в списке (сгруппированном по регионам)

1. Модели данных Data Model

Мы используем ту же модель Country (декодирование из массива верхнего уровня) и добавляем расширение extension для преобразования флагов в эмодзи. Мы также определяем простые модели для ответов response индикаторов Indicator.

import Foundation

// MARK: - Models
// This struct is used to decode the top-level array.
// We ignore the first element (metadata) and then decode the second element as an array of Country.
struct CountryResponse: Codable {
    let countries: [Country]
    
    // Custom initializer to decode the top-level array.
    init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        // Decode (and ignore) the metadata.
        _ = try container.decode(Meta.self)
        // Now decode the countries array.
        countries = try container.decode([Country].self)
    }
}
// Metadata about the response (we don't use it in this sample).
struct Meta: Codable {
    let page: Int
    let pages: Int
    let per_page: String
    let total: Int
}
// The Country model - note that we use the "id" field from the API as the unique identifier.
struct Country: Codable, Identifiable {
    // The API's "id" is the country code.
    let id: String
    let iso2Code: String
    let name: String
    let region: Category
    let incomeLevel: Category
    let lendingType: Category
    let capitalCity: String
    let longitude: String
    let latitude: String
}
// A helper type for nested category fields (like region, incomeLevel, etc.)
struct Category: Codable {
    let id: String
    let value: String
}
//------
// MARK: - Indicator API Models
// Response to decode indicator data
struct IndicatorResponse: Codable {
    let data: [IndicatorData]
    
    init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        _ = try container.decode(Meta.self)
        data = try container.decode([IndicatorData].self)
    }
}
struct IndicatorData: Codable {
    let indicator: Indicator?
    let country: IndicatorCountry?
    let countryiso3code: String?
    let date: String?
    let value: Double?
    let unit: String?
    let obs_status: String?
    let decimal: Int?
}
struct Indicator: Codable {
    let id: String?
    let value: String?
}
struct IndicatorCountry: Codable {
    let id: String?
    let value: String?
}
// MARK: - Flag Emoji Extension
extension String {
    /// Converts a 2-letter country code into its corresponding flag emoji.
    var flagEmoji: String {
        self.uppercased().unicodeScalars.compactMap { scalar -> String? in
            guard let flagScalar = UnicodeScalar(127397 + scalar.value) else { return nil }
            return String(flagScalar)
        }.joined()
    }
}

2. View Model

View Model теперь выбирает список стран countries, фильтрует агрегаты «Aggregates», а затем — используя async let — выбирает последние данные о населении population и ВВП gdp для всех стран из endpoint индикатора. Мы сохраняем эти значения в словарях (ключом к которым служит трехбуквенный код страны), чтобы View могло их найти.

import SwiftUI
class CountriesViewModel: ObservableObject {
    @Published var countries: [Country] = []
    // Group real countries by region.
    @Published var groupedCountries: [String: [Country]] = [:]
    
    // Indicator dictionaries: country id -> value
    @Published var populationData: [String: Int] = [:]
    @Published var gdpData: [String: Double] = [:]
    
    @MainActor
    func fetchCountries() async {
        guard let url = URL(string: "https://api.worldbank.org/v2/country?format=json&per_page=300") else {
            print("Invalid URL")
            return
        }
        
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            let response = try JSONDecoder().decode(CountryResponse.self, from: data)
            
            // Filter out non‑sovereign aggregates (assume region value "Aggregates" means not a real country)
            let realCountries = response.countries.filter { $0.region.value != "Aggregates" }
            self.countries = realCountries
            groupedCountries = Dictionary(grouping: realCountries, by: { $0.region.value })
            
            // Fetch population and GDP concurrently.
            async let popResult = fetchPopulation()
            async let gdpResult = fetchGDP()
            _ = try await (popResult, gdpResult)
            
        } catch {
            print("Error fetching countries: \(error)")
        }
    }
    
    // Fetch population (indicator "SP.POP.TOTL") for year 2022.
    func fetchPopulation() async throws {
        guard let url = URL(string: "https://api.worldbank.org/v2/country/all/indicator/SP.POP.TOTL?format=json&per_page=500&date=2022") else { return }
        let (data, _) = try await URLSession.shared.data(from: url)
        let decoded = try JSONDecoder().decode(IndicatorResponse.self, from: data)
        var dict: [String: Int] = [:]
        for item in decoded.data {
            if let code = item.countryiso3code, let value = item.value {
                dict[code] = Int(value)
            }
        }
        await MainActor.run { self.populationData = dict }
    }
    
    // Fetch GDP (indicator "NY.GDP.MKTP.CD") for year 2022.
    func fetchGDP() async throws {
        guard let url = URL(string: "https://api.worldbank.org/v2/country/all/indicator/NY.GDP.MKTP.CD?format=json&per_page=500&date=2022") else { return }
        let (data, _) = try await URLSession.shared.data(from: url)
        let decoded = try JSONDecoder().decode(IndicatorResponse.self, from: data)
        var dict: [String: Double] = [:]
        for item in decoded.data {
            if let code = item.countryiso3code, let value = item.value {
                dict[code] = value
            }
        }
        await MainActor.run { self.gdpData = dict }
    }
}

import SwiftUI

struct ContentView: View {
    @StateObject var viewModel = CountriesViewModel()
    
    var body: some View {
        NavigationView {
            List {
                ForEach(viewModel.groupedCountries.keys.sorted(), id: \.self) { region in
                    Section(header: Text(region)) {
                        if let countries = viewModel.groupedCountries[region] {
                            ForEach(countries) { country in
                                NavigationLink(destination: CountryDetailView(
                                     country: country,
                                     population: viewModel.populationData[country.id],
                                                                              
                                     gdp: viewModel.gdpData[country.id])) {
                                    HStack {
                                        // Flag emoji from iso2Code
                                        Text(country.iso2Code.flagEmoji)
                                            .font(.largeTitle)
                                        VStack(alignment: .leading) {
                                            Text(country.name)
                                                .font(.headline)
                                            HStack {
                                                if let 
                                               pop = viewModel.populationData[country.id] {
                                                    Text("Population: \(pop)")
                                                } else {
                                                    Text("Population: N/A")
                                                }
                                                Spacer()
                                                if let gdp = viewModel.gdpData[country.id] {
                                                    Text("GDP: \(gdp, specifier: "%.0f")")
                                                } else {
                                                    Text("GDP: N/A")
                                                }
                                            }
                                            .font(.subheadline)
                                            .foregroundColor(.secondary)
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            .navigationTitle("World Countries")
            .task {
                await viewModel.fetchCountries()
            }
        }
    }
}

Detail View (с дополнительной информацией):

struct CountryDetailView: View {
    let country: Country
    let population: Int?
    let gdp: Double?
    
    var body: some View {
        Form {
            Section(header: Text("General")) {
                HStack {
                    Text("Flag:")
                    Spacer()
                    Text(country.iso2Code.flagEmoji)
                        .font(.largeTitle)
                }
                HStack {
                    Text("Capital:")
                    Spacer()
                    Text(country.capitalCity)
                }
                HStack {
                    Text("Region:")
                    Spacer()
                    Text(country.region.value)
                }
                HStack {
                    Text("Income Level:")
                    Spacer()
                    Text(country.incomeLevel.value)
                }
                HStack {
                    Text("ISO Code:")
                    Spacer()
                    Text(country.iso2Code)
                }
            }
            
            Section(header: Text("Indicators")) {
                HStack {
                    Text("Population:")
                    Spacer()
                    if let pop = population {
                        Text("\(pop)")
                    } else {
                        Text("N/A")
                    }
                }
                HStack {
                    Text("GDP (USD):")
                    Spacer()
                    if let gdp = gdp {
                        Text("\(gdp, specifier: "%.0f")")
                    } else {
                        Text("N/A")
                    }
                }
            }
            
            Section(header: Text("Location")) {
                HStack {
                    Text("Latitude:")
                    Spacer()
                    Text(country.latitude)
                }
                HStack {
                    Text("Longitude:")
                    Spacer()
                    Text(country.longitude)
                }
            }
        }
        .navigationTitle(country.name)
    }
}

func fetchPopulation() async throws {
    guard let url = URL(string: "https://api.worldbank.org/v2/country/all/indicator/SP.POP.TOTL?format=json&per_page=500&date=2022") else { return }
    let (data, _) = try await URLSession.shared.data(from: url)
    let decoded = try JSONDecoder().decode(PopulationDataResponse.self, from: data)
    var dict: [String: Int] = [:]
    for item in decoded.data {
        if let code = item.countryiso3code, let value = item.value {
            dict[code] = Int(value)
        }
    }
    // Create an immutable copy before passing it to MainActor
    let result = dict
    await MainActor.run {
        self.populationData = result
    }
}

func fetchGDP() async throws {
    guard let url = URL(string: "https://api.worldbank.org/v2/country/all/indicator/NY.GDP.MKTP.CD?format=json&per_page=500&date=2022") else { return }
    let (data, _) = try await URLSession.shared.data(from: url)
    let decoded = try JSONDecoder().decode(GDPDataResponse.self, from: data)
    var dict: [String: Double] = [:]
    for item in decoded.data {
        if let code = item.countryiso3code, let value = item.value {
            dict[code] = value
        }
    }
    let result = dict
    await MainActor.run {
        self.gdpData = result
    }
}

import SwiftUI

@MainActor
class CountriesViewModel: ObservableObject {
    @Published var countries: [Country] = []
    @Published var groupedCountries: [String: [Country]] = [:]
    @Published var populationData: [String: Int] = [:]
    @Published var gdpData: [String: Double] = [:]
    
    func fetchCountries() async {
        guard let url = URL(string: "https://api.worldbank.org/v2/country?format=json&per_page=300") else {
            print("Invalid URL")
            return
        }
        
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            let response = try JSONDecoder().decode(CountryResponse.self, from: data)
            
            // Filter out aggregates
            let realCountries = response.countries.filter { $0.region.value != "Aggregates" }
            self.countries = realCountries
            self.groupedCountries = Dictionary(grouping: realCountries, by: { $0.region.value })
            
            // Fetch population and GDP concurrently.
            try await  fetchPopulation()
            try await fetchGDP()            
        } catch {
            print("Error fetching countries: \(error)")
        }
    }
    
    // Fetch Population (indicator "SP.POP.TOTL")
    func fetchPopulation() async throws {
        guard let url = URL(string: "https://api.worldbank.org/v2/country/all/indicator/SP.POP.TOTL?format=json&per_page=500&date=2022") else { return }
        let (data, _) = try await URLSession.shared.data(from: url)
        let decoded = try JSONDecoder().decode(PopulationDataResponse.self, from: data)
        var dict: [String: Int] = [:]
        for item in decoded.data {
            if let code = item.countryiso3code, let value = item.value {
                dict[code] = Int(value)
            }
        }
        // Since self is already isolated to the main actor, assign directly.
        self.populationData = dict
    }
    
    // Fetch GDP (indicator "NY.GDP.MKTP.CD")
    func fetchGDP() async throws {
        guard let url = URL(string: "https://api.worldbank.org/v2/country/all/indicator/NY.GDP.MKTP.CD?format=json&per_page=500&date=2022") else { return }
        let (data, _) = try await URLSession.shared.data(from: url)
        let decoded = try JSONDecoder().decode(GDPDataResponse.self, from: data)
        var dict: [String: Double] = [:]
        for item in decoded.data {
            if let code = item.countryiso3code, let value = item.value {
                dict[code] = value
            }
        }
        self.gdpData = dict
    }
}

@MainActor
class CountriesViewModel: ObservableObject {
    @Published var countries: [Country] = []
    // Group real countries by region.
    @Published var groupedCountries: [String: [Country]] = [:]
    
    // Indicator dictionaries: country id -> value
    @Published var populationData: [String: Int] = [:]
    @Published var gdpData: [String: Double] = [:]
    
    func loadCountries() async {
        do {
            // This network call runs off the background thread.
            let fetchedCountries = try await fetchCountriesInBackground()
            // Now update the UI on the main actor
            countries = fetchedCountries
            groupedCountries = Dictionary(grouping: fetchedCountries, 
                                                by: { $0.region.value })
            
            // Fetch population and GDP concurrently.
            // This network call runs off the background thread.
            async let popResult = fetchPopulation()
            async let gdpResult = fetchGDP()
            let (pop, gdp) = try await (popResult, gdpResult)
            // Now update the UI on the main actor
            self.populationData = pop
            self.gdpData = gdp
            
        } catch {
            print("Error fetching countries: \(error)")
        }
    }
    
    nonisolated private func fetchCountriesInBackground() async throws -> [Country] {
        guard let url = URL(string: "https://api.worldbank.org/v2/country?format=json&per_page=300") else {
            throw URLError(.badURL)
        }
        let (data, _) = try await URLSession.shared.data(from: url)
        let response = try JSONDecoder().decode(CountryResponse.self, from: data)
        // Filter out aggregates here if desired.
        return response.countries.filter { $0.region.value != "Aggregates" }
    }
    
    // Fetch population (indicator "SP.POP.TOTL") for year 2022.
    nonisolated private func fetchPopulation() async throws -> [String: Int] {
        guard let url = URL(string: "https://api.worldbank.org/v2/country/all/indicator/SP.POP.TOTL?format=json&per_page=500&date=2022") else { return [:]}
        let (data, _) = try await URLSession.shared.data(from: url)
        let decoded = try JSONDecoder().decode(IndicatorResponse.self, from: data)
        var dict: [String: Int] = [:]
        for item in decoded.data {
            if let code = item.countryiso3code, let value = item.value {
                dict[code] = Int(value)
            }
        }
              return dict
    }
    
    // Fetch GDP (indicator "NY.GDP.MKTP.CD") for year 2022.
    nonisolated private func fetchGDP() async throws ->  [String: Double]{
        guard let url = URL(string: "https://api.worldbank.org/v2/country/all/indicator/NY.GDP.MKTP.CD?format=json&per_page=500&date=2022") else { return   [:]}
        let (data, _) = try await URLSession.shared.data(from: url)
        let decoded = try JSONDecoder().decode(IndicatorResponse.self, from: data)
        var dict: [String: Double] = [:]
        for item in decoded.data {
            if let code = item.countryiso3code, let value = item.value {
                dict[code] = value
            }
        }
        return dict
    }
}

import SwiftUI
import MapKit

struct CountryDetailView: View {
    let country: Country
    let population: Int?
    let gdp: Double?
    
    // Create a region state from the country's latitude/longitude.
    @State private var region: MKCoordinateRegion
    
    init(country: Country, population: Int?, gdp: Double?) {
        self.country = country
        self.population = population
        self.gdp = gdp
        
        // Convert latitude/longitude strings to Double.
        let lat = Double(country.latitude) ?? 0.0
        let lon = Double(country.longitude) ?? 0.0
        _region = State(initialValue: MKCoordinateRegion(
            center: CLLocationCoordinate2D(latitude: lat, longitude: lon),
            span: MKCoordinateSpan(latitudeDelta: 10, longitudeDelta: 10)
        ))
    }
    
    var body: some View {
        Form {
            Section(header: Text("General")) {
                HStack {
                    Text("Flag:")
                    Spacer()
                    Text(country.iso2Code.flagEmoji)
                        .font(.largeTitle)
                }
                HStack {
                    Text("Capital:")
                    Spacer()
                    Text(country.capitalCity)
                }
             }
            
            Section(header: Text("Map")) {
                // Display the map with a marker for the country.
                Map(coordinateRegion: $region, annotationItems: [country]) { country in
                    // For annotation, convert the coordinate strings to Double.
                    let lat = Double(country.latitude) ?? 0.0
                    let lon = Double(country.longitude) ?? 0.0
                    return MapMarker(coordinate: 
                                    CLLocationCoordinate2D(latitude: lat, longitude: lon))
                }
                .frame(height: 300)
                .clipShape(RoundedRectangle(cornerRadius: 10))
            }
            
            Section(header: Text("Indicators")) {
                HStack {
                    Text("Population:")
                    Spacer()
                    if let pop = population {
                        Text("\(pop)")
                    } else {
                        Text("N/A")
                    }
                }
                HStack {
                    Text("GDP (USD):")
                    Spacer()
                    if let gdp = gdp {
                        Text("\(gdp, specifier: "%.0f")")
                    } else {
                        Text("N/A")
                    }
                }
            }
        }
        .navigationTitle(country.name)
    }
}

import MapKit

struct CountryDetailView: View {
    let country: Country
    let population: Int?
    let gdp: Double?
    
    // Use the new state property for the map's position.
        @State private var position: MapCameraPosition
   
    
    init(country: Country, population: Int?, gdp: Double?) {
        self.country = country
        self.population = population
        self.gdp = gdp
        
        // Convert latitude/longitude strings to Double.
        let lat = Double(country.latitude) ?? 0.0
        let lon = Double(country.longitude) ?? 0.0
        
        // Initialize the MapPCameraPosition
                _position = State(initialValue:.region(MKCoordinateRegion(
                    center: CLLocationCoordinate2D(latitude: lat, longitude: lon), span: MKCoordinateSpan(latitudeDelta: 10, longitudeDelta: 10)
                )))
    }
    
    var body: some View {
        Form {
            Section(header: Text("General")) {
                HStack {
                    Text("Flag:")
                    Spacer()
                    Text(country.iso2Code.flagEmoji)
                        .font(.largeTitle)
                }
                HStack {
                    Text("Capital:")
                    Spacer()
                    Text(country.capitalCity)
                }
            }
            
            Section(header: Text("Map")) {
              
                // Use the new iOS 17 Map initializer with a MapContentBuilder.
               Map (position: $position){
                   // For annotation, convert the coordinate strings to Double.
                   let lat = Double(country.latitude) ?? 0.0
                   let lon = Double(country.longitude) ?? 0.0
                   Marker ("",coordinate: CLLocationCoordinate2D(latitude: lat, longitude: lon))
                                }
                .frame(height: 300)
                .clipShape(RoundedRectangle(cornerRadius: 10))
            }
            
            Section(header: Text("Indicators")) {
                HStack {
                    Text("Population:")
                    Spacer()
                    if let pop = population {
                        Text("\(pop)")
                    } else {
                        Text("N/A")
                    }
                }
                HStack {
                    Text("GDP (USD):")
                    Spacer()
                    if let gdp = gdp {
                        Text("\(gdp, specifier: "%.0f")")
                    } else {
                        Text("N/A")
                    }
                }
            }
        }
        .navigationTitle(country.name)
    }
}

import SwiftUI
import MapKit
import CoreLocation

struct CountryDetailView: View {
    let country: Country
    let population: Int?
    let gdp: Double?
    
    // Use MapCameraPosition to control the camera.
    @State private var position: MapCameraPosition
    // Will hold the capital city coordinate after geocoding.
    @State private var capitalCoordinate: CLLocationCoordinate2D? = nil
    
    init(country: Country, population: Int?, gdp: Double?) {
        self.country = country
        self.population = population
        self.gdp = gdp
        
        // Convert the country's latitude/longitude (as Strings) to a coordinate.
        let lat = Double(country.latitude) ?? 0.0
        let lon = Double(country.longitude) ?? 0.0
        let center = CLLocationCoordinate2D(latitude: lat, longitude: lon)
        _position = State(initialValue:.region(MKCoordinateRegion( center: center, 
                    span: MKCoordinateSpan(latitudeDelta: 10, longitudeDelta: 10)
                )))
    }
    
    var body: some View {
        Form {
            Section(header: Text("General")) {
                HStack {
                    Text("Flag:")
                    Spacer()
                    Text(country.iso2Code.flagEmoji)
                        .font(.largeTitle)
                }
                HStack {
                    Text("Capital:")
                    Spacer()
                    Text(country.capitalCity)
                }
            }
            
            Section(header: Text("Indicators")) {
                HStack {
                    Text("Population:")
                    Spacer()
                    if let pop = population {
                        Text("\(pop)")
                    } else {
                        Text("N/A")
                    }
                }
                HStack {
                    Text("GDP (USD):")
                    Spacer()
                    if let gdp = gdp {
                        Text("\(gdp, specifier: "%.0f")")
                    } else {
                        Text("N/A")
                    }
                }
            }
            
            Section(header: Text("Map")) {
                // Use the new initializer that accepts a binding to MapCameraPosition.
                Map(position: $cameraPosition) {
                    // Marker for the country's center.
                   let lat = Double(country.latitude) ?? 0.0
                   let lon = Double(country.longitude) ?? 0.0
                  
                   // Marker for the country's center.
                   if country.capitalCity == "" {
                       Marker("\(country.name)", coordinate: 
                              CLLocationCoordinate2D(latitude: lat, longitude: lon))
                   }
                    
                    // If the capital city's coordinate is available, add a marker.
                    if let capitalCoordinate = capitalCoordinate {
                        Marker(coordinate: capitalCoordinate, position: .automatic) {
                            // Use a Label to indicate the capital city.
                            Label("Capital: \(country.capitalCity)", 
                                                       systemImage: "building.columns")
                        }
                    }
                }
                .frame(height: 300)
                .task {
                    await geocodeCapital()
                }
            }
        }
        .navigationTitle(country.name)
    }
    
    // Geocode the capital city name to obtain its coordinates.
     nonisolated func geocodeCapital() async {
        let geocoder = CLGeocoder()
        do {
            let placemarks = try await geocoder.geocodeAddressString(country.capitalCity)
            if let location = placemarks.first?.location {
               await MainActor.run {
                    capitalCoordinate = location.coordinate
               }
            }
        } catch {
            print("Error geocoding capital city: \(error)")
        }
    }
}

func geocodeCapital() async {
    // Capture the capital city string so that the detached task doesn't capture self.
    let capitalCity = country.capitalCity
    
    let coordinate: CLLocationCoordinate2D? = await Task.detached { [capitalCity] in
        let geocoder = CLGeocoder()
        do {
            let placemarks = try await geocoder.geocodeAddressString(capitalCity)
            return placemarks.first?.location?.coordinate
        } catch {
            print("Error geocoding capital city: \(error)")
            return nil
        }
    }.value

    if let coordinate = coordinate {
        await MainActor.run {
            self.capitalCoordinate = coordinate
        }
    }
}