// Usage:
val checker = SqlChecker[IO](transactor)
import checker.checkSql

checkSql(sql"invalid")


// Implementation:

package doobie.util.testing

import cats.effect.Effect
import cats.syntax.foldable._
import cats.instances.list._
import doobie.util.pretty.Block
import doobie.util.query.Query0
import doobie.util.testing.{AnalysisArgs, AnalysisReport, Analyzable, analyzeIO}
import doobie.util.transactor.Transactor
import doobie.util.update.Update0

import scala.reflect.runtime.universe.TypeTag

class SqlChecker[F[_]: Effect](transactor: Transactor[F]) {

  private def formatReport(
      args: AnalysisArgs,
      report: AnalysisReport
  ): Block = {
    val sql = args.cleanedSql
      .wrap(68)
      // SQL should use the default color
      .padLeft(Console.RESET.toString)
    val items = report.items.foldMap(formatItem)
    Block
      .fromString(args.header)
      .above(sql)
      .above(items)
  }

  private val formatItem: AnalysisReport.Item => Block = {
    case AnalysisReport.Item(desc, None) =>
      Block.fromString(s"${Console.GREEN}✓${Console.RESET} $desc")
    case AnalysisReport.Item(desc, Some(err)) =>
      Block
        .fromString(s"${Console.RED}✕${Console.RESET} $desc")
        // No color for error details - ScalaTest paints each line of failure
        // red by default.
        .above(err.wrap(66).padLeft("  "))
  }

  case class SqlAnalysisError(msg: String)
      extends java.lang.AssertionError(msg) {
    override def getStackTrace: Array[StackTraceElement] = Array()
  }

  def checkSql(q: Update0): Unit =
    checkImpl(Analyzable.unpack(q))

  def checkSql[A](q: Query0[A])(implicit A: TypeTag[A]): Unit =
    checkImpl(Analyzable.unpack(q))

  private def checkImpl(args: AnalysisArgs): Unit = {
    val report = analyzeIO(args, transactor).unsafeRunSync()
    if (!report.succeeded) {
      throw SqlAnalysisError(formatReport(args, report).toString)
    }
  }
}

object SqlChecker {
  def apply[F[_]: Effect](transactor: Transactor[F]): SqlChecker[F] =
    new SqlChecker(transactor)
}