buildscript {
  repositories { mavenCentral() }
  dependencies { classpath 'org.ajoberstar:gradle-git:0.2.3' }
}

plugins {
	id 'eclipse'
}

eclipse.project.natures 'org.eclipse.pde.PluginNature'

sourceSets.test.java.srcDirs = ['src']

////////////////////////////////////////////////////////////////////////
//
//  download and extract kawa 3.0 "kawa.jar"
//

task downloadKawa(type: Exec) {
     commandLine "wget", "ftp://ftp.gnu.org/pub/gnu/kawa/kawa-3.0.zip"
     workingDir "$temporaryDir"
     def destination = file("$temporaryDir/kawa-3.0.zip")
     enabled = !destination.exists() //to clone only once
}

task extractKawa(type: Copy, dependsOn: downloadKawa) {
	from(zipTree("${downloadKawa.temporaryDir}/kawa-3.0.zip")) {
		include "kawa-3.0/lib/kawa.jar"
		eachFile {
			relativePath new RelativePath(!directory, relativePath.lastName)
		}
	}
	into projectDir
	includeEmptyDirs false
	outputs.file 'kawa.jar'
	def destination = file('kawa.jar')
        enabled = !destination.exists() //to clone only once
}

task cleanExtractKawa(type: Delete) {
	delete files(extractKawa)[0]
}

clean.dependsOn cleanExtractKawa

////////////////////////////////////////////////////////////////////////
//
//  build kawa chess
//
import org.ajoberstar.gradle.git.tasks.*

task getKawaChess(type: GitClone) {
        def destination = file("kawa-chess")
        uri = "https://github.com/ttu-fpclub/kawa-chess"
        destinationPath = destination
        bare = false
        enabled = !destination.exists() //to clone only once
}

task compileChessFiles(type: JavaExec) {
	def kawaImg = file('kawa-chess/img.scm')
	def kawaPos = file('kawa-chess/pos.scm')
	def kawaChess = file('kawa-chess/chess.scm')
	def kawaGui = file('kawa-chess/gui.scm')
	inputs.file kawaImg
	inputs.file kawaPos
	inputs.file kawaChess
	inputs.file kawaGui

	workingDir = file('kawa-chess')

	def kawaJar = new File("kawa.jar")
	inputs.file kawaJar
	classpath kawaJar

	main 'kawa.repl'
	args '-C', 'img.scm', 'pos.scm', 'chess.scm', 'gui.scm'
}

compileChessFiles.dependsOn extractKawa
compileChessFiles.dependsOn getKawaChess

task compileChessMain(type: JavaExec, dependsOn: compileChessFiles) {
	def kawaJar = new File("kawa.jar")
	inputs.file kawaJar
	classpath kawaJar

	workingDir = file("kawa-chess")

	def kawaMain = file('kawa-chess/main.scm')
	inputs.file kawaMain

	main 'kawa.repl'
	args '--main', '-C', 'main.scm'
}

task buildChessJar(type: Jar, dependsOn: compileChessMain) {
	from file('kawa-chess')
	baseName 'kawachess'
	version null
	destinationDir projectDir
}


////////////////////////////////////////////////////////////////////////
//
//  build the kawa test jar
//

task compileKawaTestMain(type: JavaExec, dependsOn: extractKawa) {
	def kawaJar = new File("kawa.jar")
	inputs.file kawaJar
	classpath kawaJar

	workingDir file('kawasrc')
	
        def kawaMain = file('kawasrc/test.scm')
	inputs.file kawaMain

	main 'kawa.repl'
	args '--main', '-C', 'test.scm'
}

task buildKawaTestJar(type: Jar, dependsOn: compileKawaTestMain) {
	from file('kawasrc')
	baseName 'kawatest'
	version null
	destinationDir projectDir
}


////////////////////////////////////////////////////////////////////////
//
//  download and extract "bcel-5.2.jar"
//

task downloadBcel(type: VerifiedDownload) {
	ext.version = '5.2'
	def archive = "bcel-${version}.tar.gz"
	src "http://archive.apache.org/dist/jakarta/bcel/binaries/$archive"
	dest "$temporaryDir/$archive"
	checksum '19bffd7f217b0eae415f1ef87af2f0bc'
	useETag false
}

task extractBcel(type: Copy, dependsOn: downloadBcel) {
	from(tarTree(downloadBcel.dest)) {
		include "bcel-${downloadBcel.version}/bcel-${downloadBcel.version}.jar"
		eachFile {
			relativePath new RelativePath(!directory, relativePath.lastName)
		}
	}
	into projectDir
	includeEmptyDirs false
	outputs.file "bcel-${downloadBcel.version}.jar"
}

task cleanExtractBcel(type: Delete) {
	delete files(extractBcel)[0]
}

clean.dependsOn cleanExtractBcel



////////////////////////////////////////////////////////////////////////
//
//  download "java-cup-11a.jar"
//

task downloadJavaCup(type: VerifiedDownload) {
	def archive = 'java-cup-11a.jar'
	src "http://www2.cs.tum.edu/projects/cup/$archive"
	dest "$projectDir/$archive"
	checksum '2bda8c40abd0cbc295d3038643d6e4ec'
}

task cleanDownloadJavaCup(type: Delete) {
	delete downloadJavaCup
}

clean.dependsOn cleanDownloadJavaCup


////////////////////////////////////////////////////////////////////////
//
//  collect "JLex.jar"
//

task collectJLex(type: Jar) {
	from project(':com.ibm.wala.cast.java.test.data').compileTestJava
	include 'JLex/'
	baseName 'JLex'
	version null
	destinationDir projectDir
}

task cleanCollectJLex(type: Delete) {
	delete collectJLex
}

clean.dependsOn cleanCollectJLex


////////////////////////////////////////////////////////////////////////
//
//  generate "hello_hash.jar"
//

task downloadOcamlJava(type: VerifiedDownload) {
	def version = '2.0-alpha1'
	ext.basename = "ocamljava-$version"
	def archive = "${basename}.tar.gz"
	src "http://www.ocamljava.org/downloads/download.php?version=$version-bin"
	dest "$temporaryDir/$archive"
	checksum '45feec6e3889f5073a39c2c4c84878d1'
}

task unpackOcamlJava(type: Sync, dependsOn: downloadOcamlJava) {
	from tarTree(downloadOcamlJava.dest)
	into temporaryDir
}

task generateHelloHashJar(type: JavaExec, dependsOn: unpackOcamlJava) {
	def ocamlSource = file('ocaml/hello_hash.ml')
	inputs.file ocamlSource

	def jarTarget = file('hello_hash.jar')
	outputs.file jarTarget
	outputs.cacheIf { true }

	def ocamlJavaJar = new File("$unpackOcamlJava.destinationDir/$downloadOcamlJava.basename/lib/ocamljava.jar")
	inputs.file ocamlJavaJar
	classpath ocamlJavaJar

	main 'ocaml.compilers.ocamljavaMain'
	args ocamlSource, '-o', jarTarget
}

task cleanGenerateHelloHashJar(type: Delete) {
	delete generateHelloHashJar
	delete fileTree('ocaml') {
		exclude '*.ml'
		exclude '.gitignore'
	}
}

clean.dependsOn cleanGenerateHelloHashJar


////////////////////////////////////////////////////////////////////////
//
//  collect "com.ibm.wala.core.testdata_1.0.0.jar"
//

task collectTestData(type: Jar) {
	version '1.0.0'
	archiveName "${baseName}_${version}.${extension}"
	from compileTestJava
	from 'classes'
	includeEmptyDirs false
	destinationDir projectDir
}

task cleanCollectTestData(type: Delete) {
	delete collectTestData
}

clean.dependsOn cleanCollectTestData


////////////////////////////////////////////////////////////////////////
//
//  collect "com.ibm.wala.core.testdata_1.0.0a.jar"
//

task collectTestDataA(type: Jar) {
	version '1.0.0a'
	archiveName "${baseName}_${version}.${extension}"
	from compileTestJava
	from 'classes'
	includeEmptyDirs false
	destinationDir projectDir
	exclude (
		'**/CodeDeleted.class',
		'**/SortingExample.class',
		'**/A.class',
		)
}

task cleanColllectTestDataA(type: Delete) {
	delete collectTestDataA
}

clean.dependsOn cleanCollectTestDataA


////////////////////////////////////////////////////////////////////////
//
//  help Eclipse build these extra jars when needed
//

afterEclipseBuildshipImport {
	dependsOn(
		collectJLex,
		collectTestData,
		collectTestDataA,
		downloadJavaCup,
		extractBcel,
		generateHelloHashJar,
		buildChessJar,
		buildKawaTestJar,
		)
}