import Dependencies._

def scala211 = "2.11.12"
def scala212 = "2.12.8"
def scala213 = "2.13"

name := "stasis"

inThisBuild(
  Seq(
    organization := "io.stasis",
    homepage := Some(url("https://github.com/stasis/stasis")),
    licenses := List(
      "Apache-2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0"),
      "ASM" -> url("https://asm.ow2.io/license.html")
    ),
    developers := List(
      Developer(
        "gburd",
        "Gregory Burd",
        "greg@burd.me",
        url("https://greg.burd.me")
      )
    ),
    scalaVersion := scala212,
    crossScalaVersions := List(scala213, scala212, scala211),
    resolvers += Resolver.sonatypeRepo("releases"),
    scalacOptions ++= Seq(
      "-unchecked"
      , "-deprecation"
//      , "-Xfatal-warnings"
    ),
    libraryDependencies ++= Seq(
      scalatest.value % Test,
      scalacheck % Test,
      scalametaTestkit % Test,
    ),
    scalacOptions ++= {
      CrossVersion.partialVersion(scalaVersion.value) match {
        case Some((2, 11)) => Seq("-target:jvm-1.8")
        case Some((2, 12)) => Seq("-target:jvm-1.8")
        case Some((2, 13)) => Seq("-target:jvm-1.8")
        case _ => Seq.empty
      }
    },
    Test / testOptions += Tests.Argument(TestFrameworks.JUnit, "-q", "-v", "-a")
  )
)

skip in publish := true

commands += Command.command("ci-test") { s =>
  val scalaVersion = sys.env.get("TEST") match {
    case Some("2.11") => scala211
    case Some("2.12") => scala212
    case Some("2.13") => scala213
    case _ => scala212
  }
  val docsTest = if (scalaVersion == scala213) "docs/run" else "version"
  s"++$scalaVersion" ::
    s"tests/test" ::
    s"coreJS/test" ::
    docsTest ::
    s
}

lazy val core = project
  .in(file("stasis-core"))
  .settings(
    moduleName := "stasis-core",
    description := "Implementation of Stasis",
    buildInfoSettings,
    buildInfoPackage := "io.stasis",
    buildInfoObject := "BuildInfo",
    projectDependencies ++= Seq(
      scalatest.value % Test,
      scalametaTestkit % Test
    )
  )
  .enablePlugins(BuildInfoPlugin)

lazy val persist = project
  .in(file("stasis-persist"))
  .settings(
    moduleName := "stasis-persist",
    assemblyJarName.in(assembly) := "stasis-persist.jar",
  )
  .dependsOn(core, rep)

lazy val rep = project
  .in(file("stasis-rep"))
  .settings(
    moduleName := "stasis-rep",
    assemblyJarName.in(assembly) := "stasis-rep.jar"
  )
  .dependsOn(core)

lazy val test = project
  .in(file("stasis-test"))
  .settings(
    moduleName := "stasis-test",
    assemblyJarName.in(assembly) := "stasis-test.jar",
    Test / fork := true,
    Test / logBuffered := false,
    Test / parallelExecution := false,
    Test / testOptions := Seq(Tests.Argument(TestFrameworks.JUnit,"-a", "-q", "-v")),
    Test / javacOptions := Seq(
      "-Xlint:deprecation",
      "-xlint:unchecked"
    ),
    Test / javaOptions := {
      val basedir = (baseDirectory in ThisBuild).value.getCanonicalFile
      val builddir = basedir + "/target"
      val unittestdir = builddir + "/test"
      val docdir = basedir + "/docs"
      val docletsrcdir = docdir + "/doclet"
      Seq( "-DJE_TEST=true",
        s"-Dbasedir=${basedir}",
        s"-Ddist.srcdir=${basedir}/dist",
        s"-Dunittest.srcdir=${basedir}/test",
        s"-Dunittest.dir=${unittestdir}",
        s"-Dunittest.destdir=${unittestdir}/classes",
        s"-Dunittest.envdirroot=${unittestdir}/envdata",
        s"-Dunittest.failures=${unittestdir}/failures",
        s"-Dunittest.copylimit=10",
        s"-Dunittest.datadir=${unittestdir}/data",
        s"-Dunittest.extraenvdir=${unittestdir}/propTest",
        s"-Dunittest.extraenvdir2=${unittestdir}/propTest2",
        s"-Dunittest.reportsdir=${unittestdir}/reports",
        s"-Dunittest.testclassloader=${unittestdir}/testclassloader",
        s"-Dunittest.testserialdir=${unittestdir}/testserial",
        s"-Dunittest.testevolvedir=${unittestdir}/testevolve",
        s"-Dunittest.serialtest.bdb=${unittestdir}/StoredClassCatalogTest-bdb",
        s"-Dunittest.serialtest.txn=${unittestdir}/StoredClassCatalogTest-txn",
        s"-Dunittest.showoutput=true",
        s"-Ddoc.dir=${docdir}",
        s"-Ddoc.javadir=${docdir}/java",
        s"-Ddoc.internaljavadir=${docdir}/internal-javadoc",
        s"-Ddoc.examplesdir=${docdir}/examples",
        s"-Ddoc.scratchdir=${builddir}/tmp",
        s"-Ddocsrc.dir=${basedir}/docs_src",
        s"-Ddoclet.src.dir=${docletsrcdir}",
        s"-Ddoclet.classes.dir=${docletsrcdir}/Classes",
        s"-Ddoclet.jar=${docdir}/HidingDoclet.jar",
      )
    },
    libraryDependencies ++= Seq(
      "junit" % "junit" % "4.12" % Test,
      "com.novocode" % "junit-interface" % "0.11" % Test
    )
  )
  .disablePlugins(plugins.JUnitXmlReportPlugin)
  .dependsOn(core, persist, rep)

val V = "\\d+\\.\\d+\\.\\d+"
val ReleaseCandidate = s"($V-RC\\d+).*".r
val Milestone = s"($V-M\\d+).*".r

lazy val stableVersion = Def.setting {
  version.in(ThisBuild).value.replaceAll("\\+.*", "")
}

lazy val buildInfoSettings: Seq[Def.Setting[_]] = Seq(
  buildInfoKeys := Seq[BuildInfoKey](
    name,
    version,
    "scalameta" -> scalametaV,
    "nightly" -> version.value,
    "stable" -> stableVersion.value,
    "scala" -> scalaVersion.value,
    "scala211" -> scala211,
    "scala212" -> scala212,
    "scala213" -> scala213,
    "coursier" -> coursier,
    "commit" -> sys.process.Process("git rev-parse HEAD").lineStream_!.head,
    "timestamp" -> System.currentTimeMillis().toString,
    scalaVersion,
    sbtVersion
  ),
  buildInfoPackage := "io.stasis",
  buildInfoObject := "Versions"
)