diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
index b4cf3d48..4839fc7b 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt
@@ -3,7 +3,10 @@ package net.pokeranalytics.android.model.realm
 import io.realm.*
 import io.realm.annotations.Ignore
 import io.realm.annotations.PrimaryKey
-import net.pokeranalytics.android.ui.adapter.components.*
+import net.pokeranalytics.android.ui.adapter.components.DisplayableDataSource
+import net.pokeranalytics.android.ui.adapter.components.DynamicRowDelegate
+import net.pokeranalytics.android.ui.adapter.components.DynamicRowInterface
+import net.pokeranalytics.android.ui.adapter.components.SessionRow
 import net.pokeranalytics.android.util.data.sessionDao
 import java.util.*
 import kotlin.collections.ArrayList
diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt
index 784bdb00..8f0eb411 100644
--- a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt
+++ b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt
@@ -4,6 +4,7 @@ import io.realm.Realm
 import io.realm.RealmObject
 import io.realm.RealmQuery
 import io.realm.RealmResults
+import io.realm.annotations.Ignore
 import io.realm.annotations.LinkingObjects
 import net.pokeranalytics.android.exceptions.ModelException
 import java.util.*
@@ -13,23 +14,11 @@ open class TimeFrame : RealmObject() {
 
     // A start date
     var startDate: Date = Date()
-        set(value) {
-            field = value
-            this.computeDuration()
-            if (this.session != null) {
-                this.notifySessionDateChange()
-            }
-        }
+        private set
 
     // An end date
     var endDate: Date? = null
-        set(value) {
-            field = value
-            this.computeDuration()
-            if (this.session != null) {
-                this.notifySessionDateChange()
-            }
-        }
+        private set
 
     // The break duration
     var breakDuration: Long = 0L
@@ -45,20 +34,35 @@ open class TimeFrame : RealmObject() {
     // indicates a state of pause
     var paused: Boolean = false
 
+    // Session
     @LinkingObjects("timeFrame")
-    private val session: RealmResults<Session>? = null
+    private val sessions: RealmResults<Session>? = null // we should have only one session
+
+    @Ignore
+    var session: Session? = null
+        get() = this.sessions?.first()
 
+    // Group
     @LinkingObjects("timeFrame")
-    private val group: RealmResults<SessionGroup>? = null
+    private val groups: RealmResults<SessionGroup>? = null // we should have only one group
 
-    private fun computeDuration() {
+    @Ignore
+    var group: SessionGroup? = null
+        get() = this.groups?.first()
 
-        var endDate: Date
-        if (this.endDate != null) {
-            endDate = this.endDate!!
-        } else {
-            endDate = Date()
+    fun setDate(startDate: Date, endDate: Date?) {
+        this.startDate = startDate
+        this.endDate = endDate
+
+        this.computeDuration()
+
+        if (this.session != null) {
+            this.notifySessionDateChange()
         }
+    }
+
+    private fun computeDuration() {
+        var endDate: Date = this.endDate ?: Date()
         this.duration = endDate.time - startDate.time - this.breakDuration
     }
 
@@ -94,74 +98,119 @@ open class TimeFrame : RealmObject() {
      */
     private fun updateTimeFrames(sessionGroups: RealmResults<SessionGroup>) {
 
-        // update
-        if (sessionGroups.size == 1) {
-            // we are sure that the timeframe is not null from the realm query
-            val groupTimeFrame: TimeFrame = sessionGroups.first()?.timeFrame!!
-            if (this.startDate.before(groupTimeFrame.startDate)) {
-                groupTimeFrame.startDate = this.startDate
-            }
-            val endDate = this.endDate
-            if (endDate != null && groupTimeFrame.endDate != null && endDate.after(groupTimeFrame.endDate)) {
-                groupTimeFrame.endDate = endDate
-            } else if (endDate == null) {
-                groupTimeFrame.endDate = null
-            }
+        when (sessionGroups.size) {
+            0 -> this.createSessionGroup()
+            1 -> this.updateSingleSessionGroup(sessionGroups.first()!!)
+            else -> this.mergeSessionGroups(sessionGroups)
+        }
 
-        } else if (sessionGroups.size > 1) {
+    }
 
-            var startDate: Date = this.startDate
-            var endDate: Date? = this.endDate
+    /**
+     * Creates the session group when the session has none
+     */
+    private fun createSessionGroup() {
 
-            val timeFrames = sessionGroups.mapNotNull { it.timeFrame }
-            timeFrames.forEach { tf ->
-                if (tf.startDate.before(startDate)) {
-                    startDate = tf.startDate
-                }
+        val realm = Realm.getDefaultInstance()
+        realm.beginTransaction()
+
+        val group: SessionGroup = SessionGroup.newInstance()
+        group.timeFrame?.let {
+            it.startDate = this.startDate
+            it.endDate = this.endDate
+        } ?: run {
+            throw ModelException("TimeFrame should never be null here")
+        }
+        group.sessions.add(this.session)
+        realm.commitTransaction()
+    }
 
-                endDate?.let { ed ->
-                    tf.endDate?.let { tfed ->
-                        if (tfed.after(ed)) {
-                            endDate = tfed
-                        }
-                    }
-                } ?: run {
-                    endDate = tf.endDate
-                }
+    /**
+     * Single session group update
+     * Changes the group timeframe using the current timeframe dates
+     */
+    private fun updateSingleSessionGroup(sessionGroup: SessionGroup) {
 
-            }
+        var groupTimeFrame: TimeFrame = sessionGroup.timeFrame!! // tested in the query
 
-            // get all sessions from groups
-            val sessions = sessionGroups.flatMap { it.sessions }
+        if (this.startDate.before(groupTimeFrame.startDate)) {
+            groupTimeFrame.startDate = this.startDate
+        }
+        val endDate = this.endDate
+        if (endDate != null && groupTimeFrame.endDate != null && endDate.after(groupTimeFrame.endDate)) {
+            groupTimeFrame.endDate = endDate
+        } else if (endDate == null) {
+            groupTimeFrame.endDate = null
+        }
 
-            // delete all groups
-            val realm = Realm.getDefaultInstance()
-            realm.executeTransaction {
-                sessionGroups.deleteAllFromRealm()
-            }
+        // Realm Update
+        val realm = Realm.getDefaultInstance()
+        realm.beginTransaction()
+        if (!sessionGroup.sessions.contains(this.session)) {
+            sessionGroup.sessions.add(this.session)
+        }
+        realm.copyToRealmOrUpdate(groupTimeFrame)
+        realm.commitTransaction()
 
-            val group: SessionGroup = SessionGroup.newInstance()
-            group.timeFrame?.let {
-                it.startDate = startDate
-                it.endDate = endDate
-            } ?: run {
-                throw ModelException("TimeFrame should never be null here")
+    }
+
+    /**
+     * Multiple session groups update:
+     * Merges all groups into one (delete all then create a new one)
+     */
+    private fun mergeSessionGroups(sessionGroups: RealmResults<SessionGroup>) {
+
+        var startDate: Date = this.startDate
+        var endDate: Date? = this.endDate
+
+        val timeFrames = sessionGroups.mapNotNull { it.timeFrame }
+        timeFrames.forEach { tf ->
+            if (tf.startDate.before(startDate)) {
+                startDate = tf.startDate
             }
 
-            this.session?.first()?.let {
-                group.sessions.add(it)
+            endDate?.let { ed ->
+                tf.endDate?.let { tfed ->
+                    if (tfed.after(ed)) {
+                        endDate = tfed
+                    }
+                }
             } ?: run {
-                throw ModelException("TimeFrame should never be null here")
+                endDate = tf.endDate
             }
 
+        }
 
+        // get all sessions from groups
+        var sessions = sessionGroups.flatMap { it.sessions }
 
-            //@todo delete all timeframes, create a new one
-
-
+        // Start Realm updates
+        val realm = Realm.getDefaultInstance()
+        realm.beginTransaction()
+
+        // delete all groups
+        sessionGroups.deleteAllFromRealm()
+
+        // Create a new groups
+        val group: SessionGroup = SessionGroup.newInstance()
+        group.timeFrame?.let {
+            it.startDate = startDate
+            it.endDate = endDate
+        } ?: run {
+            throw ModelException("TimeFrame should never be null here")
+        }
 
+        // Add the session linked to this timeframe to the new group
+        this.sessions?.first()?.let {
+            group.sessions.add(it)
+        } ?: run {
+            throw ModelException("TimeFrame should never be null here")
         }
 
+        // Add all orphan sessions
+        group.sessions.addAll(sessions)
+
+        realm.commitTransaction()
     }
 
 }