build.gradle

plugins {
	id 'java' 
	id 'application'
	id "org.sonarqube"
	id "de.undercouch.download" version "5.6.0"
	id "com.netflix.nebula.ospackage" version "11.8.1"
	id "io.freefair.lombok" version "8.6"
	id 'org.openjfx.javafxplugin' version '0.1.0'
	id "org.beryx.jlink" version "3.0.1" apply false
	id 'jacoco'
}

sonar {
	properties {
		property "sonar.projectKey", "optyfr_JRomManager"
		property "sonar.organization", "optyfr"
		property "sonar.host.url", "https://sonarcloud.io"
		property "sonar.sourceEncoding", "utf-8"
		property "sonar.log.level", "INFO"
		property "sonar.verbose", "true"
		property "sonar.scm.provider", "git"
		property "sonar.coverage.jacoco.xmlReportPaths", "${rootDir}/build/reports/jacoco/codeCoverageReport/codeCoverageReport.xml"
	}
}

tasks.register("codeCoverageReport", JacocoReport) {
    // If a subproject applies the 'jacoco' plugin, add the result it to the report
    subprojects { subproject ->
        subproject.plugins.withType(JacocoPlugin).configureEach {
            subproject.tasks.matching({ t -> t.extensions.findByType(JacocoTaskExtension) }).configureEach { testTask ->
                sourceSets subproject.sourceSets.main
                executionData(testTask)
            }
/*
            // To automatically run `test` every time `./gradlew codeCoverageReport` is called,
            // you may want to set up a task dependency between them as shown below.
            // Note that this requires the `test` tasks to be resolved eagerly (see `forEach`) which
            // may have a negative effect on the configuration time of your build.
            subproject.tasks.matching({ t -> t.extensions.findByType(JacocoTaskExtension) }).forEach {
                rootProject.tasks.codeCoverageReport.dependsOn(it)
            }*/
        }
    }

    // enable the different report types (html, xml, csv)
    reports {
        // xml is usually used to integrate code coverage with
        // other tools like SonarQube, Coveralls or Codecov
        xml.required = true

        // HTML reports can be used to see code coverage
        // without any external tools
        html.required = true
    }
}

codeCoverageReport.dependsOn {
    subprojects*.test
}


apply plugin: 'java'

java {
    sourceCompatibility = JavaVersion.VERSION_21
    targetCompatibility = JavaVersion.VERSION_21
}

apply plugin: 'eclipse'
eclipse {
	classpath {
		downloadJavadoc = true
		downloadSources = true
	}
}


lombok {
	version = '1.18.32'
}

ext.props = new Properties()
file("dist/ver.properties").withInputStream { props.load(it) }

version = props.getProperty("Specification-Version")+'.'+props.getProperty("Implementation-Version")

repositories {
	mavenCentral()
	maven {
		url = uri("https://maven.pkg.github.com/optyfr/Jtrrntzip")
		credentials {
			username = "public"
			password = "\u0067hp_6DEjEzjpKxxDeQ5s39Wfm3wOMRTrxH2L20xf"
		}
	}
	maven { url "https://jitpack.io" }
}

configurations.all {
	resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}

boolean isConGradle(entry) {
	entry.kind == 'con' && entry.path == 'org.eclipse.buildship.core.gradleclasspathcontainer'
}
/*
task WebClientJar (type: Jar, dependsOn: [':WebClient:build']) {
	archiveBaseName = 'jrm-webui'
	from (new File(project(':WebClient').buildDir,"/gwt/release")) {
		into('webclient')
	}
	from (new File(project(':WebClient').projectDir,"/war/index.html")) {
		into('webclient')
	}
	from ('certs') {
		into('certs')
	}
	outputs.file new File(project(':WebClient').buildDir,'/libs/jrm-WebClient-'+version+'.jar') 
}
*/
import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

subprojects {
	apply plugin: 'java'
	java {
	    sourceCompatibility = JavaVersion.VERSION_21
	    targetCompatibility = JavaVersion.VERSION_21
	}

	version = props.getProperty("Specification-Version")+'.'+props.getProperty("Implementation-Version")
	repositories {
		mavenCentral()
		maven {
			url = uri("https://maven.pkg.github.com/optyfr/Jtrrntzip")
			credentials {
				username = "public"
				password = "\u0067hp_6DEjEzjpKxxDeQ5s39Wfm3wOMRTrxH2L20xf"
			}
		}
		maven { url "https://jitpack.io" }
	}

	test {
		useJUnitPlatform {
			includeEngines 'junit-jupiter'
		}
		jacocoTestReport {
			reports {
				xml.required = true
			}
		}
		finalizedBy jacocoTestReport
	}
	
	sonar {
		properties {
			property "sonar.projectKey", "optyfr_JRomManager"
			property "sonar.organization", "optyfr"
			property "sonar.host.url", "https://sonarcloud.io"
			property "sonar.sourceEncoding", "utf-8"
			property "sonar.log.level", "INFO"
			property "sonar.verbose", "true"
			property "sonar.scm.provider", "github"
			property "sonar.coverage.exclusions", "**/src-jfx/**/*"
			property "sonar.coverage.jacoco.xmlReportPaths", "${rootDir}/build/reports/jacoco/codeCoverageReport/codeCoverageReport.xml"
		}
	}

	jar {
		manifest {
			attributes(
				"Manifest-Version"     : "1.0",
				"Specification-Title"  : "JRomManager",
				"Specification-Version": props.getProperty("Specification-Version"),
				"Implementation-Title" : "jrm",
				"Implementation-Version" : props.getProperty("Implementation-Version")
			)
		}
		archiveFileName = 'jrm-' + project.name + '-' + project.version + '.jar'
	}
}

project(':WebClient') {
	sonar {
		skipProject = true
	}
}

project(':jrmcore') {
	apply plugin: "io.freefair.lombok"

	apply plugin: "eclipse"

	dependencies {
		implementation group: 'com.github.optyfr', name:'sevenzipjbindingallinone', version:'1.1'
		implementation group: 'com.github.optyfr', name:'jtrrntzip', version:'1.3.1'
		implementation group: 'commons-codec', name:'commons-codec', version:'1.+'
		implementation group: 'commons-io', name: 'commons-io', version:'2.+'
		implementation group: 'org.apache.commons', name: 'commons-text', version:'1.+'
		implementation group: 'org.apache.commons', name: 'commons-compress', version:'1.+'
	//	implementation group: 'net.sf.sevenzipjbinding', name: 'sevenzipjbinding'
		implementation group: 'one.util', name: 'streamex', version: '0.8.+'
		implementation group: 'com.sun.activation', name: 'javax.activation', version: '1.2.+'
		implementation group: 'com.eclipsesource.minimal-json', name: 'minimal-json', version: '0.9.5'
		implementation group: 'net.lingala.zip4j', name: 'zip4j', version: 'latest.release'
	
		testImplementation group: 'org.junit.jupiter', name:'junit-jupiter-api', version: 'latest.release'
		testImplementation group: 'org.junit.jupiter', name:'junit-jupiter-engine', version: 'latest.release'
	}
	jar {
		manifest {
			attributes(
				"Specification-Title"  : "JRomManager Core",
				"Implementation-Title" : "jrmcore",
			)
		}
	}
	javadoc {
		exclude '**/LICENSE'
		source = sourceSets.main.allJava
	}
	apply plugin:'jacoco'
}

project(':jrmcli') {
	apply plugin: "io.freefair.lombok"
	
	apply plugin: "eclipse"

	sourceSets {
		main {
			java {
				srcDirs = ["src/main/java"]
			}
		}
		main {
			resources {
				srcDirs = ["src/main/java"]
			}
		}
	}
	dependencies {
		implementation project(':jrmcore')
		implementation group: 'com.beust', name: 'jcommander', version:'1.+'
		implementation group: 'commons-io', name: 'commons-io', version:'2.+'
		implementation group: 'org.apache.commons', name: 'commons-lang3', version:'3.+'
		implementation group: 'com.eclipsesource.minimal-json', name: 'minimal-json', version: '0.9.5'
	
		testImplementation group: 'org.junit.jupiter', name:'junit-jupiter-api', version: 'latest.release'
		testImplementation group: 'org.junit.jupiter', name:'junit-jupiter-engine', version: 'latest.release'
	}
	apply plugin: 'application'
	application.mainClass='jrm.cli.JRomManagerCLI'
	jar {
		manifest {
			attributes(
				"Specification-Title"  : "JRomManager CLI",
				"Implementation-Title" : "jrmcli",
			)
		}
	}
	javadoc {
		exclude '**/*.properties'
		source = sourceSets.main.allJava
	}
	apply plugin:'jacoco'
	
}

project(':res-icons') {
	sourceSets {
		main {
			java {
				srcDirs = ["src/main/java"]
			}
		}
		main {
			resources {
				srcDirs = ["src/main/java"]
			}
		}
	}
	dependencies {
	}
	jar {
		manifest {
			attributes(
				"Specification-Title"  : "JRomManager Resources",
				"Implementation-Title" : "res-icons",
			)
		}
	}
	javadoc {
		enabled = false
	}
	sonar {
		skipProject = true
	}
}

project(':jrmstandalone') {
	apply plugin: "io.freefair.lombok"

	apply plugin: "eclipse"

	dependencies {
		implementation project(':jrmcore')
		implementation project(':res-icons')
		implementation group: 'commons-codec', name:'commons-codec', version:'1.+'
		implementation group: 'com.beust', name: 'jcommander', version:'1.+'
		implementation group: 'commons-io', name: 'commons-io', version:'2.+'
		implementation group: 'org.apache.commons', name: 'commons-lang3', version:'3.+'
		implementation group: 'one.util', name: 'streamex', version: '0.8.+'
		implementation group: 'com.eclipsesource.minimal-json', name: 'minimal-json', version: '0.9.5'
		implementation group: 'com.sun.activation', name: 'javax.activation', version: '1.2.+'
	
		testImplementation group: 'org.junit.jupiter', name:'junit-jupiter-api', version: 'latest.release'
		testImplementation group: 'org.junit.jupiter', name:'junit-jupiter-engine', version: 'latest.release'
	}
	apply plugin: 'application'
	application.mainClass='jrm.JRomManager'
	jar {
		manifest {
			attributes(
				"Manifest-Version"     : "1.0",
				"Specification-Title"  : "JRomManager Standalone",
			)
		}
	}
	apply plugin:'jacoco'
}

project(':jrmfx') {
	apply plugin: "io.freefair.lombok"

	apply plugin: "org.openjfx.javafxplugin"
	
	javafx {
		version = '22'
		modules = [ 'javafx.controls', 'javafx.fxml', 'javafx.web' ]
	}

	apply plugin: "eclipse"

	eclipse {
		classpath {
			downloadSources = true
			downloadJavadoc = true
		}
	}

	sourceSets {
		main {
			java {
				srcDirs = ["src/main/java"]
			}
		}
		main {
			resources {
				srcDirs = ["src/main/java"]
			}
		}
	}

	dependencies {
		implementation project(':jrmcore')
		implementation project(':res-icons')
		implementation group: 'com.beust', name: 'jcommander', version:'1.+'
		implementation group: 'commons-io', name: 'commons-io', version:'2.+'
		implementation group: 'org.apache.commons', name: 'commons-text', version:'1.+'
		implementation group: 'org.apache.commons', name: 'commons-lang3', version:'3.+'
		implementation group: 'com.google.code.gson', name: 'gson', version: 'latest.release'
		implementation group: 'com.eclipsesource.minimal-json', name: 'minimal-json', version: '0.9.5'
	}
	apply plugin: 'application'
	application.mainClass='jrm.fx.JRomManager'
	jar {
		manifest {
			attributes(
				"Manifest-Version"     : "1.0",
				"Specification-Title"  : "JRomManager JFX",
				"Specification-Version": props.getProperty("Specification-Version"),
				"Implementation-Title"  : "jrm",
				"Implementation-Version" : props.getProperty("Implementation-Version"),
			)
		}
	}
	javadoc {
		exclude '**/*.fxml'
		source = sourceSets.main.allJava
	}
	apply plugin:'jacoco'
}

project(':jrmserver') {
	apply plugin: "io.freefair.lombok"

	apply plugin: "eclipse"

	dependencies {
		implementation project(':jrmcore')
		implementation project(':res-icons')
		implementation group: 'com.beust', name: 'jcommander', version:'1.+'
		implementation group: 'commons-io', name: 'commons-io', version:'2.+'
		implementation group: 'commons-daemon', name:'commons-daemon', version: 'latest.release'
		implementation group: 'org.apache.commons', name: 'commons-lang3', version:'3.+'
		implementation group: 'org.eclipse.jetty', name:'jetty-server', version:'12.+'
		implementation group: 'org.eclipse.jetty.ee9', name: 'jetty-ee9-servlet', version: '12.+'
		implementation group: 'org.eclipse.jetty', name:'jetty-security', version:'12.+'
		implementation group: 'org.eclipse.jetty', name:'jetty-session', version:'12.+'
		implementation group: 'org.eclipse.jetty', name:'jetty-alpn-server', version:'12.+'
		implementation group: 'org.eclipse.jetty', name:'jetty-alpn-conscrypt-server', version:'12.+'
		implementation group: 'org.eclipse.jetty.http2', name:'jetty-http2-server', version:'12.+'
		implementation group: 'com.eclipsesource.minimal-json', name: 'minimal-json', version: '0.9.5'
		implementation group: 'com.google.code.gson', name: 'gson', version: 'latest.release'
		implementation group: 'one.util', name: 'streamex', version: '0.8.+'
		implementation group: 'commons-dbutils', name:'commons-dbutils', version: 'latest.release'
		implementation group: 'com.h2database', name:'h2', version: '2.2.+'
		implementation group: 'org.mindrot', name:'jbcrypt', version:'0.4'
		implementation group: 'net.java.dev.jna', name:'jna', version: 'latest.release'
		implementation group: 'de.mkammerer', name:'argon2-jvm', version: 'latest.release'
		implementation group: 'ch.qos.logback', name:'logback-core', version: 'latest.release'
		implementation group: 'ch.qos.logback', name:'logback-classic', version: 'latest.release'
		implementation files(project(':WebClient').jar)

		testImplementation group: 'org.eclipse.jetty', name: 'jetty-client', version:'12.+'
		testImplementation group: 'org.eclipse.jetty', name: 'jetty-http', version:'12.+'
		testImplementation group: 'org.awaitility', name: 'awaitility', version: '4.+'
    		testImplementation("org.junit.jupiter:junit-jupiter:latest.release")
    		testRuntimeOnly("org.junit.platform:junit-platform-launcher:latest.release")
//		testImplementation group: 'org.junit.jupiter', name:'junit-jupiter-api', version: 'latest.release'
//		testImplementation group: 'org.junit.jupiter', name:'junit-jupiter-engine', version: 'latest.release'
	}
	
	apply plugin: 'jacoco'
	test {
		useJUnitPlatform {
			includeEngines 'junit-jupiter'
		}
		jacocoTestReport {
			reports {
				xml.required = true
			}
		}
		finalizedBy jacocoTestReport
	    testLogging {
	        // set options for log level LIFECYCLE
	        events TestLogEvent.FAILED,
	               TestLogEvent.PASSED,
	               TestLogEvent.SKIPPED,
	               TestLogEvent.STANDARD_OUT
	        exceptionFormat TestExceptionFormat.FULL
	        showExceptions true
	        showCauses true
	        showStackTraces true
	
	        // set options for log level DEBUG and INFO
	        debug {
	            events TestLogEvent.STARTED,
	                   TestLogEvent.FAILED,
	                   TestLogEvent.PASSED,
	                   TestLogEvent.SKIPPED,
	                   TestLogEvent.STANDARD_ERROR,
	                   TestLogEvent.STANDARD_OUT
	            exceptionFormat TestExceptionFormat.FULL
	        }
	        info.events = debug.events
	        info.exceptionFormat = debug.exceptionFormat
	
	        afterSuite { desc, result ->
	            if (!desc.parent) { // will match the outermost suite
	                def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
	                def startItem = '|  ', endItem = '  |'
	                def repeatLength = startItem.length() + output.length() + endItem.length()
	                println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
	            }
	        }
	    }
	    systemProperty "JRomManager.rootPath", "${rootDir}"
	    systemProperty "file.encoding", "utf-8"
	}

	
	jar {
		manifest {
			attributes(
				"Specification-Title"  : "JRomManager Server",
				"Implementation-Title" : "jrmserver",
			)
		}
	}
}

configurations {
	jlinkConfig
	noarchConfig.extendsFrom runtimeClasspath, runtime
}

dependencies {
	jlinkConfig project(':jrmstandalone')
	jlinkConfig project(':jrmfx')
	jlinkConfig project(':jrmcli')
	jlinkConfig project(':jrmserver')
	noarchConfig project(':jrmcli')
	noarchConfig project(':jrmserver')
}

configurations.jlinkConfig  {
    def runtimeAttributes = configurations.runtimeClasspath.attributes
    runtimeAttributes.keySet().each { key ->
        attributes.attribute(key, runtimeAttributes.getAttribute(key))
    }
}

jar {
	def mainClassName="jrm.server.Server"
	manifest {
		def path =configurations.noarchConfig.filter { it.name.endsWith('.jar') }.collect { 'lib/' + it.getName() }.join(' ')
		attributes(
			"Manifest-Version"     : "1.0",
			"Specification-Title"  : "JRomManager",
			"Specification-Version": props.getProperty("Specification-Version"),
			"Implementation-Title" : "jrm",
			"Implementation-Version" : props.getProperty("Implementation-Version"),
			"Main-Class"           : mainClassName,
			"Class-Path"           : path
		)
		archiveFileName = project.name + '.jar'
	}
}

task cliFatJar(type: Jar) {
	def mainClassName="jrm.cli.JRomManagerCLI"
	manifest {
		attributes(
			"Manifest-Version"     : "1.0",
			"Specification-Title"  : "JRomManager",
			"Specification-Version": props.getProperty("Specification-Version"),
			"Implementation-Title" : "jrm",
			"Implementation-Version" : props.getProperty("Implementation-Version"),
			'Main-Class': mainClassName
		)
	}
	duplicatesStrategy = DuplicatesStrategy.INCLUDE
	archiveBaseName = 'JRomManagerCLI'
	from(project(':jrmcli').sourceSets.main.output.classesDirs)
	from(project(':jrmcli').sourceSets.main.resources)
	from { project(':jrmcli').configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
}

build.dependsOn cliFatJar 

task downloadDaemonWin(type: Download) {
	src 'https://archive.apache.org/dist/commons/daemon/binaries/windows/commons-daemon-'+props.getProperty("Commons-Daemon-Version")+'-bin-windows.zip'
	dest file("$buildDir/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-bin-windows.zip")
	onlyIfModified true
}

task extractDaemonWin(type: Copy) {
    dependsOn downloadDaemonWin
    from zipTree(file("${buildDir}/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-bin-windows.zip"))
    include('amd64/*.exe', 'prunmgr.exe')
    eachFile {
      path = name
    }
    includeEmptyDirs = false
    into "${buildDir}/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-bin-windows"
}

task downloadDaemonLinux(type: Download) {
	src 'https://archive.apache.org/dist/commons/daemon/source/commons-daemon-'+props.getProperty("Commons-Daemon-Version")+'-native-src.tar.gz'
	dest file("$buildDir/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-native-src.tar.gz")
	onlyIfModified true
}

task extractDaemonLinux(type: Copy) {
    dependsOn downloadDaemonLinux
    from tarTree(file("${buildDir}/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-native-src.tar.gz"))
    into "${buildDir}/jsvc"
}

task configureDaemonLinux(type:Exec, dependsOn:extractDaemonLinux){
	workingDir "${buildDir}/jsvc/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-native-src/unix"
	commandLine './configure', '--silent', '--with-java='+System.properties['java.home']
	standardOutput = new ByteArrayOutputStream()
	doLast{
		print standardOutput.toString().trim()
	}
}

task compileDaemonLinux(type:Exec, dependsOn:configureDaemonLinux){
	workingDir "${buildDir}/jsvc/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-native-src/unix"
	commandLine 'make', '--silent'
	standardOutput = new ByteArrayOutputStream()
	doLast{
		print standardOutput.toString().trim()
	}
}

import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform

def os = DefaultNativePlatform.currentOperatingSystem
def arch = DefaultNativePlatform.currentArchitecture

distributions {
	main {
        distributionBaseName = 'JRomManager'
       	distributionClassifier = 'nogui-noarch'
		contents {
			from (configurations.noarchConfig) {
				into('lib')
				exclude '*.zip'
				include '*.jar'
			}
			from (jar)
			if (os.isLinux()) {
				from ("${buildDir}/jsvc/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-native-src/unix") {
					include 'jsvc'
					fileMode = 0755
				}
			}
			from ("${buildDir}/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-bin-windows") {
				fileMode = 0755
			}
			from ('dist/logs') {
				include '.do_not_delete'
				into 'logs'
				dirMode = 0777
			}
			from ('dist') {
				include '*.bat'
				include '*.sh'
				fileMode = 0755
			}
		}
	}
	win {
        distributionBaseName = 'JRomManager'
        if(arch.isI386())
        	distributionClassifier = 'win-x32'
        else if(arch.isAmd64())
        	distributionClassifier = 'win-x64'
        else if(arch.isArm32())
        	distributionClassifier = 'win-arm32'
        else if(arch.isArm64())
        	distributionClassifier = 'win-arm64'
        else
        	distributionClassifier = 'win-'+arch.getName()
		contents {
			from (configurations.jlinkConfig) {
				into('lib')
				exclude '*.zip'
				include '*.jar'
			}
			from (jar)
			from ("${buildDir}/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-bin-windows") {
				fileMode = 0755
			}
			from ('dist/logs') {
				include '.do_not_delete'
				into 'logs'
				dirMode = 0777
			}
			from ('dist') {
				include '*.bat'
				fileMode = 0755
			}
			from ('dist/full') {
				include '*.bat'
				fileMode = 0755
			}
		}
	}
	linux {
        distributionBaseName = 'JRomManager'
        if(arch.isI386())
        	distributionClassifier = 'linux-x32'
        else if(arch.isAmd64())
        	distributionClassifier = 'linux-x64'
        else if(arch.isArm32())
        	distributionClassifier = 'linux-arm32'
        else if(arch.isArm64())
        	distributionClassifier = 'linux-arm64'
        else
        	distributionClassifier = 'linux-'+arch.getName()
		contents {
			from (configurations.jlinkConfig) {
				into('lib')
				exclude '*.zip'
				include '*.jar'
			}
			from (jar)
			from ("${buildDir}/jsvc/commons-daemon-"+props.getProperty("Commons-Daemon-Version")+"-native-src/unix") {
				include 'jsvc'
				fileMode = 0755
			}
			from ('dist/logs') {
				include '.do_not_delete'
				into 'logs'
				dirMode = 0777
			}
			from ('dist') {
				include '*.sh'
				fileMode = 0755
			}
			from ('dist/full') {
				include '*.sh'
				fileMode = 0755
			}
		}
	}
}

distTar {
	compression = Compression.GZIP
	archiveExtension = "tar.gz"
}

distZip.dependsOn jar
distZip.dependsOn ':WebClient:build'
distZip.dependsOn extractDaemonWin
distTar.dependsOn jar
distTar.dependsOn ':WebClient:build'
distTar.dependsOn extractDaemonWin
installDist.dependsOn jar
installDist.dependsOn ':WebClient:build'
installDist.dependsOn extractDaemonWin
if (os.isLinux()) {
	winDistZip.enabled = false
	winDistTar.enabled = false
	linuxDistZip.enabled = false
	linuxDistTar.dependsOn jar
	linuxDistTar.dependsOn ':WebClient:build'
	linuxDistTar.dependsOn compileDaemonLinux
	linuxDistTar {
		compression = Compression.GZIP
		archiveExtension = "tar.gz"
	}
	distZip.dependsOn compileDaemonLinux
	distTar.dependsOn compileDaemonLinux
	installDist.dependsOn compileDaemonLinux
	build.dependsOn linuxDistTar
}
else if (os.isWindows()) {
	linuxDistTar.enabled = false
	linuxDistZip.enabled = false
	winDistTar.enabled = false
	winDistZip.dependsOn jar
	winDistZip.dependsOn ':WebClient:build'
	winDistZip.dependsOn extractDaemonWin
	build.dependsOn winDistZip
}

task aggregatedJavadocs(type: Javadoc, description: 'Generate javadocs from all child projects as if it was a single project', group: 'Documentation') {
	destinationDir = file("$buildDir/docs/javadoc")
	title = "$project.name $version API"
	options.author true
	options.links 'https://docs.oracle.com/en/java/javase/21/docs/api', 'https://openjfx.io/javadoc/21/'
	options.addStringOption 'Xdoclint:none', '-quiet'
	
	def projectsWithJavadoc = subprojects.findAll { it.javadoc.enabled }
	source = projectsWithJavadoc.collect { it.sourceSets.main.allJava }
	classpath = files(projectsWithJavadoc.collect { it.sourceSets.main.compileClasspath })
	includes = projectsWithJavadoc.collectMany { it.javadoc.getIncludes() }
	excludes = projectsWithJavadoc.collectMany { it.javadoc.getExcludes() }
	
/*	subprojects.each { proj ->
		proj.tasks.withType(Javadoc).each { javadocTask ->
			source += javadocTask.source
			classpath += javadocTask.classpath
			excludes += javadocTask.excludes
			includes += javadocTask.includes
		}
	}*/
}

task docZip(type: Zip, dependsOn: aggregatedJavadocs) {
	destinationDirectory = buildDir
	archiveClassifier = 'javadocs'
	from javadoc.outputs.files
	into "docs"
	archiveFileName = project.name + '-' + project.version + '-apidocs' + '.zip'
	destinationDirectory = file("$buildDir/distributions/")
}

build.dependsOn docZip

build.dependsOn installDist

apply plugin: 'com.netflix.nebula.ospackage'

ospackage {
	packageName 'jrommanager'
	packageDescription 'A Mame and Retrogaming Rom Manager, Java alternative to ClrMamePro'
	release '1'
	type= BINARY
	license 'GPL-2'
	vendor 'optyfr'
	packager 'optyfr'
	maintainer 'optyfr'
	user 'root'
	permissionGroup 'root'
	into '/opt/jrommanager'
	url 'https://github.com/optyfr/JRomManager'
	from (configurations.noarchConfig) {
		into('lib')
		exclude '*.zip'
		include '*.jar'
	}
	from (jar)
	from ('dist') {
		include '*.bat'
		include '*.sh'
		include '*.shconf'
		fileMode = 0755
	}
	from ('dist') {
		include name+'.desktop'
		into '/usr/share/applications'
	}
	from ('dist') {
		include name+'.png'
		into '/usr/share/pixmaps'
	}
	link('/usr/bin/jrommanager', '/opt/jrommanager/JRomManager-multi.sh')
}

buildDeb {
	requires('java21-runtime')
	arch = "all"
}

buildRpm {
	requires('java', '1:21', EQUAL).or('java-21')
	arch = NOARCH
	os = LINUX
	addParentDirs = false
	createDirectoryEntry = false
}

buildRpm.dependsOn distZip
build.dependsOn buildRpm
buildDeb.dependsOn distZip
build.dependsOn buildDeb


apply plugin: "org.beryx.jlink"

jlink {
//	options = ['--strip-debug', '--compress', '2', '--no-header-files', '--no-man-pages']
	mergedModuleName = "jrm.merged.module"
	configuration = 'jlinkConfig'
	addExtraDependencies("javafx")
	mergedModule {
 		additive = true
	//	requires 'com.google.gson'
		requires 'ch.qos.logback.classic'
	//	requires 'one.util.streamex'
		requires 'jdk.zipfs'
	}
	launcher {
		name = 'JRomManager'
		moduleName = 'jrm.merged.module'
		mainClass = 'jrm.fx.JRomManagerMulti'
		jvmArgs = ['-Dfile.encoding=UTF-8', '-XX:MaxRAMPercentage=75']
	}
	secondaryLauncher {
		name = 'JRomManagerSwing'
		moduleName = 'jrm.merged.module'
		mainClass = 'jrm.JRomManagerMulti'
		jvmArgs = ['-Dfile.encoding=UTF-8', '-XX:MaxRAMPercentage=75']
	}
	secondaryLauncher {
		name = 'JRomManagerCLI'
		moduleName = 'jrm.merged.module'
		mainClass = 'jrm.cli.JRomManagerCLI'
		winConsole = true
		jvmArgs = ['-Dfile.encoding=UTF-8', '-XX:MaxRAMPercentage=75']
	}
	secondaryLauncher {
		name = 'JRomManagerServer'
		moduleName = 'jrm.merged.module'
		mainClass = 'jrm.server.Server'
		winConsole = true
		jvmArgs = ['-Dfile.encoding=UTF-8', '-XX:MaxRAMPercentage=75']
		args = ['--workpath','%HOMEPATH%/.jrommanager']
	}
	secondaryLauncher {
		name = 'JRomManagerFullServer'
		moduleName = 'jrm.merged.module'
		mainClass = 'jrm.fullserver.FullServer'
		winConsole = true
		jvmArgs = ['-Dfile.encoding=UTF-8', '-XX:MaxRAMPercentage=75']
		args = ['--workpath','%HOMEPATH%/.jrommanager']
	}
	targetPlatform("win") {
		jdkHome = jdkDownload("https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.3%2B9/OpenJDK21U-jdk_x64_windows_hotspot_21.0.3_9.zip")
	}
	targetPlatform("linux-x64") {
		jdkHome = jdkDownload("https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.3%2B9/OpenJDK21U-jdk_x64_linux_hotspot_21.0.3_9.tar.gz")
	}
	targetPlatform("macos-x64") {
		jdkHome = jdkDownload("https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.3%2B9/OpenJDK21U-jdk_x64_mac_hotspot_21.0.3_9.tar.gz")
	}
	jpackage {
		installerType = project.findProperty('installerType') // we will pass this from the command line (example: -PinstallerType=msi)
		targetPlatformName = project.findProperty('targetPlatform') // we will pass this from the command line (example: -PtargetPlatform=win)
		installerOutputDir = file("$buildDir/installer")
		imageName = 'JRomManager'
		icon = 'dist/JRomManager.ico'
		if (installerType == 'msi') {
			imageOptions += ['--icon', 'dist/JRomManager.ico']
			installerOptions += [
				'--win-dir-chooser', '--win-menu', '--win-shortcut'
			]
		}
		if (installerType == 'deb' || installerType=='rpm') {
			imageOptions += ['--icon', 'dist/JRomManager.png']
			installerOptions += [
				'--linux-package-name', 'jrommanager',
				'--linux-app-category', 'utils',
				'--linux-app-release', 1,
				'--linux-rpm-license-type', 'GPL-2',
				'--linux-menu-group', 'Utility',
				'--linux-shortcut'
			]
		}
		if (installerType == 'dmg') {
/*			imageOptions += ['--icon', 'dist/JRomManager.png']
			installerOptions += [
			]*/
		}
	}	
}