package esoft.com.moblin

import android.os.Bundle
import android.os.Parcel
import android.os.Parcelable
import androidx.appcompat.app.AppCompatActivity
import com.jakewharton.rxbinding3.view.clicks
import com.spotify.mobius.First
import com.spotify.mobius.MobiusLoop
import com.spotify.mobius.Next
import com.spotify.mobius.Next.next
import com.spotify.mobius.android.AndroidLogger
import com.spotify.mobius.android.MobiusAndroid
import com.spotify.mobius.rx2.RxConnectables
import com.spotify.mobius.rx2.RxMobius
import io.reactivex.Observable
import kotlinx.android.synthetic.main.activity_main.*

sealed class Event {
    object IncreaseClicked : Event()
    object DecreaseClicked : Event()
}

sealed class Effect {
    object ErrorCalclating : Effect()
}

data class StateModel(
    val counter: Int = 0
) : Parcelable {
    constructor(parcel: Parcel) : this(parcel.readInt())

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeInt(counter)
    }

    override fun describeContents(): Int {
        return 0
    }

    companion object CREATOR : Parcelable.Creator<StateModel> {
        override fun createFromParcel(parcel: Parcel): StateModel {
            return StateModel(parcel)
        }

        override fun newArray(size: Int): Array<StateModel?> {
            return arrayOfNulls(size)
        }
    }
}

abstract class Updater<MOD, EVT, EFT> : ((MOD, EVT) -> Next<MOD, EFT>)

inline fun <reified MOD, EVT, EFT> createController(
    defaultModel: MOD?,
    updater: Updater<MOD, EVT, EFT>
): MobiusLoop.Controller<MOD, EVT> {
    val loop = RxMobius.loop<MOD, EVT, EFT>(updater, { Observable.empty() })
        .init { initial ->
            defaultModel?.let { First.first<MOD, EFT>(it) } ?: First.first<MOD, EFT>(initial)
        }

    return MobiusAndroid.controller<MOD, EVT, EFT>(loop, MOD::class.java.newInstance())
}

class MainActivity : AppCompatActivity() {

    private val mobiusLoop = RxMobius.loop<StateModel, Event, Effect>(UpdaterImpl) { effect ->
        Observable.empty()
    }.logger(AndroidLogger.tag("MoBlin")).init {
        First.first(it)
    }

    private object UpdaterImpl : Updater<StateModel, Event, Effect>() {
        override fun invoke(model: StateModel, event: Event): Next<StateModel, Effect> = when (event) {
            Event.DecreaseClicked -> next(model.copy(counter = model.counter - 1))
            Event.IncreaseClicked -> next(model.copy(counter = model.counter + 1))
        }
    }

    private val controller = createController(
        null,
        UpdaterImpl
    )

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        controller.connect(RxConnectables.fromTransformer { models ->
            val modelsDisposable = models.subscribe {
                counter.text = it.counter.toString()
            }
            Observable.merge(
                increase.clicks().map { Event.IncreaseClicked },
                decrease.clicks().map { Event.DecreaseClicked }
            ).doOnDispose(modelsDisposable::dispose)
        })

        savedInstanceState?.get("COUNT")?.let {
            controller.replaceModel(it as StateModel)
        }
    }

    override fun onSaveInstanceState(outState: Bundle?) {
        super.onSaveInstanceState(outState?.apply {
            putParcelable("COUNT", controller.model)
        })
    }

    public override fun onResume() {
        super.onResume()
        controller.start()
    }

    public override fun onPause() {
        super.onPause()
        controller.stop()
    }
}