package net.pokeranalytics.android.model

import io.realm.Realm
import io.realm.RealmResults
import io.realm.Sort
import io.realm.kotlin.where
import net.pokeranalytics.android.exceptions.PokerAnalyticsException
import net.pokeranalytics.android.model.filter.FilterHelper
import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.interfaces.Identifiable
import net.pokeranalytics.android.model.realm.*

sealed class Criteria {
    abstract class RealmCriteria : Criteria() {
        inline fun <reified T:Identifiable> comparison(): List<QueryCondition> {
            return compare < QueryCondition.QueryDataCondition<Identifiable>, T >()
        }
    }

    abstract class SimpleCriteria(private val condition:QueryCondition): Criteria() {
        fun comparison(): List<QueryCondition> {
            return listOf(condition)
        }
    }

    abstract class StaticCriteria : Criteria() {
        inline fun <reified T:QueryCondition.SingleValueQueryCondition> comparison(): List<QueryCondition> {
            QueryCondition.distinct<Session, T>()?.let {
                val values = it.mapNotNull { session ->
                    when (this) {
                        is Limits -> session.limit
                        else -> null
                    }
                }
                return compare<T>(values)
            }
            return listOf<T>()
        }
    }

    object Bankrolls: RealmCriteria()
    object Games: RealmCriteria()
    object TournamentNames: RealmCriteria()
    object Locations: RealmCriteria()
    object TournamentFeatures: RealmCriteria()
    object Limits: StaticCriteria()
    object TournamentTypes : StaticCriteria()

    object Tournament : SimpleCriteria(QueryCondition.TOURNAMENT)

    val queryConditions: List<QueryCondition>
        get() {
            return when (this) {
                is Bankrolls -> comparison<Bankroll>()
                is Games -> comparison<Game>()
                is TournamentFeatures-> comparison<TournamentFeature>()
                is TournamentNames-> comparison<TournamentName>()
                is Locations -> comparison<Location>()
                is SimpleCriteria -> comparison()
                is Limits -> comparison<QueryCondition.LIMIT>()
                is TournamentTypes -> comparison<QueryCondition.TOURNAMENT_TYPE>()
                else -> throw PokerAnalyticsException.QueryTypeUnhandled
            }
        }

    companion object {
        inline fun < reified  S : QueryCondition.QueryDataCondition<Identifiable>, reified T : Identifiable > compare(): List<S> {
            val objects = arrayListOf<S>()
            val realm = Realm.getDefaultInstance()
            realm.where<T>().findAll().forEach {
                objects.add((QueryCondition.getInstance<T>() as S).apply {
                    setObject(it)
                })
            }
            realm.close()
            return objects
        }

        inline fun < reified  S : QueryCondition.SingleValueQueryCondition > compare(values:List<Int>): List<S> {
            val objects = arrayListOf<S>()
            values.forEach {
                objects.add((S::class.java.newInstance()).apply {
                    setValue(it)
                })
            }
            return objects
        }
    }

}