class AdapterStateRepository {
  private val keyGenerator = AtomicInteger()
  private val memoryCache = object : LruCache<Int, ByteArray>(MEMORY_CACHE_COUNT) {
    override fun entryRemoved(evicted: Boolean, key: Int?, oldValue: ByteArray?, newValue: ByteArray?) {
      if (evicted && oldValue != null && key != null) {
        writeToDiskCache(key, oldValue)
      }
    }
  }

  private val cacheDirectory by lazy {
    File(TradeMeApp.getContext().cacheDir, DISK_CACHE_PREFIX).apply {
      delete()
      mkdir()
    }
  }

  private fun writeToDiskCache(key: Int, oldValue: ByteArray) {
    File(cacheDirectory, key.toString()).writeBytes(oldValue)
  }

  private fun getFromDiskCache(key: Int): ByteArray? = with(File(cacheDirectory, key.toString())) {
    return when {
      exists() && canRead() -> {
        val result = readBytes()
        delete()
        result
      }
      else -> null
    }
  }

  fun put(bundle: Bundle): Int {
    val key = keyGenerator.getAndIncrement()
    with(Parcel.obtain()) {
      writeBundle(bundle)
      memoryCache.put(key, marshall())
      recycle()
    }
    return key
  }

  fun get(key: Int, classLoader: ClassLoader): Bundle? {
    val data = memoryCache[key] ?: getFromDiskCache(key) ?: return null
    memoryCache.remove(key)
    with(Parcel.obtain()) {
      unmarshall(data, 0, data.size)
      setDataPosition(0)
      val bundle = readBundle(classLoader)
      recycle()
      return bundle
    }
  }

  fun trimMemory(level: Int) {
    if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL) {
      memoryCache.evictAll()
    }
  }
}