Caching Strategies for Mobile Apps

// iOS: Simple memory cache using NSCache
final class MemoryCache<Key: Hashable, Value> {
    private let cache = NSCache<WrappedKey, WrappedValue>()

    init(countLimit: Int = 100) {
        cache.countLimit = countLimit
    }

    func get(_ key: Key) -> Value? {
        cache.object(forKey: WrappedKey(key))?.value
    }

    func set(_ value: Value, forKey key: Key) {
        cache.setObject(WrappedValue(value), forKey: WrappedKey(key))
    }

    func remove(_ key: Key) {
        cache.removeObject(forKey: WrappedKey(key))
    }

    // NSCache requires NSObject keys and values
    private class WrappedKey: NSObject {
        let key: Key
        init(_ key: Key) { self.key = key }
        override var hash: Int { key.hashValue }
        override func isEqual(_ object: Any?) -> Bool {
            guard let other = object as? WrappedKey else { return false }
            return key == other.key
        }
    }

    private class WrappedValue {
        let value: Value
        init(_ value: Value) { self.value = value }
    }
}

// Android: Memory cache using LruCache
class MemoryCache<K, V>(maxSize: Int) {

    private val cache = object : LruCache<K, V>(maxSize) {
        override fun sizeOf(key: K & Any, value: V & Any): Int {
            // Override this to measure actual size in KB
            return 1
        }
    }

    fun get(key: K): V? = cache.get(key)

    fun put(key: K, value: V) {
        cache.put(key, value)
    }

    fun remove(key: K) {
        cache.remove(key)
    }

    fun clear() {
        cache.evictAll()
    }
}

// iOS: Cache-aside pattern with two-tier caching
final class UserRepository {
    private let memoryCache = MemoryCache<String, UserProfile>()
    private let diskCache: DiskCache<UserProfile>
    private let apiClient: APIClient

    init(apiClient: APIClient, diskCache: DiskCache<UserProfile>) {
        self.apiClient = apiClient
        self.diskCache = diskCache
    }

    func getUser(id: String) async throws -> UserProfile {
        // 1. Check memory cache
        if let cached = memoryCache.get(id) {
            return cached
        }

        // 2. Check disk cache
        if let diskCached = try diskCache.read(key: id) {
            memoryCache.set(diskCached, forKey: id)
            return diskCached
        }

        // 3. Fetch from network
        let user = try await apiClient.fetchUser(id: id)

        // 4. Populate both caches
        memoryCache.set(user, forKey: id)
        try diskCache.write(user, key: id)

        return user
    }
}

// Android: Cache-aside with coroutines
class UserRepository(
    private val memoryCache: MemoryCache<String, UserProfile>,
    private val userDao: UserDao,
    private val apiService: ApiService
) {
    suspend fun getUser(id: String): UserProfile {
        // 1. Check memory cache
        memoryCache.get(id)?.let { return it }

        // 2. Check disk cache (Room)
        userDao.getById(id)?.let { entity ->
            val profile = entity.toUserProfile()
            memoryCache.put(id, profile)
            return profile
        }

        // 3. Fetch from network
        val response = apiService.getUser(id)
        val profile = response.toUserProfile()

        // 4. Populate both caches
        memoryCache.put(id, profile)
        userDao.insert(profile.toEntity())

        return profile
    }
}

// Android: Write-through for a banking app
suspend fun transferFunds(from: Account, to: Account, amount: BigDecimal) {
    // Write to backend first — this is the source of truth
    val result = apiService.transfer(
        fromId = from.id,
        toId = to.id,
        amount = amount
    )

    // Only update cache after backend confirms
    val updatedFrom = from.copy(balance = from.balance - amount)
    val updatedTo = to.copy(balance = to.balance + amount)

    memoryCache.put(from.id, updatedFrom)
    memoryCache.put(to.id, updatedTo)
    accountDao.update(updatedFrom.toEntity())
    accountDao.update(updatedTo.toEntity())
}

// iOS: Write-through for a banking app
func transferFunds(from: Account, to: Account, amount: Decimal) async throws {
    // Write to backend first — this is the source of truth
    let result = try await apiClient.transfer(
        fromId: from.id,
        toId: to.id,
        amount: amount
    )

    // Only update cache after backend confirms
    let updatedFrom = from.withBalance(from.balance - amount)
    let updatedTo = to.withBalance(to.balance + amount)

    memoryCache.set(updatedFrom, forKey: from.id)
    memoryCache.set(updatedTo, forKey: to.id)
    try diskCache.write(updatedFrom, key: from.id)
    try diskCache.write(updatedTo, key: to.id)
}

// Android: Write-behind for social media likes
class LikeRepository(
    private val likeDao: LikeDao,
    private val apiService: ApiService,
    private val workManager: WorkManager
) {
    suspend fun toggleLike(postId: String, isLiked: Boolean) {
        // 1. Update cache immediately — UI responds instantly
        likeDao.upsert(LikeEntity(postId = postId, isLiked = isLiked, synced = false))

        // 2. Schedule background sync — batched, retried on failure
        val workRequest = OneTimeWorkRequestBuilder<LikeSyncWorker>()
            .setConstraints(
                Constraints.Builder()
                    .setRequiredNetworkType(NetworkType.CONNECTED)
                    .build()
            )
            .build()

        workManager.enqueueUniqueWork(
            "like_sync_$postId",
            ExistingWorkPolicy.REPLACE,
            workRequest
        )
    }
}

// iOS: Write-behind for social media likes
final class LikeRepository {
    private let likeStore: LikeStore   // local persistence (Core Data / SQLite)
    private let apiClient: APIClient

    init(likeStore: LikeStore, apiClient: APIClient) {
        self.likeStore = likeStore
        self.apiClient = apiClient
    }

    func toggleLike(postId: String, isLiked: Bool) async throws {
        // 1. Update cache immediately — UI responds instantly
        try await likeStore.upsert(
            PendingLike(postId: postId, isLiked: isLiked, synced: false)
        )

        // 2. Schedule background sync — batched, retried on failure
        let request = BGProcessingTaskRequest(identifier: "com.app.likeSync")
        request.requiresNetworkConnectivity = true
        try BGTaskScheduler.shared.submit(request)
    }
}

// Android: TTL-based cache entry
data class CacheEntry<T>(
    val value: T,
    val cachedAtMillis: Long,
    val ttlMillis: Long
) {
    val isExpired: Boolean
        get() = System.currentTimeMillis() - cachedAtMillis > ttlMillis
}

// Usage in repository
suspend fun getUser(id: String): UserProfile {
    userDao.getEntry(id)?.let { entry ->
        if (!entry.isExpired) return entry.value
    }

    val user = apiService.fetchUser(id)
    userDao.upsert(
        CacheEntry(
            value = user,
            cachedAtMillis = System.currentTimeMillis(),
            ttlMillis = 300_000L // 5 min TTL
        )
    )
    return user
}

// iOS: TTL-based cache entry
struct CacheEntry<T: Codable>: Codable {
    let value: T
    let cachedAt: Date
    let ttlSeconds: TimeInterval

    var isExpired: Bool {
        Date().timeIntervalSince(cachedAt) > ttlSeconds
    }
}

// Usage in repository
func getUser(id: String) async throws -> UserProfile {
    if let entry: CacheEntry<UserProfile> = try diskCache.read(key: id),
       !entry.isExpired {
        return entry.value
    }

    let user = try await apiClient.fetchUser(id: id)
    let entry = CacheEntry(value: user, cachedAt: Date(), ttlSeconds: 300) // 5 min TTL
    try diskCache.write(entry, key: id)
    return user
}

// Android: Version-based cache check
class FeedRepository(
    private val feedDao: FeedDao,
    private val apiService: ApiService
) {
    suspend fun getFeed(): List<FeedItem> {
        val cachedVersion = feedDao.getCurrentVersion()

        return try {
            val response = apiService.getFeed(ifNoneMatch = cachedVersion)

            if (response.code() == 304) {
                // Cache is still valid
                feedDao.getAll().map { it.toFeedItem() }
            } else {
                val items = response.body()!!
                val newVersion = response.headers()["ETag"]
                feedDao.replaceAll(items.map { it.toEntity() }, newVersion)
                items
            }
        } catch (e: IOException) {
            // Network error — fall back to cache
            feedDao.getAll().map { it.toFeedItem() }
        }
    }
}

// iOS: Version-based cache check
final class FeedRepository {
    private let feedStore: FeedStore
    private let apiClient: APIClient

    init(feedStore: FeedStore, apiClient: APIClient) {
        self.feedStore = feedStore
        self.apiClient = apiClient
    }

    func getFeed() async throws -> [FeedItem] {
        let cachedVersion = try feedStore.currentVersion()

        do {
            let (items, response) = try await apiClient.getFeed(ifNoneMatch: cachedVersion)

            if response.statusCode == 304 {
                // Cache is still valid
                return try feedStore.getAll()
            } else {
                let newVersion = response.value(forHTTPHeaderField: "ETag")
                try feedStore.replaceAll(items, version: newVersion)
                return items
            }
        } catch is URLError {
            // Network error — fall back to cache
            return try feedStore.getAll()
        }
    }
}

// Android: Simplified image caching pipeline
object ImageLoader {
    private val memoryCache = LruCache<String, Bitmap>(100)
    private lateinit var diskCacheDir: File
    private val client = OkHttpClient()
    // Track in-flight downloads to avoid duplicate requests
    private val inFlightRequests = mutableMapOf<String, Deferred<Bitmap>>()
    private val mutex = Mutex()
    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)

    fun init(context: Context) {
        diskCacheDir = File(context.cacheDir, "ImageCache").apply { mkdirs() }
    }

    suspend fun loadImage(url: String): Bitmap {
        // 1. Memory cache
        memoryCache.get(url)?.let { return it }

        // 2. Disk cache
        val file = File(diskCacheDir, url.sha256Hash())
        if (file.exists()) {
            BitmapFactory.decodeFile(file.path)?.let { bitmap ->
                memoryCache.put(url, bitmap)
                return bitmap
            }
        }

        // 3. Deduplicate in-flight requests
        val download = mutex.withLock {
            inFlightRequests.getOrPut(url) {
                scope.async {
                    val request = Request.Builder().url(url).build()
                    val bytes = client.newCall(request).execute().use { response ->
                        response.body?.bytes() ?: throw IOException("Empty body")
                    }
                    val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
                        ?: throw IOException("Decoding failed")
                    file.writeBytes(bytes)
                    memoryCache.put(url, bitmap)
                    bitmap
                }
            }
        }

        try {
            return download.await()
        } finally {
            mutex.withLock { inFlightRequests.remove(url) }
        }
    }
}

// iOS: Simplified image caching pipeline
final class ImageLoader {
    static let shared = ImageLoader()

    private let memoryCache = NSCache<NSString, UIImage>()
    private let diskCachePath: URL
    private let session = URLSession.shared
    // Track in-flight downloads to avoid duplicate requests
    private var inFlightRequests: [String: Task<UIImage, Error>] = [:]

    init() {
        let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
        diskCachePath = caches.appendingPathComponent("ImageCache")
        try? FileManager.default.createDirectory(at: diskCachePath, withIntermediateDirectories: true)
    }

    func loadImage(from url: URL) async throws -> UIImage {
        let key = url.absoluteString

        // 1. Memory cache
        if let cached = memoryCache.object(forKey: key as NSString) {
            return cached
        }

        // 2. Disk cache
        let filePath = diskCachePath.appendingPathComponent(key.sha256Hash)
        if let data = try? Data(contentsOf: filePath),
           let image = UIImage(data: data) {
            memoryCache.setObject(image, forKey: key as NSString)
            return image
        }

        // 3. Deduplicate in-flight requests
        if let existingTask = inFlightRequests[key] {
            return try await existingTask.value
        }

        let task = Task<UIImage, Error> {
            let (data, _) = try await session.data(from: url)
            guard let image = UIImage(data: data) else {
                throw ImageLoadingError.decodingFailed
            }
            try data.write(to: filePath)
            memoryCache.setObject(image, forKey: key as NSString)
            return image
        }

        inFlightRequests[key] = task
        defer { inFlightRequests.removeValue(forKey: key) }
        return try await task.value
    }
}

// Android: Setting up OkHttp with HTTP caching
val cacheDir = File(context.cacheDir, "http_cache")
val cacheSize = 50L * 1024 * 1024 // 50 MB

val client = OkHttpClient.Builder()
    .cache(Cache(cacheDir, cacheSize))
    .addInterceptor { chain ->
        var request = chain.request()

        // Force cache when offline
        if (!isNetworkAvailable()) {
            request = request.newBuilder()
                .cacheControl(CacheControl.FORCE_CACHE)
                .build()
        }

        chain.proceed(request)
    }
    .build()

// iOS: Setting up URLSession with HTTP caching
let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
    .appendingPathComponent("http_cache")

let config = URLSessionConfiguration.default
config.urlCache = URLCache(
    memoryCapacity: 10 * 1024 * 1024,  // 10 MB in memory
    diskCapacity: 50 * 1024 * 1024,    // 50 MB on disk
    directory: cacheDir
)
config.requestCachePolicy = .useProtocolCachePolicy

let session = URLSession(configuration: config)

// Force cache when offline
func makeRequest(url: URL) -> URLRequest {
    var request = URLRequest(url: url)
    if !isNetworkAvailable() {
        request.cachePolicy = .returnCacheDataDontLoad
    }
    return request
}

// Override server cache headers for specific endpoints
.addNetworkInterceptor { chain ->
    val response = chain.proceed(chain.request())

    if (chain.request().url.encodedPath.contains("/feed")) {
        response.newBuilder()
            .header("Cache-Control", "public, max-age=60")
            .build()
    } else {
        response
    }
}

// Override server cache headers for specific endpoints
func urlSession(
    _ session: URLSession,
    dataTask: URLSessionDataTask,
    willCacheResponse proposedResponse: CachedURLResponse
) async -> CachedURLResponse? {
    guard let response = proposedResponse.response as? HTTPURLResponse,
          let url = response.url, url.path.contains("/feed"),
          var headers = response.allHeaderFields as? [String: String] else {
        return proposedResponse
    }

    headers["Cache-Control"] = "public, max-age=60"

    guard let newResponse = HTTPURLResponse(
        url: url,
        statusCode: response.statusCode,
        httpVersion: nil,
        headerFields: headers
    ) else {
        return proposedResponse
    }

    return CachedURLResponse(response: newResponse, data: proposedResponse.data)
}

// Android: Caching cursor-paginated feed data
class FeedCache(
    private val feedDao: FeedDao,
    private val apiService: ApiService
) {
    /** Load the next page after the given cursor. */
    suspend fun loadPage(afterCursor: String?): FeedPage {
        // Check if we have this page cached
        feedDao.getPage(afterCursor)?.let { cached ->
            if (!cached.isExpired) return cached
        }

        val page = apiService.getFeed(after = afterCursor, limit = 20)

        // Store items with their position metadata
        feedDao.insertPage(
            items = page.items,
            nextCursor = page.nextCursor,
            previousCursor = afterCursor,
            fetchedAt = System.currentTimeMillis()
        )

        return page
    }

    /** Pull-to-refresh: fetch new items and prepend to cache */
    suspend fun refresh(): List<FeedItem> {
        val latestCachedId = feedDao.getLatestItemId()

        // Fetch newest items until we find overlap with our cache
        val newItems = apiService.getFeed(after = null, limit = 20)

        val overlapIndex = newItems.items.indexOfFirst { it.id == latestCachedId }
        return if (overlapIndex >= 0) {
            // Only insert items before the overlap
            val freshItems = newItems.items.take(overlapIndex)
            feedDao.prependItems(freshItems)
            freshItems
        } else {
            // No overlap — gap too large, reset cache
            feedDao.clearAndInsert(newItems.items, nextCursor = newItems.nextCursor)
            newItems.items
        }
    }
}

// iOS: Caching cursor-paginated feed data
final class FeedCache {
    private let feedDao: FeedDao

    /// Load the next page after the given cursor.
    func loadPage(after cursor: String?) async throws -> FeedPage {
        // Check if we have this page cached
        if let cached = try feedDao.getPage(afterCursor: cursor),
           !cached.isExpired {
            return cached
        }

        let page = try await apiClient.getFeed(after: cursor, limit: 20)

        // Store items with their position metadata
        try feedDao.insertPage(
            items: page.items,
            nextCursor: page.nextCursor,
            previousCursor: cursor,
            fetchedAt: Date()
        )

        return page
    }

    /// Pull-to-refresh: fetch new items and prepend to cache
    func refresh() async throws -> [FeedItem] {
        let latestCachedId = try feedDao.getLatestItemId()

        // Fetch newest items until we find overlap with our cache
        let newItems = try await apiClient.getFeed(after: nil, limit: 20)

        if let overlapIndex = newItems.items.firstIndex(where: { $0.id == latestCachedId }) {
            // Only insert items before the overlap
            let freshItems = Array(newItems.items.prefix(upTo: overlapIndex))
            try feedDao.prependItems(freshItems)
            return freshItems
        } else {
            // No overlap — gap too large, reset cache
            try feedDao.clearAndInsert(newItems.items, nextCursor: newItems.nextCursor)
            return newItems.items
        }
    }
}