saker.build

global(VERSION_saker.msvc) = "0.8.8"
global(DEPENDENCIES_saker.msvc) = [
	saker.standard, 
	saker.compiler.utils,
	saker.sdk.support,
	saker.process-api,
	saker.windows-api,
]

static(VERSION_saker.build) = nest.dependency.resolve(
	saker.build,
	Filters: nest.dependency.filter.kind([]),
)[Bundles][0][BundleIdentifier][VersionNumber]
static(VERSION_saker.nest) = nest.dependency.resolve(
	saker.nest,
	Filters: nest.dependency.filter.kind([]),
)[Bundles][0][BundleIdentifier][VersionNumber]

compile(
	in testapicompile = include(_testapicompile),
	out javac,
) {
	$resolveddependencies = nest.dependency.resolve(
		global(DEPENDENCIES_saker.msvc),
		Filters: nest.dependency.filter.compile(CompileTransitive: false)
	)
	$javac = saker.java.compile(
		SourceDirectories: [
			src/main/
		],
		ClassPath: [
			saker.java.classpath.bundle([
				"saker.nest-api-v{ static(VERSION_saker.nest) }"
			]),
			saker.java.classpath.bundle($resolveddependencies),
			$testapicompile[javac],
		],
		Identifier: "saker.msvc{ $testapicompile[enabled] ? "-testing" : "" }",	
	)
}
export(
	in compile = include(compile),
	out compile,
	out mainjar,
	out apijar,
	out impljar,
	out sourcejar,
	
	out bundlepaths = [
		$mainjar[Path],
		$apijar[Path],
		$impljar[Path],
		$sourcejar[Path],
	]
) {
	$mainjar = saker.jar.create(
		Output: saker.msvc.jar,
		Resources: [
			{
				Directory: $compile[javac][ClassDirectory],
				Resources: saker/msvc/main/**,
			},
			{
				Directory: main/resources/,
				Resources: **,
			},
		],
		Manifest: {
			MainAttributes: {
				Nest-Bundle-Format-Version: 1,
				Nest-Bundle-Identifier: "saker.msvc-v{ global(VERSION_saker.msvc) }",
				Nest-Bundle-Source: "saker.msvc-sources-v{ global(VERSION_saker.msvc) }",
				Nest-ClassPath-Supported-Build-System-Versions: "[0.8.9)",
			},
		},
	)
	$apijar = saker.jar.create(
		Output: saker.msvc-api.jar,
		Resources: [
			{
				Directory: $compile[javac][ClassDirectory],
				Resources: saker/msvc/api/**,
			},
			{
				Directory: api/resources/,
				Resources: **,
			},
		],
		Manifest: {
			MainAttributes: {
				Nest-Bundle-Format-Version: 1,
				Nest-Bundle-Identifier: "saker.msvc-api-v{ global(VERSION_saker.msvc) }",
				Nest-Bundle-Source: "saker.msvc-sources-v{ global(VERSION_saker.msvc) }",
				Nest-ClassPath-Supported-Build-System-Versions: "[0.8.9)",
			},
		},
	)
	$impljar = saker.jar.create(
		Output: saker.msvc-impl.jar,
		Resources: [
			{
				Directory: $compile[javac][ClassDirectory],
				Resources: saker/msvc/impl/**,
			},
			{
				Directory: impl/resources/,
				Resources: **,
			},
			{
				Files: LICENSE,
				TargetDirectory: META-INF,
			},
		],
		Manifest: {
			MainAttributes: {
				Nest-Bundle-Format-Version: 1,
				Nest-Bundle-Identifier: "saker.msvc-impl-v{ global(VERSION_saker.msvc) }",
				Nest-Bundle-Source: "saker.msvc-sources-v{ global(VERSION_saker.msvc) }",
				Nest-ClassPath-Supported-Build-System-Versions: "[0.8.9)",
			},
		},
	)
	$sourcejar = saker.jar.create(
		Output: saker.msvc-sources.jar,
		Resources: [
			{
				Directory: [src/main/],
				Resources: [**/*.java],
			},
			{
				Files: LICENSE,
				TargetDirectory: META-INF,
			},
		],
		Manifest: {
			MainAttributes: {
				Nest-Bundle-Format-Version: 1,
				Nest-Bundle-Identifier: "saker.msvc-sources-v{ global(VERSION_saker.msvc) }",
			},
		},
	)
}
install() {
	$export = include(export)
	nest.local.install($export[bundlepaths])
}
upload(){
	$export = include(export, Path: saker.build)
	include(Path: secret/secrets.build)
	nest.server.upload(
		Bundles: $export[bundlepaths],
		APIKey: global(saker.msvc.UPLOAD_API_KEY),
		APISecret: global(saker.msvc.UPLOAD_API_SECRET),
		Overwrite: true,
	)
}
test(
){
	$testapi = include(_testapicompile, enabled: true)
	$export = include(export, compile: include(compile, testapicompile: $testapi))
	
	$testcompile = saker.java.compile(
		SourceDirectories: [
			test/src/,
		],
		ClassPath: [
			$testapi[javac],
			saker.java.classpath.bundle([
				"saker.build-test-runner-v{ static(VERSION_saker.build) }",
				"saker.build-test-utils-v{ static(VERSION_saker.build) }",
				"saker.nest-test-utils-v{ static(VERSION_saker.nest )}"
			]),
		],
		Identifier: saker.msvc-tests,
	)
	
	$resolveddependencies = nest.dependency.resolve(
		global(DEPENDENCIES_saker.msvc),
		Filters: nest.dependency.filter.kind(classpath)
	)
	
	$test = saker.java.test(
		TestRunnerClassPath: [
			saker.java.classpath.bundle("saker.build-test-runner-v{ static(VERSION_saker.build) }"),
		],
		ClassPath: [
			$testapi[javac], 
		],
		DependencyClassPath: [
			$export[compile][javac],
		],
		TestInvokerClass: testing.saker.SakerJavaTestingInvoker,
		TestClassPath:	[
			$testcompile[ClassDirectory],
			saker.java.classpath.bundle([
				"saker.build-test-utils-v{ static(VERSION_saker.build) }",
				"saker.nest-test-utils-v{ static(VERSION_saker.nest )}",
			]),
		],
		TestClasses: [
			testing.saker.msvc.**.*Test
		],
		NonDeterministicTests: [
			**,
		],
		TestClassParameters: {
			**: {
				RepositoryJarPath: nest.bundle.localize("saker.nest-test-v{ static(VERSION_saker.nest) }")[BundleLocalPaths][0],
				RepositoryParameterBundles: "{ 
						foreach $path in $export[bundlepaths]: "{ std.file.mirror($path) };" 
					};{
						foreach $path in nest.bundle.localize($resolveddependencies)[BundleLocalPaths]: ";{ $path }"
					}",
			}
		},
		TestInvokerParameters: {
			SakerJarPath: std.file.mirror($testapi[instrumentedjar]),
			TimeoutMillis: 120000,
			TestsBaseBuildDirectory: std.file.mirror.path(std.file.place(test/build)),
		},
		IgnoreFileChanges: [
			std.file.place(test/build),
		],
		#ProcessJVMParameters: [ "-agentlib:jdwp=transport=dt_socket,address=localhost:5432,server=y,suspend=y,quiet=y" ],
		MaxJVMCount: 1,
		FailFast: true,
		AbortOnFail: true,
		Verbose: true,
	)
}

_testapicompile(
	in enabled = false,
	out enabled,
	out javac,
	out instrumentedjar,
){
	if $enabled {
		$instrumentedjar = nest.test.instrument(
			nest.bundle.download("saker.build-test-v{ static(VERSION_saker.build) }")[BundlePaths][0],
			NestVersion: static(VERSION_saker.nest),
		)
		$sakerbuildcp = $instrumentedjar
	} else {
		$instrumentedjar = null
		$sakerbuildcp = saker.java.classpath.bundle("saker.build-api-v{ static(VERSION_saker.build) }")
	}
	$javac = saker.java.compile(
		SourceDirectories: [
			testapi/common/,
			$enabled ? testapi/enabled/ : testapi/disabled/,
		],
		ClassPath: [
			$sakerbuildcp,
		],
		Identifier: "testapi-{ $enabled ? enabled : disabled }",
	)
}