package com.test.arrow.monad.monad_error

import arrow.Kind
import arrow.core.Either
import arrow.core.extensions.either.monadError.monadError
import arrow.core.fix
import arrow.typeclasses.MonadError

object Nuke
object Target
object Impacted

sealed class NukeError {
    object SystemOffline : NukeError()
    object RotationNeedsOil : NukeError()
    data class MissedByMeters(val meters: Int) : NukeError()
}

typealias SystemOffline = NukeError.SystemOffline
typealias RotationNeedsOil = NukeError.RotationNeedsOil
typealias MissedByMeters = NukeError.MissedByMeters

typealias Arm<F> = (MonadError<F, NukeError>) -> Kind<F, Nuke>
typealias Aim<F> = (MonadError<F, NukeError>) -> Kind<F, Target>
typealias Launch<F> = (MonadError<F, NukeError>, Target, Nuke) -> Kind<F, Impacted>

fun <F> attack(ME: MonadError<F, NukeError>, arm: Arm<F>, aim: Aim<F>, launch: Launch<F>): Kind<F, Impacted> =
        ME.fx.monad {
            val (nuke) = arm(ME)
            val (target) = aim(ME)
            val (impact) = launch(ME, target, nuke)
            impact
        }

fun <F> arm(ME: MonadError<F, NukeError>): Kind<F, Nuke> = ME.just(Nuke)
fun <F> aim(ME: MonadError<F, NukeError>): Kind<F, Target> = ME.just(Target)
fun <F> launch(ME: MonadError<F, NukeError>, target: Target, nuke: Nuke) = ME.just(Impacted)

fun <F> armFailed(ME: MonadError<F, NukeError>): Kind<F, Nuke> = ME.raiseError(SystemOffline)
fun <F> aimFailed(ME: MonadError<F, NukeError>): Kind<F, Target> = ME.raiseError(RotationNeedsOil)
fun <F> launchFailed(ME: MonadError<F, NukeError>, target: Target, nuke: Nuke):
        Kind<F, Impacted> = ME.raiseError(MissedByMeters(5))

fun runOnEitherSuccess(): Either<NukeError, Impacted> {
    return attack(Either.monadError(), ::arm, ::aim, ::launch).fix()
}

fun runOnEitherFail1(): Either<NukeError, Impacted> {
    return attack(Either.monadError(), ::armFailed, ::aim, ::launch).fix()
}

fun runOnEitherFail2(): Either<NukeError, Impacted> {
    return attack(Either.monadError(), ::arm, ::aimFailed, ::launch).fix()
}

fun runOnEitherFail3(): Either<NukeError, Impacted> {
    return attack(Either.monadError(), ::arm, ::aim, ::launchFailed).fix()
}

fun main() {
    println(runOnEitherSuccess())
    println(runOnEitherFail1())
    println(runOnEitherFail2())
    println(runOnEitherFail3())
}

/*
fun runOnOption(): Option<Impacted> {
    val me: OptionMonadError = Option.monadError()
    return attack(me, ::arm, ::aim, ::launch).fix()
}

fun runOnIO(): IO<Impacted> {
    val me: IOMonadError = IO.monadError()
    return attack(me, ::arm, ::aim, ::launch).fix()
}
 */