import com.saikocat.sbtplugin.ForkTestByAnnotationPlugin._

// Define a task key to find tests to fork
lazy val testsAnnotatedWithRequiresSpark: TaskKey[Seq[String]] =
  taskKey[Seq[String]]("Returns list of FQCNs of tests annotated with RequiresSpark")

testsAnnotatedWithRequiresSpark := {
  val analysis = (compile in Test).value

  // Define a filter function that will match a predicate
  // Full qualified path is required
  // e.g: for a list of tags filtering
  // List("tags.RequiresSpark", "tags.RequiresHive").contains(annotationFullName)
  def filterDefinition(annotationFullName: String): Boolean = {
    annotationFullName == "tags.RequiresSpark"
  }

  // Filter the Tests Definition
  def isAnnotatedWithRequiresSpark(definition: xsbti.api.Definition): Boolean = {
    isAnnotatedWith(definition)(filterDefinition)
  }

  // Trigger the source filtering
  sourcesAnnotatedWith(analysis)(isAnnotatedWithRequiresSpark)
}

// Group the tests to non-forks and forks
// Here you can define the fork options as well
testGrouping in Test <<= (definedTests in Test, testsAnnotatedWithRequiresSpark)
  .map { (testDefs, testsToFork) =>
    groupTestsToInProcessAndForkedJvm(
      testDefs, testsToFork,
      new sbt.ForkOptions(runJVMOptions = Seq(s"-Dgroup.prefix=someProp")))
  }

def isAnnotatedWith(definition: Definition)
                   (annotationFilterFn: String => Boolean): Boolean

def sourcesAnnotatedWith(analysis: Analysis)
                        (annotatedWithFn: Definition => Boolean): Seq[String] 

def groupTestsToInProcessAndForkedJvm(testDefs: Seq[TestDefinition],
                                      testsToFork: Seq[String],
                                      forkOptions: ForkOptions = ForkOptions()): Seq[Group]