package com.dgis.utils

import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.os.Handler
import android.os.Looper
import android.util.Base64
import java.io.BufferedInputStream
import java.net.URL

object ImageCacheManager {

    private val imageCache = mutableMapOf<String, Bitmap?>()
    private val mainHandler = Handler(Looper.getMainLooper())

    fun getImage(context: Context, source: String, callback: (Bitmap?) -> Unit) {
        imageCache[source]?.let {
            callback(it)
            return
        }

        downloadImageAsync(context, source) { bitmap ->
            imageCache[source] = bitmap
            callback(bitmap)
        }
    }

    private fun downloadImageAsync(context: Context, url: String, callback: (Bitmap?) -> Unit) {
        Thread {
            try {
                val bitmap = loadBitmap(context, url)
                mainHandler.post { callback(bitmap) }
            } catch (e: Exception) {
                e.printStackTrace()
                mainHandler.post { callback(null) }
            }
        }.start()
    }

    private fun loadBitmap(context: Context, url: String): Bitmap = when {
        url.startsWith("http://") || url.startsWith("https://") -> loadFromNetwork(url)
        url.startsWith("data:image") -> loadFromBase64(url)
        url.startsWith("file://") -> loadFromFile(url)
        else -> loadFromResources(context, url)
    }

    private fun loadFromNetwork(url: String): Bitmap {
        val connection = URL(url).openConnection()
        connection.connect()
        return connection.getInputStream().use { inputStream ->
            BufferedInputStream(inputStream).use { bufferedStream ->
                BitmapFactory.decodeStream(bufferedStream)
            }
        }
    }

    private fun loadFromBase64(dataUrl: String): Bitmap {
        val base64Data = dataUrl.substringAfter(",")
        val decodedBytes = Base64.decode(base64Data, Base64.DEFAULT)
        return BitmapFactory.decodeByteArray(decodedBytes, 0, decodedBytes.size)
    }

    private fun loadFromFile(fileUrl: String): Bitmap {
        val filePath = fileUrl.removePrefix("file://")
        return BitmapFactory.decodeFile(filePath)
    }

    private fun loadFromResources(context: Context, resourceName: String): Bitmap {
        val resourceId = context.resources.getIdentifier(resourceName, "drawable", context.packageName)
        return BitmapFactory.decodeResource(context.resources, resourceId)
    }
}