import org.specs2._
import org.specs2.specification.core.{ Fragment, Fragments }
import org.specs2.specification.create.{ FormattingFragments => Format }
import org.specs2.specification.dsl.Online._
import cats.implicits._
import cats.effect._
import doobie._
import doobie.util.testing._
import org.specs2.mutable.Specification
import scala.reflect.runtime.universe.TypeTag

trait DoobieChecker[F[_]]{
  def checkQuery[A: TypeTag, B: TypeTag](q: Query[A, B]) : F[Fragments]
  def checkQuery0[A: TypeTag](q: Query0[A]): F[Fragments]
  def checkUpdate[A: TypeTag](q: Update[A]): F[Fragments]
  def checkUpdate0(q: Update0): F[Fragments]
}

object DoobieChecker {
  def apply[F[_]](implicit ev: DoobieChecker[F]): DoobieChecker[F] = ev


    implicit def effectUniqueImpl[F[_]: Effect](
      spec: Specification,
      driverName: String,
      jdbcUrl: String,
      dbUserName: String,
      dbPassword: String,
      setup: F[Unit]
    ): DoobieChecker[F] = new DoobieChecker[F]{
      def checkQuery[A: TypeTag, B: TypeTag](q: Query[A, B]) : F[Fragments] = for {
        _ <- setup
        transactor <- Sync[F].delay(Transactor.fromDriverManager[F](
          driverName,
          jdbcUrl,
          dbUserName,
          dbPassword
        ))
        fragments <- checkImpl(spec, transactor, Analyzable.unpack(q))
      } yield fragments

      override def checkQuery0[A: TypeTag](q: Query0[A]): F[Fragments] = for {
        _ <- setup
        transactor <- Sync[F].delay(Transactor.fromDriverManager[F](
          driverName,
          jdbcUrl,
          dbUserName,
          dbPassword
        ))
        fragments <- checkImpl(spec,transactor, Analyzable.unpack(q))
      } yield fragments

    def checkUpdate[A: TypeTag](q: Update[A]): F[Fragments] = for {
        _ <- setup
        transactor <- Sync[F].delay(Transactor.fromDriverManager[F](
          driverName,
          jdbcUrl,
          dbUserName,
          dbPassword
        ))
        fragments <- checkImpl(spec,transactor, Analyzable.unpack(q))
      } yield fragments
    def checkUpdate0(q: Update0): F[Fragments]= for {
        _ <- setup
        transactor <- Sync[F].delay(Transactor.fromDriverManager[F](
          driverName,
          jdbcUrl,
          dbUserName,
          dbPassword
        ))
        fragments <- checkImpl(spec, transactor, Analyzable.unpack(q))
      } yield fragments

    }



    private def checkImpl[F[_]: Effect](spec: Specification, transactor: Transactor[F], arguments: AnalysisArgs): F[Fragments] = {
      import spec._
      Sync[F].delay(
        // continuesWith is necessary to make sure the query doesn't run too early
        s"${arguments.header}\n\n${arguments.cleanedSql.padLeft("  ")}\n" >> ok.continueWith {
            analyzeIO[F](arguments, transactor).map{report =>
              indentBlock(
                report.items.map { item =>
                  item.description ! item.error.fold(ok) {
                    err => ko(err.wrap(70).toString)
                  }
                }
              )
            }.unsafeRunSync
        }
      )
    }

  private def indentBlock(fs: Seq[Fragment]): Fragments =
      // intersperse fragments with newlines, and indent them.
      // This differs from standard version (FragmentsDsl.fragmentsBlock()) in
      // that any failure gets properly indented, too.
      Fragments.empty
        .append(Format.t)
        .append(fs.flatMap(Seq(Format.br, _)))
        .append(Format.bt)

}