build.mill

package build

import mill.scalalib.publish.Scope.Test

import $ivy.`com.github.lolgab::mill-crossplatform::0.2.4`
import $ivy.`io.github.quafadas:millSite_mill0.12_2.13:0.0.38`
import $ivy.`de.tototec::de.tobiasroeser.mill.vcs.version::0.4.0`
import $ivy.`com.lihaoyi::mill-contrib-jmh:`
import $ivy.`com.goyeau::mill-scalafix::0.4.2`

import de.tobiasroeser.mill.vcs.version._
import com.github.lolgab.mill.crossplatform._
import mill._, mill.scalalib._, mill.scalajslib._, mill.scalanativelib._
import io.github.quafadas.millSite._
import mill._, scalalib._, publish._
import mill.scalajslib.api._
import mill.scalanativelib._

import mill.util.Jvm
import mill.api.Result
import com.goyeau.mill.scalafix.ScalafixModule

import $packages._

// mill __.compiledClassesAndSemanticDbFiles
// mill --import ivy:com.lihaoyi::mill-contrib-bloop:  mill.contrib.bloop.Bloop/install
object V {
  val spire = "0.18.0"
  val laminar = "17.2.0"
  val scalatags = "0.13.1"
  val scalaVersion = "3.7.0"
  val munitVersion = "1.1.1"
}

trait Common extends ScalaModule  with PublishModule with ScalafixModule {
  def scalaVersion = V.scalaVersion

  def publishVersion = VcsVersion.vcsState().format()

  def ivyDeps = super.ivyDeps() ++ Agg(
    ivy"ai.dragonfly::narr::1.0"
  )

  override def scalacOptions: Target[Seq[String]] = super.scalacOptions() ++ Seq("-explain-cyclic", "-Wunused:imports")

  override def pomSettings = T {
    PomSettings(
      description = "Making cross platform compute intense problems less vexing",
      organization = "io.github.quafadas",
      url = "https://github.com/Quafadas/vecxt",
      licenses = Seq(License.`Apache-2.0`),
      versionControl =
        VersionControl.github("quafadas", "vecxt"),
      developers = Seq(
        Developer("quafadas", "Simon Parten", "https://github.com/quafadas")
      )
    )
  }

}

val vecIncubatorFlag = Seq("""--add-modules=jdk.incubator.vector""")

trait CommonJS extends ScalaJSModule {
  def scalaJSVersion = "1.19.0"
  // def ivyDeps = super.ivyDeps() ++ Seq(ivy"com.raquo::ew::0.2.0")
  // def moduleKind = ModuleKind.
}


trait CommonNative extends ScalaNativeModule {
  def ivyDeps = super.ivyDeps() ++ Agg(
    ivy"org.ekrich::sblas::0.7.0"
  )
  def scalaNativeVersion: mill.T[String] = "0.5.7"
}

trait CommonTests extends TestModule.Munit {
  def ivyDeps = super.ivyDeps() ++ Agg(
    ivy"org.scalameta::munit::${V.munitVersion}",
  )
}


object vecxt extends CrossPlatform {
  trait Shared extends CrossPlatformScalaModule with Common {
    // common `core` settings here
    trait SharedTests extends CommonTests {
      // common `core` test settings here
    }
  }
  object jvm extends Shared {
    override def javacOptions: T[Seq[String]] = super.javacOptions() ++ vecIncubatorFlag
    def forkArgs = super.forkArgs() ++ vecIncubatorFlag
    def ivyDeps = super.ivyDeps() ++ Agg(
      ivy"dev.ludovic.netlib:blas:3.0.3"
    )

    object test extends ScalaTests with SharedTests {
      def forkArgs = super.forkArgs() ++ vecIncubatorFlag
    }
  }
  object js extends Shared with CommonJS {
    // js specific settings here
    object test extends ScalaJSTests with SharedTests {
        def moduleKind = ModuleKind.CommonJSModule
    }
  }

  object native extends Shared with CommonNative {
    // native specific settings here
    object test extends ScalaNativeTests with SharedTests
  }
}

object vecxtensions extends CrossPlatform {
  override def moduleDeps: Seq[CrossPlatform] = Seq(vecxt)
  trait Shared extends CrossPlatformScalaModule with Common {

    // common `core` settings here
    trait SharedTests extends CommonTests {
      // common `core` test settings here
    }
  }
  object jvm extends Shared {
    override def javacOptions: T[Seq[String]] = super.javacOptions() ++ vecIncubatorFlag
    def forkArgs = super.forkArgs() ++ vecIncubatorFlag
    def ivyDeps = Agg(
      ivy"org.typelevel::spire::${V.spire}"
    )


    object test extends ScalaTests with SharedTests {
      def forkArgs = super.forkArgs() ++ vecIncubatorFlag
    }
  }
  object js extends Shared with CommonJS {
    override def ivyDeps: Target[Agg[Dep]] = super.ivyDeps() ++ Agg(
      ivy"com.lihaoyi::scalatags::${V.scalatags}",
      ivy"com.raquo::laminar::${V.laminar}",
      ivy"org.typelevel::spire::${V.spire}"
    )
    // js specific settings here
    object test extends ScalaJSTests with SharedTests {
      def moduleKind = ModuleKind.CommonJSModule
    }
  }

  object native extends Shared with CommonNative {
    // native specific settings here
    object test extends ScalaNativeTests with SharedTests
  }
}



object jsSite extends SiteJSModule {

  override def moduleDeps = Seq(vecxt.js, vecxtensions.js)
  override def scalaVersion = vecxt.js.scalaVersion
  override def scalaJSVersion = vecxt.js.scalaJSVersion

  // override def scalaJsCompilerVersion: String = "3.6.2"


  // override def allScalacOptions: T[Seq[String]] = super.allScalacOptions`() ++ Seq("-experimental", "-language:experimental.namedTuples")
  override def scalacOptions: T[Seq[String]] = super.scalacOptions()
  override def moduleKind = ModuleKind.ESModule
  override def ivyDeps = super.ivyDeps() ++ Agg(
    ivy"org.scala-js::scalajs-dom::2.8.0",
    ivy"com.lihaoyi::scalatags::${V.scalatags}",
    ivy"com.raquo::laminar::${V.laminar}",
    ivy"com.lihaoyi::upickle::4.0.2"
  )

  object test extends ScalaJSTests with CommonTests {
    def moduleKind = ModuleKind.CommonJSModule
  }
}

// object integration extends ScalaModule with CommonTests {
//   def scalaVersion: T[String] = vecxt.jvm.scalaVersion

// }

// note that scastic won't work, as I don't think we can start a JVM with the incubator flag.
object site extends SiteModule {

  override val jsSiteModule = jsSite
  override def pathToImportMap = Some(PathRef(T.workspace / "importmap.json"))
  override def forkArgs: T[Seq[String]] = super.forkArgs() ++ vecIncubatorFlag
  def scalaVersion = vecxt.jvm.scalaVersion
  override def moduleDeps = Seq(vecxt.jvm)

  override def scalacOptions: T[Seq[String]] = super.scalacOptions()

}