outwatch-test/src/main/scala/outwatchapp/components/todo/TodoListStore.scala

package nova.monadic_sfx.ui.components.todo

import cats.kernel.Eq
import com.softwaremill.quicklens._
import io.circe.generic.JsonCodec
import monix.bio.Task
import nova.monadic_sfx.util.reactive.store.Reducer
import nova.monadic_sfx.util.reactive.store.Store

case class Todo(id: Int, content: String)
object Todo {
  implicit val eqForTodo = Eq.fromUniversalEquals[Todo]
}

object TodoListStore {

  @JsonCodec
  sealed trait Action
  case object Init extends Action
  case class Add(content: String) extends Action
  case class Edit(id: Int, content: String) extends Action
  case class Delete(id: Int) extends Action

  private case class InternalAdd(content: String) extends Action
  private case object End extends Action
  object Action {
    implicit val eqForAction = Eq.fromUniversalEquals[Action]

  }

  case class State(todos: Vector[Todo], counter: Int)
  object State {
    implicit val eqForState = Eq.fromUniversalEquals[State]
  }

  def reducer()(
      state: State,
      action: Action
  ): (State, Option[Task[Action]]) =
    action match {
      case Init => (state, None)
      case Add(content) =>
        println("hello")
        val nextAction = Some(for {
          // do some validation
          // _ <- logger.debug(s"Received $content")
          _ <- Task(println(s"Received $content"))
          res <- Task.pure(InternalAdd(content))
        } yield res)
        (state, nextAction)
      case Edit(id, content) =>
        val condition: Todo => Boolean = _.id == id
        val nextState = state
          .modify(_.todos.eachWhere(condition))
          .using(_.copy(content = content))
        (nextState, None)
      case Delete(id) =>
        (state.copy(state.todos.filterNot(_.id == id)), None)

      case InternalAdd(content) =>
        val nextState =
          state
            .modify(_.todos)
            .using(_ :+ Todo(state.counter, content))
            .modify(_.counter)
            .using(_ + 1)
        (nextState, Some(Task.pure(End)))
      case End => (state, None)
    }

  def apply(): Task[Store[Action, State]] =
    Task.deferAction(implicit s =>
      for {
        store <-
          Store
            .createL[Action, State](
              Init,
              State(Vector.empty[Todo], 0),
              Reducer.withOptionalEffects(reducer() _)
            )
      } yield store
    )
}