@Database(entities = [ProductEntity::class], version = 1)
abstract class AppDatabase : RoomDatabase() {

    abstract fun productDao(): ProductDao

    companion object {
        const val DATABASE_NAME = "basic-sample-db"

        private val mIsDatabaseCreated = MutableLiveData<Boolean>()

        @Volatile
        private var instance: AppDatabase? = null
        private var LOCK = AppDatabase::class

        operator fun invoke(context: Context, executors: AppExecutors): AppDatabase {
            if (instance == null) {
                synchronized(LOCK) {
                    if (instance == null) {
                        instance = buildDatabase(context.applicationContext, executors)
                        instance?.updateDatabaseCreated(context.applicationContext)
                    }
                }
            }
            return instance!!
        }

        private fun buildDatabase(appContext: Context, executors: AppExecutors): AppDatabase {
            return Room
                .databaseBuilder(appContext, AppDatabase::class.java, DATABASE_NAME)
                .addCallback(object : Callback() {
                    override fun onCreate(db: SupportSQLiteDatabase) {
                        super.onCreate(db)
                        executors.diskIO.execute {
                            addDelay()

                            // Generate the data for pre-population
                            val database =
                                AppDatabase(appContext, executors)
                            val products =
                                DataGenerator.generateProducts()

                            insertData(database, products)

                            database.setDatabaseCreated()
                        }
                    }
                })
                .build()
        }

        private fun addDelay() {
            try {
                Thread.sleep(4000)
            } catch (ignored: InterruptedException) {
            }
        }

        private fun insertData(database: AppDatabase, products: List<ProductEntity>) {
            database.runInTransaction {
                database.productDao().insertAll(products)
            }
        }

    }
    
    private fun setDatabaseCreated() {
        mIsDatabaseCreated.postValue(true)
    }

    private fun updateDatabaseCreated(context: Context) {
        if (context.getDatabasePath(DATABASE_NAME).exists()) {
            setDatabaseCreated()
        }
    }

    fun getDatabaseCreated(): LiveData<Boolean> {
        return mIsDatabaseCreated
    }
}

class DataRepository(private val database: AppDatabase) {

    private var mObservableProducts: MediatorLiveData<List<ProductEntity>> = MediatorLiveData()

    init {
        mObservableProducts.addSource(
            database.productDao().loadAllProducts()
        ) { productEntities ->
            if (database.getDatabaseCreated().value != null) {
                mObservableProducts.postValue(productEntities)
            }
        }
    }

    companion object {
        @Volatile
        private var instance: DataRepository? = null
        private var LOCK = DataRepository::class

        operator fun invoke(database: AppDatabase): DataRepository {
            return instance ?: synchronized(LOCK) {
                instance ?: DataRepository(database)
            }
        }
    }

    fun getProducts(): LiveData<List<ProductEntity>> {
        return mObservableProducts
    }

    fun loadProduct(productId: Int): LiveData<ProductEntity> {
        return database.productDao().loadProduct(productId)
    }
}