build.sbt

import java.io.File
import routing.Build._
import scala.sys.process._

Global / onChangedBuildSource := ReloadOnSourceChanges

noPublishSettings

// GitHub Actions config
val javaVersions = Seq(11, 17, 21, 25).map(v => JavaSpec.temurin(v.toString))

ThisBuild / githubWorkflowJavaVersions := javaVersions
ThisBuild / githubWorkflowArtifactUpload := false
ThisBuild / githubWorkflowBuildMatrixFailFast := Some(false)
ThisBuild / githubWorkflowTargetBranches := Seq("master")
ThisBuild / githubWorkflowPublishTargetBranches := Seq()

def isJava(v: Int) = s"matrix.java == '${javaVersions.find(_.version == v.toString).get.render}'"

ThisBuild / githubWorkflowBuild := Seq(
  WorkflowStep.Run(List("sbt test"), name = Some("Build project")),
  WorkflowStep.Run(List("sbt mdoc"), name = Some("Build docs"), cond = Some(isJava(25))),
  WorkflowStep.Run(List("sbt mimaReportBinaryIssues"), name = Some("Check binary compatibility"), cond = Some(isJava(25))),
)

lazy val core = simpleProj(projectMatrix.in(file("core")), "core", List(
  Platform.Jvm,
  Platform.Js,
  Platform.Native,
))
  .settings(publishSettings)
  .settings(
    libraryDependencies ++= Seq(
      catsCore.value % Optional,
      izumiReflect.value,
    ),
    Compile / sourceGenerators += Def.task {
      val generators = new File("git rev-parse --show-toplevel".!!.trim) / "generators"
      val srcManaged = (Compile / sourceManaged).value / "generated"

      def gen(scalaF: String, rubyF: String) = {
        println(s"Generating ${srcManaged / scalaF} with ${generators / rubyF}")
        IO.write(srcManaged / scalaF, Seq("ruby", (generators / rubyF).toString).!!)
        srcManaged / scalaF
      }

      Seq(
        gen("RouteMethods.scala", "route_methods.rb"),
        gen("TupledInstances.scala", "tupled_instances.rb"),
      )
    }
  )

lazy val http4s = http4sProj(projectMatrix.in(file("http4s")), "http4s")(axis => _ => _.settings(
  libraryDependencies ++= Seq(
    axis.dep("core").value,
    axis.dep("dsl").value,
  )
))
  .settings(publishSettings)
  .settings(scalacOptions ~= (_.filterNot(_ == "-Wunused:nowarn")))
  .dependsOn(core % "compile->compile;test->test")

lazy val play = playProj(projectMatrix.in(file("play")), "play")(axis => _ => _.settings(
  libraryDependencies ++= Seq(axis.dep("play").value),
))
  .settings(publishSettings)
  .dependsOn(core % "compile->compile;test->test")

lazy val bench = http4sProj(projectMatrix.in(file("bench")), "bench", _ => List(Platform.Jvm))(
  _ => sjsNowarnGlobalECSettings,
)
  .settings(noPublishSettings)
  .dependsOn(core, http4s, play)
  .enablePlugins(JmhPlugin)

lazy val http4sImplFile = "http4s.md"

def http4sImplDoc(dir: File, axis: Http4sAxis.Value): (File, String) =
  (dir / "implementations" / http4sImplFile, s"${http4sImplFile.split(".md").head}-${axis.suffix}.md")

def playDepString(axis: PlayAxis.Value): String =
  s""""bondlink" %% "routing-play_${axis.suffix}" % "$currentVersion""""

lazy val docs = http4sProj(projectMatrix.in(file("routing-docs")), "routing-docs", _ => List(Platform.Jvm))(
  axis => _ => _.settings(
    scalacOptions -= "-Werror",
    mdocVariables ++= {
      val playAxisDeps = PlayAxis.all.map(_.dep("fake")).join.value
      Map(
        "VERSION" -> currentVersion,
        "GITHUB_REPO_URL" -> githubRepoUrl,
        "GITHUB_BLOB_URL" -> s"$githubRepoUrl/blob/master",
        "HTTP4S_SUFFIX" -> axis.suffix,
        "HTTP4S_VERSION_COMMENT" -> axis.comment,
        "PLAY_LATEST_DEPENDENCY" -> playDepString(PlayAxis.v3_0),
        "PLAY_SUPPORTED_VERSIONS" -> PlayAxis.all.zip(playAxisDeps).map { case (a, d) => s"${d.revision} -- `${playDepString(a)}`" }.mkString("\n"),
      )
    },
  ),
).enablePlugins(MdocPlugin)
  .settings(noPublishSettings)
  .dependsOn(core, http4s, play)

lazy val buildDocsSite = taskKey[Unit]("Build GitHub pages documentation site locally")
lazy val publishDocsSite = taskKey[Unit]("Build and publish GitHub pages documentation site")

def runCmd(cmd: ProcessBuilder): Unit = {
  val code = cmd.!
  assert(code == 0, s"command returned $code: $cmd")
}

buildDocsSite := Def.taskDyn {
  val projs = Http4sAxis.all.map(axis => docs.finder(axis, VirtualAxis.jvm)(latestScalaV))
  val target = (ThisBuild / baseDirectory).value / "routing-docs" / "target"
  val out = target / "generated-site"
  Def.taskDyn {
    Def.sequential(projs.map(p => (p / mdoc).toTask(""))).map { _ =>
      IO.delete(out)
      IO.copyDirectory((projs.last / mdocOut).value, out)
      IO.copy(Http4sAxis.all.dropRight(1).map { axis =>
        val (srcFile, targetRelFile) = http4sImplDoc(target / s"${axis.suffix}-jvm-3" / "mdoc", axis)
        println(s"$srcFile -> ${new File(s"$out/implementations/$targetRelFile")}")
        srcFile -> new File(s"$out/implementations/$targetRelFile")
      })
      val website = (ThisBuild / baseDirectory).value / "website"
      runCmd(Process(Seq("npm", "install"), cwd = website) #&& Process(Seq("npm", "run", "build"), cwd = website))
    }
  }
}.value

publishDocsSite := Def.taskDyn {
  val gitUser = sys.env.getOrElse("GIT_USER", sys.error("Please set the `GIT_USER` environment variable to your GitHub username"))
  val useSsh = sys.env.getOrElse("USE_SSH", sys.error("Please set the `USE_SSH` environment variable to `true` or `false` " ++
                                                      "to specify whether connecting to GitHub should use SSH"))
  Def.sequential(
    buildDocsSite,
    Def.task(runCmd(Process(
      Seq("npm", "run", "publish-gh-pages"),
      (ThisBuild / baseDirectory).value / "website",
      "GIT_USER" -> gitUser,
      "USE_SSH" -> useSsh)))
  )
}.value

lazy val example = http4sProj(projectMatrix.in(file("example")), "example", _ => List(Platform.Jvm))(
  axis => sjsNowarnGlobalECSettings.andThen(_.andThen(_.settings(
    libraryDependencies ++= Seq(
      axis.dep("circe").value,
      axis.dep("ember-server").value,
    ),
    dependencyOverrides ++= Seq(
      axis.dep("core").value
    ),
  ))),
)
  .settings(noPublishSettings)
  .settings(
    libraryDependencies ++= Seq(
      circeDep("core").value,
      circeDep("generic").value,
      "org.slf4j" % "slf4j-api" % "2.0.18",
      "org.slf4j" % "slf4j-simple" % "2.0.18"
    )
  )
  .dependsOn(core, http4s, play)

lazy val githubRepoUrl = "https://github.com/mblink/routing"