import cats.effect.IO

trait AchievementRegistry {

  def registerAchievement(achievement: Achievement): IO[Unit]

  def findAllAchievementsByTeam(teamId: TeamId): IO[List[Achievement]]
}

trait MemeFinder {
  def findRandomMemeByKeyword(keyword: String): IO[Meme]
}

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import cats.implicits._ // for >> operator

val ha = Future(print("h")) >> Future(print("a"))
// ha
ha >> ha

Future(print("h")) >> Future(print("a")) >> Future(print("h")) >> Future(print("a"))
// haha

import cats.effect.IOApp
import cats.implicits._

object App extends IOApp {

  val app = new AppF[IO]

  def run(args: List[String]): IO[ExitCode] =
    app.run.use(_ => IO.never).as(ExitCode.Success)
}

trait AchievementRegistry[F[_]] {

  def registerAchievement(achievement: Achievement): F[Unit]

  def findAllAchievementsByTeam(teamId: TeamId): F[List[Achievement]]
}

trait MemeFinder[F[_]] {
  def findRandomMemeByKeyword(keyword: String): F[Meme]
}

trait CongratulationService[F[_]] {
  def congratulate(achievement: Achievement): F[Congratulation]
}

object CongratulationService {

  def apply[F[_]: ApplicativeError[?[_], Throwable]](
    achievementRegistry: AchievementRegistry[F],
    memeFinder: MemeFinder[F]
  ) =
    new CongratulationService[F] {

      def congratulate(achievement: Achievement): F[Congratulation] = {
        val registrationF: F[Unit] =
          achievementRegistry.registerAchievement(achievement)

        val memeF: F[Option[Meme]] =
          memeFinder
            .findRandomMemeByKeyword("congratulations")
            .attempt.map(_.toOption)

        (registrationF *> memeF).map { maybeMeme =>
          Congratulation(achievement, "Congratulations!", maybeMeme)
        }
      }
    }
}

class ApiRoutes[F[_]: Effect](
                               congratulationService: CongratulationService[F],
                               achievementRegistry: AchievementRegistry[F],
                             ) extends Http4sDsl[F] {
  // ...

  private val registerAchievement = HttpRoutes.of[F] {
    case req @ POST -> Root / "done" =>
      req.decode[Achievement] { achievement =>
        for {
          congrats <- congratulationService.congratulate(achievement)
          slackResp = SlackPresenter.renderCongratulation(congrats)
          resp <- Ok(slackResp)
        } yield resp
      }
  }

  private val listTeamAchievements = HttpRoutes.of[F] {
    case req @ POST -> Root / "done-list" =>
      // ...
  }

  val routes: HttpRoutes[F] =
    registerAchievement <+> listTeamAchievements
}

object PostgresAchievementRegistry extends AchievementRegistry[ConnectionIO] {

  def registerAchievement(achievement: Achievement): ConnectionIO[Unit] =
    Statements
      .registerAchievement(achievement.teamId, achievement.userId, achievement.text)
      .run.void

  def findAllAchievementsByTeam(teamId: TeamId): ConnectionIO[List[Achievement]] =
    Statements.findAchievementsByTeam(teamId).to[List]

  object Statements {

    def registerAchievement(teamId: TeamId, userId: UserId, achievement: String): Update0 =
      sql"""INSERT INTO achievements (team_id, user_id, text)
            VALUES (${teamId}, ${userId}, ${achievement})
      """.update

    def findAchievementsByTeam(teamId: TeamId): Query0[Achievement] =
      sql"""SELECT team_id, user_id, text
            FROM achievements
            WHERE team_id = ${teamId}
            ORDER BY id DESC
      """.query
  }
  
  // ...
}

trait AchievementRegistryLaws[F[_]] {
  def algebra: AchievementRegistry[F]
  implicit def M: Monad[F]

  def registerFindAllComposition(a: Achievement) =
    (
      algebra.registerAchievement(a) >> 
      algebra.findAllAchievementsByTeam(a.teamId).map(_.headOption)
    ) <-> 
      M.pure(Some(a))
}

trait AchievementRegistryTests[F[_]] extends Laws {
  def laws: AchievementRegistryLaws[F]

  def algebra(implicit
              arbAchievement: Arbitrary[Achievement],
              eqFOptAchievement: Eq[F[Option[Achievement]]]) =
    new SimpleRuleSet(
      name = "Achievements",
      "register and findAll compose" -> forAll(laws.registerFindAllComposition _)
    )
}

class InMemoryAchievementRegistryTest
  extends FunSuite
  with Discipline
  with ArbitraryInstances
  with TestInstances {


  implicit val context = TestContext()


  val registry = InMemoryAchievementRegistry.make[IO].unsafeRunSync

  checkAll(
    "InMemoryAchievementRegistry",
    AchievementRegistryTests(registry).algebra
  )
}

class PostgresAchievementRegistryTest
  extends FunSuite
  with Discipline
  with ArbitraryInstances
  with ConnectionIOInstances[IO]
  with TestInstances {

  implicit val context = TestContext()
  implicit val M: Monad[ConnectionIO] = Async[ConnectionIO]

  val transactor = TestTransactor.autoRollback

  checkAll(
    "PostgresAchievementRegistry", 
    AchievementRegistryTests(PostgresAchievementRegistry).algebra
  )
}