Contrarian View: You Don't Need Kotlin Multiplatform 2.0 – Use Swift 6.0 for iOS 18 and Kotlin 2.0 for Android 15

import Foundation
import Observation

/// Swift 6.0 strict concurrency compliant user profile service for iOS 18
/// Uses new Observation framework instead of Combine for reduced overhead
@Observable
final class UserProfileViewModel {
    // MARK: - Published State
    var userProfile: UserProfile?
    var isLoading: Bool = false
    var errorMessage: String?

    // MARK: - Dependencies
    private let networkService: NetworkServicing
    private let cache: UserProfileCaching

    // MARK: - Initialization
    init(networkService: NetworkServicing = URLSessionNetworkService(),
         cache: UserProfileCaching = UserDefaultsProfileCache()) {
        self.networkService = networkService
        self.cache = cache
    }

    // MARK: - Public Methods
    /// Fetches user profile with cache-first strategy, strict concurrency isolation
    @MainActor
    func fetchProfile(for userId: String) async {
        isLoading = true
        errorMessage = nil

        // Check cache first (non-isolated, safe for concurrent access)
        if let cachedProfile = await cache.getProfile(for: userId) {
            self.userProfile = cachedProfile
            isLoading = false
            return
        }

        do {
            // Network call with Swift 6's strict error handling
            let profile: UserProfile = try await networkService.fetch(
                endpoint: "/users/\(userId)",
                method: .get,
                headers: ["Accept": "application/json"]
            )

            // Update state on main actor (required by Swift 6 concurrency rules)
            self.userProfile = profile
            // Cache result non-isolated
            await cache.saveProfile(profile, for: userId)
        } catch let error as NetworkError {
            errorMessage = "Network error: \(error.localizedDescription)"
        } catch {
            errorMessage = "Unexpected error: \(error.localizedDescription)"
        }

        isLoading = false
    }
}

// MARK: - Supporting Protocols & Models
protocol NetworkServicing {
    func fetch<T: Decodable>(endpoint: String, method: HTTPMethod, headers: [String: String]) async throws -> T
}

enum HTTPMethod: String {
    case get = "GET"
    case post = "POST"
}

enum NetworkError: LocalizedError {
    case invalidURL
    case noData
    case decodingError

    var errorDescription: String? {
        switch self {
        case .invalidURL: return "Invalid endpoint URL"
        case .noData: return "No data received from server"
        case .decodingError: return "Failed to decode response"
        }
    }
}

struct UserProfile: Decodable, Equatable {
    let id: String
    let username: String
    let email: String
    let avatarURL: URL?

    enum CodingKeys: String, CodingKey {
        case id, username, email
        case avatarURL = "avatar_url"
    }
}

// MARK: - Concrete Implementations
final class URLSessionNetworkService: NetworkServicing {
    private let session: URLSession

    init(session: URLSession = .shared) {
        self.session = session
    }

    func fetch<T: Decodable>(endpoint: String, method: HTTPMethod, headers: [String: String]) async throws -> T {
        guard let url = URL(string: "https://api.example.com\(endpoint)") else {
            throw NetworkError.invalidURL
        }

        var request = URLRequest(url: url)
        request.httpMethod = method.rawValue
        headers.forEach { request.setValue($1, forHTTPHeaderField: $0) }

        let (data, response) = try await session.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse, 200..<300 ~= httpResponse.statusCode else {
            throw NetworkError.noData
        }

        do {
            return try JSONDecoder().decode(T.self, from: data)
        } catch {
            throw NetworkError.decodingError
        }
    }
}

protocol UserProfileCaching {
    func getProfile(for userId: String) async -> UserProfile?
    func saveProfile(_ profile: UserProfile, for userId: String) async
}

final class UserDefaultsProfileCache: UserProfileCaching {
    private let userDefaults: UserDefaults
    private let cacheKeyPrefix = "user_profile_"

    init(userDefaults: UserDefaults = .standard) {
        self.userDefaults = userDefaults
    }

    func getProfile(for userId: String) async -> UserProfile? {
        let key = cacheKeyPrefix + userId
        guard let data = userDefaults.data(forKey: key) else { return nil }
        return try? JSONDecoder().decode(UserProfile.self, from: data)
    }

    func saveProfile(_ profile: UserProfile, for userId: String) async {
        let key = cacheKeyPrefix + userId
        guard let data = try? JSONEncoder().encode(profile) else { return }
        userDefaults.set(data, forKey: key)
    }
}

import android.content.Context
import android.os.Build
import androidx.appcompat.app.AppCompatDelegate
import androidx.core.os.LocaleListCompat
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.withContext
import kotlinx.serialization.Serializable
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.json.Json
import java.net.URL
import javax.net.ssl.HttpsURLConnection

/// Kotlin 2.0 compliant user profile view model for Android 15
/// Uses K2 compiler optimizations and Android 15 dynamic language support
class UserProfileViewModel(
    private val context: Context,
    private val dispatcher: CoroutineDispatcher = Dispatchers.IO,
    private val apiBaseUrl: String = "https://api.example.com"
) {
    // MARK: - State
    private val _uiState = MutableStateFlow(UserProfileUiState())
    val uiState: StateFlow<UserProfileUiState> = _uiState.asStateFlow()

    // MARK: - Dependencies
    private val json = Json { ignoreUnknownKeys = true }

    // MARK: - Public Methods
    /// Fetches user profile with Android 15 dynamic language support
    suspend fun fetchProfile(userId: String) {
        _uiState.update { it.copy(isLoading = true, errorMessage = null) }

        // Apply Android 15 per-app language if available
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
            val locales = LocaleListCompat.forLanguageTags("en-US")
            AppCompatDelegate.setApplicationLocales(locales)
        }

        try {
            val profile = withContext(dispatcher) {
                fetchProfileFromNetwork(userId)
            }
            _uiState.update { it.copy(isLoading = false, profile = profile) }
        } catch (e: NetworkException) {
            _uiState.update { it.copy(isLoading = false, errorMessage = "Network error: ${e.message}") }
        } catch (e: Exception) {
            _uiState.update { it.copy(isLoading = false, errorMessage = "Unexpected error: ${e.message}") }
        }
    }

    /// Updates user profile with Kotlin 2.0's new data class copy optimizations
    fun updateProfileUsername(newUsername: String) {
        _uiState.update { currentState -
            currentState.profile?.let { profile -
                currentState.copy(profile = profile.copy(username = newUsername))
            } ?: currentState
        }
    }

    // MARK: - Private Methods
    @Throws(NetworkException::class)
    private fun fetchProfileFromNetwork(userId: String): UserProfile {
        val url = URL("$apiBaseUrl/users/$userId")
        val connection = (url.openConnection() as HttpsURLConnection).apply {
            requestMethod = "GET"
            setRequestProperty("Accept", "application/json")
            connectTimeout = 5000
            readTimeout = 5000
        }

        return try {
            val responseCode = connection.responseCode
            if (responseCode !in 200..299) {
                throw NetworkException("HTTP error: $responseCode")
            }

            val response = connection.inputStream.bufferedReader().use { it.readText() }
            json.decodeFromString<UserProfile>(response)
        } catch (e: Exception) {
            throw NetworkException("Failed to fetch profile: ${e.message}")
        } finally {
            connection.disconnect()
        }
    }
}

// MARK: - Supporting Models
@Serializable
data class UserProfile(
    val id: String,
    val username: String,
    val email: String,
    val avatar_url: String?
) {
    val avatarURL: URL? get() = avatar_url?.let { URL(it) }
}

data class UserProfileUiState(
    val isLoading: Boolean = false,
    val profile: UserProfile? = null,
    val errorMessage: String? = null
)

class NetworkException(message: String) : Exception(message)

// MARK: - Kotlin 2.0 K2 Compiler Optimized Extension
// New in Kotlin 2.0: context receivers for cleaner dependency injection
context(Context)
fun UserProfileViewModel.updateAppLanguage(languageTag: String) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
        val locales = LocaleListCompat.forLanguageTags(languageTag)
        AppCompatDelegate.setApplicationLocales(locales)
    }
}

import SwiftUI
import WidgetKit

/// Swift 6.0 SwiftUI view for iOS 18 displaying user profile
/// Uses new iOS 18 interactive widget preview and strict concurrency
struct UserProfileView: View {
    @StateObject private var viewModel: UserProfileViewModel
    @Environment(\.refresh) private var refresh

    init(viewModel: UserProfileViewModel = .init()) {
        _viewModel = StateObject(wrappedValue: viewModel)
    }

    var body: some View {
        NavigationStack {
            Group {
                if viewModel.isLoading {
                    ProgressView("Loading profile...")
                        .progressViewStyle(.circular)
                } else if let errorMessage = viewModel.errorMessage {
                    ErrorView(message: errorMessage) {
                        Task { await refreshProfile() }
                    }
                } else if let profile = viewModel.userProfile {
                    ProfileContent(profile: profile)
                } else {
                    Text("No profile data available")
                        .foregroundStyle(.secondary)
                }
            }
            .navigationTitle("Profile")
            .task {
                await viewModel.fetchProfile(for: "current-user-id")
            }
            .refreshable {
                await refreshProfile()
            }
        }
    }

    private func refreshProfile() async {
        await viewModel.fetchProfile(for: "current-user-id")
        // Trigger widget update for iOS 18 interactive widgets
        if #available(iOS 18.0, *) {
            WidgetCenter.shared.reloadTimelines(ofKind: "UserProfileWidget")
        }
    }
}

// MARK: - Subviews
private struct ProfileContent: View {
    let profile: UserProfile

    var body: some View {
        List {
            Section("Basic Info") {
                LabeledContent("Username", value: profile.username)
                LabeledContent("Email", value: profile.email)
            }

            Section("Avatar") {
                if let avatarURL = profile.avatarURL {
                    AsyncImage(url: avatarURL) { image in
                        image
                            .resizable()
                            .scaledToFit()
                            .frame(height: 200)
                            .clipShape(RoundedRectangle(cornerRadius: 12))
                    } placeholder: {
                        ProgressView()
                            .frame(height: 200)
                    }
                } else {
                    Text("No avatar available")
                        .foregroundStyle(.secondary)
                }
            }

            Section("Actions") {
                Button("Refresh Profile") {
                    Task { await refreshProfile() }
                }
                .buttonStyle(.borderedProminent)
            }
        }
    }

    @available(iOS 18.0, *)
    private func refreshProfile() async {
        // In real app, this would call viewModel, but for brevity we'll reload widget
        WidgetCenter.shared.reloadTimelines(ofKind: "UserProfileWidget")
    }
}

private struct ErrorView: View {
    let message: String
    let retryAction: () -> Void

    var body: some View {
        VStack(spacing: 16) {
            Image(systemName: "exclamationmark.triangle.fill")
                .font(.system(size: 48))
                .foregroundStyle(.red)

            Text(message)
                .font(.headline)
                .multilineTextAlignment(.center)
                .padding(.horizontal)

            Button("Retry", action: retryAction)
                .buttonStyle(.bordered)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
    }
}

// MARK: - iOS 18 Widget Preview
#Preview {
    UserProfileView(viewModel: {
        let vm = UserProfileViewModel()
        vm.userProfile = UserProfile(
            id: "1",
            username: "testuser",
            email: "test@example.com",
            avatarURL: URL(string: "https://example.com/avatar.jpg")
        )
        return vm
    }())
}

// Strict concurrency compliant actor for shared user data
actor UserDataStore {
    private var cachedUsers: [String: UserProfile] = [:]

    func saveUser(_ user: UserProfile) {
        cachedUsers[user.id] = user
    }

    func getUser(id: String) -> UserProfile? {
        cachedUsers[id]
    }
}

// Usage from non-isolated context (compiler enforces actor isolation)
func updateUser(_ user: UserProfile, store: UserDataStore) async {
    await store.saveUser(user) // Compiler checks actor isolation here
}

// K2 compiler optimized repository with context receivers
context(CoroutineDispatcher)
suspend fun fetchUserProfile(userId: String): UserProfile {
    return withContext(this@CoroutineDispatcher) {
        // Network call here
        UserProfile(id = userId, username = "test")
    }
}

// Usage: inject dispatcher via context
suspend fun main() {
    withContext(Dispatchers.IO) {
        val profile = fetchUserProfile("123")
    }
}

// Before: KMP-enabled build.gradle.kts
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.multiplatform") // Remove this
}

kotlin {
    androidTarget()
    iosX64()
    iosArm64()
    // ... common source sets
}

// After: Native Kotlin 2.0 build.gradle.kts
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android") // Native Kotlin plugin
}

android {
    namespace = "com.example.android15"
    compileSdk = 35 // Android 15
    defaultConfig {
        applicationId = "com.example.android15"
        minSdk = 35
        targetSdk = 35
    }
}