import ch.srf.assetimporter.importer.Domain.Error
import ch.srf.assetimporter.importer.tms.Interpreters.tmsThrowableToImporterError
import ch.srg.tmsclient.EffDomain._envReader
import ch.srg.tmsclient.TmsEffect.{TmsAlgebra, TmsErrorEither}
import org.atnos.eff.addon.scalaz.concurrent.TaskEffect
import org.atnos.eff.addon.scalaz.concurrent.TaskEffect._Task
import org.atnos.eff.{Eff, Fx, Member}

import scalaz.\/

/*
* Beispiel für Eff Komplexität:
* ich will statt einem Ergebnis Eff[R,A] lieber ein
* Ergebnis Eff[R, Error \/ A], wie gerade im Assetimporter mit runTms
* implementiert:
* statt runTms implemtiere ich runTmsErrorHandled:
* */
private def runTmsErrorHandled[R, A, U](p: Eff[R, A])(implicit m: Member.Aux[TmsAlgebra, R, U],
                                                      task: _Task[U],
                                                      env: _envReader[U]): Eff[U, Error \/ A] = {
  import ch.srg.tmsclient.TmsEffect.TmsEffectInterpreterSyntax
  import org.atnos.eff.syntax.addon.scalaz.eff._
  import org.atnos.eff.syntax.addon.scalaz.either._
  import org.atnos.eff.syntax.addon.scalaz.task._
  type S = Fx.prepend[TmsErrorEither, R]
  p
    .into[S]
    .runTms
    .taskAttempt
    .map(e => \/.fromEither(e).leftMap(tmsThrowableToImporterError))
    .runDisjunction
    .flatMap(_.fold(
      tmsError => TaskEffect.taskFailed[U, Error \/ A](new Exception(tmsError.toString)),
      _.pureEff
    ))
}

/* Und das ist schon ein heftiger Aufwand für eine simple Transformation, oder*/