data class DeleteRequest(
    @SerializedName("obj_type") val type: Int,
    @SerializedName("id") val uuid: String
)

data class DeviationRequest(
    @SerializedName("obj_type") val objectType: Int,
    @SerializedName("id") val uuid: String,
    @SerializedName("date") val timestamp: Long, //todo remove 0
    @SerializedName("forecastId") val forecastId: String,
    @SerializedName("measurementId") val measurementId: String,
    @SerializedName("reasonIds") val reasonsIds: List<String>
) : UpdateRequest

data class GlucoseLevelRequest(
    @SerializedName("obj_type") val objectType: Int,
    @SerializedName("id") val uuid: String,
    @SerializedName("date") val timestamp: Long,
    @SerializedName("value") val value: Int,
    @SerializedName("type") val type: Int
) : UpdateRequest


data class MedicationRequest(
    @SerializedName("obj_type") val objectType: Int,
    @SerializedName("id") val uuid: String,
    @SerializedName("date") val timestamp: Long,
    @SerializedName("value") val value: Int,
    @SerializedName("drugId") val drugId: String?
): UpdateRequest

data class SyncRequest(
    val userId: String,
    val insert: List<UpdateRequest>,
    val update: List<UpdateRequest>,
    val delete: List<DeleteRequest>
)

interface UpdateRequest


class SyncModel(
    private val repository: RoomControlPointRepository,
    private val serverApi: ServerApi
) {

    companion object {
        val OBJ_TYPE_GLUCOSE = 0
        val OBJ_TYPE_DEVIATION = 1
        val OBJ_TYPE_MEDICATION = 2
        val TYPE_MEASUREMENT = 0
        val TYPE_FORECAST = 1

    }

    fun syncData(androidId: String): Completable {
        return Maybe.zip(
            getListForUpdate(EntityStatus.NEW),
            getListForUpdate(EntityStatus.UPDATED),
            getListForDelete(),
            Function3 { insert: List<UpdateRequest>, update: List<UpdateRequest>, delete: List<DeleteRequest> ->
                return@Function3 SyncRequest(androidId, insert, update, delete)
            })
            .flatMapCompletable { serverApi.syncAllData(it) }
            .andThen(finishSync())
            .subscribeOn(Schedulers.io())
    }

    private fun getListForUpdate(status: EntityStatus): Maybe<List<UpdateRequest>> {
        val measurements = repository.getMeasurementsByStatus(status).map { measurementList ->
            measurementList.map { measurement ->
                GlucoseLevelRequest(
                    OBJ_TYPE_GLUCOSE,
                    measurement.measurementId,
                    measurement.time,
                    measurement.value,
                    TYPE_MEASUREMENT
                )
            }
        }

        val forecasts = repository.getForecastsByStatus(status)
            .map { forecastList ->
                forecastList.map { forecast ->
                    GlucoseLevelRequest(
                        OBJ_TYPE_GLUCOSE,
                        forecast.forecastId,
                        forecast.time,
                        forecast.value,
                        TYPE_FORECAST
                    )
                }
            }

        val deviations = repository.getDeviationsForRequestByStatus(status, OBJ_TYPE_DEVIATION)

        val medications = repository.getMedicationsForRequest(status, OBJ_TYPE_MEDICATION)

        return Maybe.zip(
            measurements,
            forecasts,
            deviations,
            medications,
            Function4 { m: List<GlucoseLevelRequest>, f: List<GlucoseLevelRequest>, d: List<DeviationRequest>, med: List<MedicationRequest> ->
                return@Function4 m.plus(f).plus(d).plus(med)
            })
    }

    private fun getListForDelete(): Maybe<List<DeleteRequest>> {
        val measurements = repository.getMeasurementsByStatus(EntityStatus.DELETED).map { measurementList ->
            measurementList.map { measurement ->
                DeleteRequest(
                    OBJ_TYPE_GLUCOSE,
                    measurement.measurementId
                )
            }
        }

        val forecasts = repository.getForecastsByStatus(EntityStatus.DELETED)
            .map { forecastList ->
                forecastList.map { forecast ->
                    DeleteRequest(
                        OBJ_TYPE_GLUCOSE,
                        forecast.forecastId
                    )
                }
            }

        val deviations = repository.getDeviationsByStatus(EntityStatus.DELETED)
            .map { deviationList ->
                deviationList.map {
                    DeleteRequest(
                        OBJ_TYPE_DEVIATION,
                        it.deviationId
                    )
                }
            }

        val medications = repository.getMedicationsForRequest(EntityStatus.DELETED, OBJ_TYPE_MEDICATION)
            .map { medicationList ->
                medicationList.map {
                    DeleteRequest(
                        OBJ_TYPE_MEDICATION,
                        it.uuid
                    )
                }
            }

        return Maybe.zip(
            measurements,
            forecasts,
            deviations,
            medications,
            Function4 { m: List<DeleteRequest>, f: List<DeleteRequest>, d: List<DeleteRequest>, med: List<DeleteRequest> ->
                return@Function4 m.plus(f).plus(d).plus(med)
            })
    }

    fun finishSync(): Completable {
        return repository.removeAllDeleted().andThen(repository.updateDeviationStatus())
    }
}