package net.pokeranalytics.android.model

import io.realm.Realm
import io.realm.RealmObject
import io.realm.RealmResults
import io.realm.Sort
import net.pokeranalytics.android.R
import net.pokeranalytics.android.model.realm.*
import net.pokeranalytics.android.ui.view.Localizable

/**
 * An interface to easily handle the validity of any object we want to save
 */
interface ObjectSavable {
    fun isValidForSave(): Boolean { return true }
}

/**
 * An enum managing the business objects related to a realm results
 */
enum class LiveData : Localizable {
    BANKROLL,
    GAME,
    LOCATION,
    TOURNAMENT_FEATURE,
    TRANSACTION_TYPE;

    fun items(realm: Realm, fieldName: String? = null, sortOrder: Sort? = null): RealmResults<*> {
        return realm.where(this.relatedEntity).findAll().sort(fieldName?:this.sortingFieldName, sortOrder?:this.sorting)
    }

    private var sortingFieldName: String = "name"
    private var sorting: Sort = Sort.ASCENDING


    private val relatedEntity: Class < out RealmObject >
        get() {
            return when (this) {
                BANKROLL -> Bankroll::class.java
                GAME -> Game::class.java
                LOCATION -> Location::class.java
                TOURNAMENT_FEATURE -> TournamentFeature::class.java
                TRANSACTION_TYPE -> TransactionType::class.java
            }
        }

    fun newEntity(): RealmObject {
        return when (this) {
            BANKROLL -> Bankroll()
            GAME -> Game()
            LOCATION -> Location()
            TOURNAMENT_FEATURE -> TournamentFeature()
            TRANSACTION_TYPE -> TransactionType()
        }
    }

    fun getData(realm:Realm, primaryKey:String?): RealmObject? {
        var proxyItem: RealmObject? = null
        primaryKey?.let {
            val t = realm.where(this.relatedEntity).equalTo("id", it).findFirst()
            t?.let {
                proxyItem = t
            }
        }
        return proxyItem
    }

    fun updateOrCreate(realm:Realm, primaryKey:String?): RealmObject {
        val proxyItem: RealmObject? = this.getData(realm, primaryKey)
        proxyItem?.let {
            return realm.copyFromRealm(it)
        } ?: run {
            return this.newEntity()
/*            realm.beginTransaction()
            val t = realm.createObject(this.relatedEntity, UUID.randomUUID().toString())
            realm.commitTransaction()
            return realm.copyFromRealm(t)*/
        }
    }

    override val resId: Int?
        get() {
            return when (this) {
                BANKROLL -> R.string.bankroll
                GAME -> R.string.game
                LOCATION -> R.string.location
                TOURNAMENT_FEATURE -> R.string.tournament_type
                TRANSACTION_TYPE -> R.string.operation_types
            }
        }}

/*
interface ListableDataSource {
    fun items(realm: Realm, fieldName: String? = null, sortOrder: Sort? = null): RealmResults<*>
    var sortingFieldName: String
    var sorting: Sort
    var relatedEntity: Class < out RealmObject >
}
*/