Added SessionGroup creation + refactoring

app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt

@@ -34,16 +34,18 @@ open class TimeFrame : RealmObject() {
     // indicates a state of pause
     var paused: Boolean = false
 
+    // Session
     @LinkingObjects("timeFrame")
-    private val sessions: RealmResults<Session>? = null
+    private val sessions: RealmResults<Session>? = null // we should have only one session
-
-    @LinkingObjects("timeFrame")
-    private val groups: RealmResults<SessionGroup>? = null
 
     @Ignore
     var session: Session? = null
         get() = this.sessions?.first()
 
+    // Group
+    @LinkingObjects("timeFrame")
+    private val groups: RealmResults<SessionGroup>? = null // we should have only one group
+
     @Ignore
     var group: SessionGroup? = null
         get() = this.groups?.first()
@@ -60,13 +62,7 @@ open class TimeFrame : RealmObject() {
     }
 
     private fun computeDuration() {
-
+        var endDate: Date = this.endDate ?: Date()
-        var endDate: Date
-        if (this.endDate != null) {
-            endDate = this.endDate!!
-        } else {
-            endDate = Date()
-        }
         this.duration = endDate.time - startDate.time - this.breakDuration
     }
 
@@ -102,83 +98,107 @@ open class TimeFrame : RealmObject() {
      */
     private fun updateTimeFrames(sessionGroups: RealmResults<SessionGroup>) {
 
-        // update
+        when (sessionGroups.size) {
-        if (sessionGroups.size == 1) {
+            0 -> this.createSessionGroup()
+            1 -> this.updateSingleSessionGroup(sessionGroups.first()?.timeFrame!!)
+            else -> this.mergeSessionGroups(sessionGroups)
+        }
 
-            // 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
-            }
 
-            // Realm Update
+    private fun createSessionGroup() {
-            val realm = Realm.getDefaultInstance()
-            realm.beginTransaction()
-            realm.copyToRealmOrUpdate(groupTimeFrame)
-            realm.commitTransaction()
 
-        } else if (sessionGroups.size > 1) {
+        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")
+        }
 
-            var startDate: Date = this.startDate
+    }
-            var endDate: Date? = this.endDate
 
-            val timeFrames = sessionGroups.mapNotNull { it.timeFrame }
+    /**
-            timeFrames.forEach { tf ->
+     * Single session group update
-                if (tf.startDate.before(startDate)) {
+     * Changes the group timeframe using the current timeframe dates
-                    startDate = tf.startDate
+     */
-                }
+    private fun updateSingleSessionGroup(groupTimeFrame: TimeFrame) {
 
-                endDate?.let { ed ->
+        if (this.startDate.before(groupTimeFrame.startDate)) {
-                    tf.endDate?.let { tfed ->
+            groupTimeFrame.startDate = this.startDate
-                        if (tfed.after(ed)) {
+        }
-                            endDate = tfed
+        val endDate = this.endDate
-                        }
+        if (endDate != null && groupTimeFrame.endDate != null && endDate.after(groupTimeFrame.endDate)) {
-                    }
+            groupTimeFrame.endDate = endDate
-                } ?: run {
+        } else if (endDate == null) {
-                    endDate = tf.endDate
+            groupTimeFrame.endDate = null
-                }
+        }
 
-            }
+        // Realm Update
+        val realm = Realm.getDefaultInstance()
+        realm.beginTransaction()
+        realm.copyToRealmOrUpdate(groupTimeFrame)
+        realm.commitTransaction()
 
-            // get all sessions from groups
+    }
-            var sessions = sessionGroups.flatMap { it.sessions }
 
-            // Start Realm updates
+    /**
-            val realm = Realm.getDefaultInstance()
+     * Multiple session groups update:
-            realm.beginTransaction()
+     * Merges all groups into one (delete all then create a new one)
+     */
+    private fun mergeSessionGroups(sessionGroups: RealmResults<SessionGroup>) {
 
-            // delete all groups
+        var startDate: Date = this.startDate
-            sessionGroups.deleteAllFromRealm()
+        var endDate: Date? = this.endDate
 
-            // Create a new groups
+        val timeFrames = sessionGroups.mapNotNull { it.timeFrame }
-            val group: SessionGroup = SessionGroup.newInstance()
+        timeFrames.forEach { tf ->
-            group.timeFrame?.let {
+            if (tf.startDate.before(startDate)) {
-                it.startDate = startDate
+                startDate = tf.startDate
-                it.endDate = endDate
-            } ?: run {
-                throw ModelException("TimeFrame should never be null here")
             }
 
-            // Add the session linked to this timeframe to the new group
+            endDate?.let { ed ->
-            this.sessions?.first()?.let {
+                tf.endDate?.let { tfed ->
-                group.sessions.add(it)
+                    if (tfed.after(ed)) {
+                        endDate = tfed
+                    }
+                }
             } ?: run {
-                throw ModelException("TimeFrame should never be null here")
+                endDate = tf.endDate
             }
 
-            // Add all orphan sessions
+        }
-            group.sessions.addAll(sessions)
+
+        // get all sessions from groups
+        var sessions = sessionGroups.flatMap { it.sessions }
 
-            realm.commitTransaction()
+        // 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()
     }
 
 }