buildscript {

	repositories {
		mavenCentral()
        maven {
            url alfrescoMavenUrl
        }
	}

	dependencies {
        //MMT dependencies
        classpath('org.alfresco:alfresco-mmt:4.2.d-beta') {
            transitive = true
        }
        classpath 'de.schlichtherle.truezip:truezip-kernel:7.5.5'
        classpath 'de.schlichtherle.truezip:truezip-swing:7.5.5'

        //YUI
	    classpath 'com.yahoo.platform.yui:yuicompressor:2.4.6'
	}
}
 
task wrapper(type: Wrapper) {
    gradleVersion = '1.7'
}

task deleteDist(type: Delete) {
    ant.delete(includeEmptyDirs: 'true', dir: 'dist')
}

/** Global Values **/
ext {
    distDir = 'dist'
    packageBaseName = "${groupid}-${packageName}-${version}-${build}"
    packageZipFile = "${packageBaseName}.zip"
    if (!project.hasProperty('alfrescoBaseSolrVersion')) alfrescoBaseSolrVersion=alfrescoBaseVersion
    if (!project.hasProperty('alfrescoTestDepsVersion')) alfrescoTestDepsVersion=alfrescoBaseVersion
    javaVersion = JavaVersion.current()
}

/** Package Build Tasks */

task packageBuild (dependsOn: [':rm-server:amp', ':rm-share:amp']) << {
	
	def distDirFile = file('dist')
	if (distDirFile.exists() == false) {
		distDirFile.mkdirs();
	}
	
	def alfrescoAmp = "${project(':rm-server').name}/${project(':rm-server').buildDistDir}/${project(':rm-server').ampFile}"
	def shareAmp = "${project(':rm-share').name}/${project(':rm-share').buildDistDir}/${project(':rm-share').ampFile}"
	
	ant.zip(destfile: "${distDir}/${packageZipFile}", update: 'true') {	
		
		ant.zipfileset(file: "${alfrescoAmp}")
		ant.zipfileset(file: "${shareAmp}")		
	}
}

/** I18N Tasks */

task localisationPackage (dependsOn: [':rm-server:assembleLocalisationPackage', ':rm-share:assembleLocalisationPackage']) << {

	distDirFile = file('dist')
	if (distDirFile.exists() == false) {
		distDirFile.mkdirs();
	}	
	
	def svnVersion
	new ByteArrayOutputStream().withStream { os ->
		
		def result = exec {
			executable = 'svn'
			args = ['info']
			standardOutput = os
		}
		
		def outputAsString = os.toString()
		def matchLastChangedRev = outputAsString =~ /Last Changed Rev: (\d+)/
		svnVersion = matchLastChangedRev[0][1]
	}
		
	localisationPackageZipFile = "messages-${groupid}-${packageName}-${version}-r${svnVersion}.zip"
	
	alfrescoLocalisationPackage = "${project(':rm-server').name}/${project(':rm-server').i18nDir}"
	shareLocalisationPackage = "${project(':rm-share').name}/${project(':rm-share').i18nDir}"

	ant.zip(destfile: "${distDir}/${localisationPackageZipFile}", update: 'true') {	
		
		ant.zipfileset(dir: "${alfrescoLocalisationPackage}")
		ant.zipfileset(dir: "${shareLocalisationPackage}")
	}
}

/** Icon extraction */

task iconPackage (dependsOn: [':rm-server:assembleIconPackage', ':rm-share:assembleIconPackage']) << {

	distDirFile = file('dist')
	if (distDirFile.exists() == false) {
		distDirFile.mkdirs();
	}	
	
	def svnVersion
	new ByteArrayOutputStream().withStream { os ->
		
		def result = exec {
			executable = 'svn'
			args = ['info']
			standardOutput = os
		}
		
		def outputAsString = os.toString()
		def matchLastChangedRev = outputAsString =~ /Last Changed Rev: (\d+)/
		svnVersion = matchLastChangedRev[0][1]
	}
		
	iconPackageZipFile = "icons-${groupid}-${packageName}-${version}-r${svnVersion}.zip"
	
	alfrescoIconPackage = "${project(':rm-server').name}/${project(':rm-server').iconDir}"
	shareIconPackage = "${project(':rm-share').name}/${project(':rm-share').iconDir}"

	ant.zip(destfile: "${distDir}/${iconPackageZipFile}", update: 'true') {	
		
		ant.zipfileset(dir: "${alfrescoIconPackage}")
		ant.zipfileset(dir: "${shareIconPackage}")
	}
}

/** Subproject configuration */
subprojects { subproject ->

	apply plugin: 'java'	
	apply plugin: 'eclipse'
	
	sourceCompatibility = 1.7
    targetCompatibility = 1.7

    ext {	
    	explodedDepsDir = 'explodedDeps'	
    	explodedLibsDir = "${explodedDepsDir}/lib"
    	explodedConfigDir = "${explodedDepsDir}/config"
    	iconDir = 'build/icon'
    	configModuleDir = "config/alfresco/module/${moduleid}"
    	baseName = "${groupid}-${appName}-${version}-${build}"
    	jarFile = "${baseName}.jar"
    	ampFile = "${baseName}.amp"
    	tomcatRoot = System.getenv(tomcatEnv)
    	jarFilePath = "${buildLibDir}/${jarFile}"
	}
   
	sourceSets {
		main {
			java {
				srcDir 'source/java'
			}
            resources {
                srcDir 'source/resources'
            }
		}
        amp {
            resources {         
               srcDir 'config'
            }
        }
		test {
			java {
				srcDir 'test/java'
			}	
			resources {
				srcDir 'test/resources'
			}
            runtimeClasspath += amp.output
		}        
        web {
            resources {
                srcDir 'source/web'
            }
        }
	}
    
	repositories { 
	
		flatDir {
			dirs explodedLibsDir
		}
		mavenCentral()
		maven {
			url alfrescoMavenUrl
		}
		maven {
			url alfrescoEnterpriseMavenUrl
			credentials {
				username alfrescoEnterpriseMavenUser
				password alfrescoEnterpriseMavenPwd
			}
		}
		maven {
			url 'https://artifacts.alfresco.com/nexus/content/groups/public-snapshots'
		}
		maven {
			url 'https://repository.jboss.org/nexus/content/groups/public'
		}
	}
	
	configurations {
		alfrescoDeps
	}	
	
	configurations.all {
		exclude group: 'com.sun.jdmk', module: 'jmxtools'
		exclude group: 'com.sun.jmx', module: 'jmxri'
		exclude group: "javax.mail", module: "mail"
		exclude group: 'javax.jms', module: 'jms'
		exclude group: 'maven-plugins', module: 'maven-cobertura-plugin'
		exclude group: 'maven-plugins', module: 'maven-findbugs-plugin'
		exclude group: 'org.mybatis', module: 'mybatis'
		exclude group: 'commons-dbcp', module: 'commons-dbcp'
		exclude group: 'org.alfresco', module: 'alfresco-web-framework-commons'
	}
	
	dependencies {		     		
		
		compile fileTree(dir: explodedLibsDir, include: '*.jar')     	
	}	
	
	// make sure existing eclipse projects are cleared
	tasks.eclipse.dependsOn(cleanEclipse)
	
	/** --- Compile tasks --- */
    tasks.withType(Compile) {
        options.encoding = 'utf-8'
    }

    jar {
        archiveName = jarFile
        exclude "**/dev-context.xml"
        exclude "**/readme.txt"
     }
	
    //Add manifest attributes
    tasks.withType(Jar) {
        manifest {
            attributes 'Specification-Title': "Alfresco Records Management",
                       'Implementation-Title': "${subproject.archivesBaseName}",
                       'Implementation-Version': version,
                       'Created-By': "${javaVersion} (${System.getProperty('java.specification.vendor')})"
        }
    }

	/** --- Dependancy tasks --- */	

	task fetchWarFile(type:Copy) {
        from configurations.alfrescoDeps
        into '.'
        include '*.war'
        rename { String filename -> warFile }
	}

	task explodeDeps << {
	
		def explodedDir = file(explodedDepsDir)
		def explodedLibDir = file(explodedLibsDir)
		def explodedConfigDir = file("${explodedDepsDir}/config")
		def warFileObj = file(warFile)
	
		// if the WAR file still isn't there raise an error
		if (warFileObj.exists() == true) {
			
			logger.lifecycle "${warFile} was found.  Checking dependancies ..."
			
			if (explodedDir.exists() == false) {
				println(" ... creating destination dir ${explodedDir}")
				explodedDir.mkdir()
			}
			
			if (isUnpacked(explodedLibDir) == false) {
			
				println(" ... unpacking libs into ${explodedLibDir}")
				
				ant.unzip(src: warFileObj, dest: explodedLibDir) {
					ant.patternset {
						ant.include(name: 'WEB-INF/lib/*.jar')
					}
					ant.mapper(type: 'flatten')
				}
			}
			
			if (isUnpacked(explodedConfigDir) == false) {
			
				println(" ... unpacking config into ${explodedConfigDir}")
				
				ant.unzip(src: warFileObj, dest: explodedDir) {
					ant.patternset {
						ant.include(name: 'WEB-INF/classes/**/*')
					}
				}
				
				copy {
					from "${explodedDir}/WEB-INF/classes"
					into explodedConfigDir
				}
				
				// TODO understand why this doesn't delete the folder as expected
				ant.delete(includeEmptyDirs: 'true') {
					ant.fileset(dir: "${explodedDir}/WEB-INF", includes: '**/*')			
				}
			}
		}
		else {			
			logger.error "Dependant WAR file ${warFile} can not be found.  Please place it in ${warFileObj.getPath()} to continue."
			throw new TaskInstantiationException("Dependant WAR file ${warFile} can not be found.  Please place it in ${warFileObj.getPath()} to continue.")
		}		
	}

    compileJava.dependsOn explodeDeps
    
	task cleanDeps(dependsOn: clean) << {
		ant.delete(includeEmptyDirs: 'true', dir: explodedDepsDir)
		ant.delete(file: warFile)
	}	
    
	/** --- I18N tasks */
		
	task assembleLocalisationPackage << {
	
		delete i18nDir
		file(i18nDir).mkdirs()
	
		copy {
			from sourceSets.amp.resources
			include '**/*.properties'			
			exclude '**/*_*.properties'
			exclude '**/rm-method-security.properties'
			exclude '**/alfresco-global.properties'
			exclude '**/log4j.properties'
			exclude '**/module.properties'
			exclude '**/file-mapping.properties'
			into "${i18nDir}/${project.name}/config"	
            includeEmptyDirs = false 			
		}
	
	}
	
	task assembleIconPackage << {
	
		delete iconDir
		file(iconDir).mkdirs()
	
		copy {
			from '.'
			include '**/*.png'
			exclude 'build'
			exclude "${explodedDepsDir}"
			into "${iconDir}/${project.name}"	
            includeEmptyDirs = false 			
		}
	
	}
	
	/** --- AMP tasks --- */
	
	task copyWar(type: Copy) {
		from warFile
		into buildDistDir
	}
	
	task amp(dependsOn: 'jar') << {
	
		delete assembleDir
	
		copy {
			from "${configModuleDir}"
			include "${moduleProperties}"
			include "${fileMapping}"	
			into assembleDir
		}
	
		copy {
			from jarFilePath
			into "${assembleDir}/lib"
		}
		
		copy {
			from sourceSets.amp.resources
			exclude "**/${moduleProperties}"
			exclude "**/${fileMapping}"	
            exclude "**/readme.txt"
			exclude "**/dev-context.xml"
			into "${assembleDir}/config"		
		}
		
		copy {
			from sourceSets.web.resources			
			include '**/*'
			into "${assembleDir}/web"
		}
		
		def tree = fileTree("${assembleDir}/web") {
			include '**/*.js'
			exclude '**/*-min.js'
		}
		
		tree.each {File file ->
				
			def destinationFile = new File(file.getPath().replaceFirst('\\.js', '-min.js'))
			
			file.withReader{ reader -> 
				def compressor = new com.yahoo.platform.yui.compressor.JavaScriptCompressor(reader, null)
				destinationFile.withWriter { writer ->
					compressor.compress(writer, -1, false, false, false, false)
				}
			}
		}
		
		ant.zip(destfile: "${buildDistDir}/${ampFile}", update: 'true') {
			ant.zipfileset(dir: assembleDir)
		}	
	}
	
	task deployExploded(dependsOn: 'jar') << {
	
		def jarFileObj = file(jarFilePath)
	
		def explodedWebAppDir = new File("${tomcatRoot}/webapps/${webAppName}")
		if (explodedWebAppDir.exists() == true) {
		
				// copy module properties
				// TODO but not so important for now
				
				// copy jars
				if (jarFileObj.exists()) {
					copy {
						from jarFilePath
						into "${explodedWebAppDir}/WEB-INF/lib"
					}
				}
				
				// copy config
                from(sourceSets.amp.resources) {
                    exclude "**/${moduleProperties}"
                    exclude  "**/${fileMapping}"
                }
                into "${explodedWebAppDir}/WEB-INF/classes"
		
				// copy web
				copy {
					from sourceSets.web.resources
					into "${explodedWebAppDir}"						
				}
		}
		else {
			println "Exploded webapp directory ${explodedWebAppDir} does not exist."
		}
	}
	
	task installAmp(dependsOn: ['amp', 'copyWar']) << {
		
		def warFileLocation = file("${buildDistDir}/${warFile}")
		def ampFileLocation = file("${buildDistDir}/${ampFile}")
		
		mmt = new org.alfresco.repo.module.tool.ModuleManagementTool()
		mmt.setVerbose(true)		
		mmt.installModule(ampFileLocation.getPath(), warFileLocation.getPath(), false, true, false)
	}
	
	task cleanDeploy(type: Delete) {
		delete "${tomcatRoot}/webapps/${webAppName}", "${tomcatRoot}/webapps/${warFile}"
	}
	
	task deployAmp(dependsOn: ['cleanDeploy', 'installAmp']) << {
	
		tomcatRootDir = new File(tomcatRoot)
		if (tomcatRootDir.exists() == true) {
			
			// copy war
			copy {
				from "${buildDistDir}/${warFile}"
				into "${tomcatRoot}/webapps"
			}
		} 
		else {
			println "Tomcat root directory ${tomcatRoot} does not exist."
		}		
	}
}

/** Utility function - indicates wether the provided dir is unpacked (ie exists and has some contents) */
Boolean isUnpacked(dir) {
	if (dir.exists() == true && dir.list().length > 0) {
		return true
	}
	else {
		return false
	}
}