plugins {
	id 'org.hibernate.build.xjc' version '2.0.0-SNAPSHOT'
}

/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
import org.apache.tools.ant.filters.ReplaceTokens

apply from: rootProject.file( 'gradle/published-java-module.gradle' )
apply plugin: Antlr4Plugin
apply plugin: 'hibernate-matrix-testing'

description = 'Hibernate\'s core ORM functionality'

ext {
    jaxbTargetDir = file( "${buildDir}/generated-src/jaxb/main" )
}

sourceSets.main {
    java.srcDir project.jaxbTargetDir
}

sourceSets {
    // resources inherently exclude sources
    test {
        resources {
            setSrcDirs( ['src/test/java','src/test/resources'] )
        }
    }

    testJavassist {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
        }
    }
}

configurations {
    tests {
        description = 'Configuration for the produced test jar'
    }

    //Configures the compile and runtime configurations for our javassist tests
    //and includes the dependencies of the test task.
    testJavassistCompile.extendsFrom testCompile
    testJavassistRuntime.extendsFrom testRuntime
}

dependencies {
    compile( libraries.jpa )
    // This can now be made provided
    compile( libraries.javassist )
    compile( libraries.byteBuddy )
    compile( libraries.antlr )
    compile( libraries.jta )
    compile( libraries.jandex )
    compile( libraries.classmate )
    compile( libraries.activation )

    // We need dom4j for a number of things temporarily:
    //      1) (unsupported) EntityMode.DOM4J support
    //      2) Envers
    //      3) hibernate-commons-annotations
    compile( libraries.dom4j )
    compile( libraries.commons_annotations )

    // JAXB
    compile( libraries.jaxb_api )
    compile( libraries.jaxb_runtime )

	// Antlr
	antlr( libraries.antlr )

	// xjc plugin
    xjc( libraries.jaxb_runtime )
    xjc( libraries.jaxb_xjc )
    xjc( libraries.jaxb2_basics )
    xjc( libraries.jaxb2_basics_ant )
    xjc( libraries.activation )

    provided( libraries.jacc )
    provided( libraries.validation )
    provided( libraries.ant )
	provided( libraries.cdi )

	runtime( libraries.junit5_vintage )
	runtime( libraries.junit5_jupiter )

    testCompile( project(':hibernate-testing') )
    testCompile( libraries.shrinkwrap_api )
    testCompile( libraries.shrinkwrap )
    testCompile( libraries.jacc )
    testCompile( libraries.validation )
    testCompile( libraries.jandex )
    testCompile( libraries.classmate )
    testCompile( libraries.mockito )
    testCompile( libraries.mockito_inline )
    testCompile( libraries.jodaTime )
    testCompile( libraries.assertj )

    testCompile( libraries.cdi ) {
        // we need to force it to make sure we influence the one coming from arquillian
        force=true
    }

    testCompile( libraries.validator ) {
        // for test runtime
        transitive = true
    }

    // for testing stored procedure support
    testCompile( libraries.derby )

    testRuntime( "org.jboss.spec.javax.ejb:jboss-ejb-api_3.2_spec:1.0.0.Final" )
    testRuntime( libraries.expression_language )
    testRuntime( 'jaxen:jaxen:1.1' )
    testRuntime( libraries.javassist )
    testRuntime( libraries.byteBuddy )
    testRuntime( libraries.weld )
    testRuntime( libraries.atomikos )
    testRuntime( libraries.atomikos_jta )
    testRuntime(libraries.wildfly_transaction_client)

    testAnnotationProcessor( project( ':hibernate-jpamodelgen' ) )

    testCompile libraries.arquillian_junit_container
    testCompile libraries.arquillian_protocol_servlet
    testCompile libraries.shrinkwrap_descriptors_api_javaee
    testCompile libraries.shrinkwrap_descriptors_impl_javaee
    testCompile libraries.wildfly_arquillian_container_managed

    testCompile libraries.jboss_ejb_spec_jar
    testCompile libraries.jboss_annotation_spec_jar

    // Additional tests requiring Javassist
    // folder in src/javassist/java
    testJavassistCompile libraries.javassist
}

jar {
    manifest {
        mainAttributes( 'Main-Class': 'org.hibernate.Version' )

        instructionFirst 'Import-Package',
                         'javax.security.auth;resolution:=optional',
                         'javax.security.jacc;resolution:=optional',
                         'javax.validation;resolution:=optional',
                         'javax.validation.constraints;resolution:=optional',
                         'javax.validation.groups;resolution:=optional',
                         'javax.validation.metadata;resolution:=optional',
                         // TODO: Shouldn't have to explicitly list this, but the plugin
                         // generates it with a [1.0,2) version.
                         "javax.persistence;version=\"${project.jpaVersion.osgiName}\"",
                         // optionals
                         'javax.management;resolution:=optional',
                         'javax.naming.event;resolution:=optional',
                         'javax.naming.spi;resolution:=optional',
                         'org.apache.tools.ant;resolution:=optional',
                         'org.apache.tools.ant.taskdefs;resolution:=optional',
                         'org.apache.tools.ant.types;resolution:=optional',
                         '!javax.enterprise*',
                         'javax.enterprise.context.spi;resolution:=optional',
                         'javax.enterprise.inject.spi;resolution:=optional',
                         'javax.inject;resolution:=optional',
                         'net.bytebuddy.*;resolution:=optional',
                         // We must specify the version explicitly to allow Karaf
                         // to use an older version of JAXB (the only one we can use in Karaf)
                         "javax.xml.bind.*;version=\"${project.jaxbApiVersionOsgiRange}\""

//        // TODO: Uncomment once EntityManagerFactoryBuilderImpl no longer
//        // uses ClassLoaderServiceImpl.
//        instruction 'Export-Package',
//            'org.hibernate.boot.registry.classloading.internal',
//            '*'
    }
}

ext {
    jaxbTargetDir = file( "${buildDir}/generated-src/jaxb/main" )
}

sourceSets.main {
    java.srcDir project.jaxbTargetDir
}

// resources inherently exclude sources
sourceSets.test.resources {
    setSrcDirs( ['src/test/java','src/test/resources'] )
}

idea {
    module {
        sourceDirs += file( "${buildDir}/generated-src/antlr/main" )
    }
}

xjc {
    outputDir = project.jaxbTargetDir

    schemas {
        cfg {
            xsd = file( 'src/main/resources/org/hibernate/xsd/cfg/legacy-configuration-4.0.xsd' )
            xjcBinding = file( 'src/main/xjb/hbm-configuration-bindings.xjb' )
        }
        hbm {
            xsd = file( 'src/main/resources/org/hibernate/xsd/mapping/legacy-mapping-4.0.xsd' )
            xjcBinding = file( 'src/main/xjb/hbm-mapping-bindings.xjb' )
            xjcExtensions = ['inheritance', 'simplify']
        }
    }
}


//sourceSets.main.sourceGeneratorsTask.dependsOn xjc
//sourceSets.main.sourceGeneratorsTask.dependsOn antlr
tasks.compile.dependsOn antlr

// todo (6.0) : remove this once we get 6.0 stable-ish
tasks.withType( JavaCompile ).forEach({ JavaCompile c -> c.options.compilerArgs += ["-Xmaxerrs", "4999"]})

task copyBundleResources (type: Copy) {
    ext {
        bundlesTargetDir = file( "${buildDir}/bundles" )
        bundleTokens = dbBundle[db]
        ext.bundleTokens['buildDirName'] = buildDir.absolutePath
    }

    from file('src/test/bundles')
    into ext.bundlesTargetDir
    filter( ReplaceTokens, tokens: ext.bundleTokens)

    doFirst {
        ext.bundlesTargetDir.mkdirs()
    }
}
processTestResources.dependsOn copyBundleResources

task testJar(type: Jar, dependsOn: testClasses) {
    classifier = 'test'
    from sourceSets.test.output
}

artifacts {
    tests testJar
}

task generateEnversStaticMetamodel(
        type: JavaCompile,
        description: "Generate the Hibernate Envers revision entity static metamodel classes." ) {
    source = sourceSets.main.java
    // we only want to include these specific classes for metamodel generation.
    // if envers adds any additional revision entity classes, they must be listed here.
    include 'org/hibernate/envers/DefaultRevisionEntity.java'
    include 'org/hibernate/envers/DefaultTrackingModifiedEntitiesRevisionEntity.java'
    include 'org/hibernate/envers/enhanced/SequenceIdRevisionEntity.java'
    include 'org/hibernate/envers/enhanced/SequenceIdTrackingModifiedEntitiesRevisionEntity.java'

    classpath = sourceSets.main.runtimeClasspath + sourceSets.test.compileClasspath
    options.compilerArgs = [
            "-proc:only",
            "-processor",
            "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor"
    ]

    // put static metamodel classes back out to the source tree since they're version controlled.
    destinationDir = new File( "${projectDir}/src/main/java" )
}
//
//if ( JavaVersion.current().isJava9Compatible() ) {
//    logger.warn( '[WARN] Skipping Javassist-related tests for hibernate-core due to Javassist JDK 9 incompatibility' )
//
//    // we need to exclude tests using Javassist enhancement, which does not properly support
//    // Java 9 yet - https://issues.jboss.org/browse/JASSIST-261
//    test {
//        // rather than wild-cards, keep an explicit list
//        exclude 'org/hibernate/jpa/test/enhancement/InterceptFieldClassFileTransformerTest.class'
//        exclude 'org/hibernate/jpa/test/enhancement/runtime/JpaRuntimeEnhancementTest.class'
//        exclude 'org/hibernate/test/bytecode/enhancement/EnhancerTest.class'
//        exclude 'org/hibernate/test/bytecode/enhancement/basic/BasicInSessionTest.class'
//
//        // also, any tests using Arquillian for in-container testing with WildFly currently
//        // need to be excluded because WildFly does not yet work with Java 9
//        exclude 'org/hibernate/test/wf/ddl/**'
//        exclude 'org/hibernate/jpa/test/cdi/**'
//        exclude 'org/hibernate/envers/internal/tools/MapProxyTest.class'
//        exclude 'org/hibernate/envers/test/integration/components/dynamic/AuditedDynamicComponentTest.class'
//        exclude 'org/hibernate/envers/test/integration/components/dynamic/AuditedDynamicComponentsAdvancedCasesTest.class'
//    }
//}


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// todo (6.0) : fix after fixing hibernate-spatial
//processTestResources {
//    doLast {
//        copy {
//            from file( 'src/test/resources' )
//            into file( "${buildDir}/resources/test" )
//            include 'arquillian.xml'
//            include 'org/hibernate/test/wf/ddl/manifest.mf'
//            expand wildFlyInstallDir: project( ':hibernate-orm-modules' ).wildFlyInstallDir,
//                   hibernateMajorMinorVersion: "${project.ormVersion.family}",
//                   arquillianDeploymentExportDir: "${rootProject.buildDir.absolutePath}/arquillian-deployments"
//        }
//    }
//}
//
//test.dependsOn ':hibernate-orm-modules:prepareWildFlyForTests'
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

test {
    systemProperty 'file.encoding', 'utf-8'
    beforeTest { descriptor ->
        //println "Starting test: " + descriptor
    }
}


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Custom Antlr v4 Plugin
//      - the Gradle-supplied Antlr plugin attempts to simultaneously support
//      multiple versions of Antlr which leads to many difficulties.  this custom
//      plugin provides dedicated and simplified support for Antlr v4

ext {
    baseAntlrInputPath = 'src/main/antlr'
    baseAntlrOutputPath = 'generated-src/antlr/main'
}

class GrammarDescriptor {
    String packageName
    String grammarName

    GrammarDescriptor(String packageName, String grammarName) {
        this.packageName = packageName
        this.grammarName = grammarName
    }

    File resolveSourceFile(Project project) {
        return project.file(
                project.baseAntlrInputPath +
                        '/' + packageName.replace( '.', '/' ) +
                        '/' + grammarName + '.g4'
        )
    }

    File resolveOutputFile(Project project) {
        final File baseOutputDir = project.file( "${project.buildDir}/${project.baseAntlrOutputPath}/" )
        final File packagedOutputDirectory = new File( baseOutputDir, packageName.replace( '.', '/' ) )

        return new File( packagedOutputDirectory, grammarName + '.g4' )
    }
}

class Antlr4Plugin implements Plugin<Project> {
    void apply(Project project) {
        project.with {
            apply plugin : 'java'

            configurations.maybeCreate 'antlr'

            Antlr4GenerationTask genTask = tasks.create 'antlr', Antlr4GenerationTask
            genTask.group = 'Build'
            genTask.description = 'Generate source code from ANTLR grammar'

            tasks.getByName('compileJava').dependsOn genTask

            SourceSet mainSourceSet = project.convention.getPlugin( JavaPluginConvention ).sourceSets.getByName( SourceSet.MAIN_SOURCE_SET_NAME );
            mainSourceSet.compileClasspath += configurations.antlr

            SourceSet testSourceSet = project.convention.getPlugin( JavaPluginConvention ).sourceSets.getByName( SourceSet.TEST_SOURCE_SET_NAME );
            testSourceSet.compileClasspath += configurations.antlr

            project.afterEvaluate({
                mainSourceSet.java.srcDir( genTask.outputDirectory )
            })

        }
    }
}

class Antlr4GenerationTask extends DefaultTask {
    static final String HQL_PCKG        = 'org.hibernate.grammars.hql'
    static final String IMPORT_SQL_PCKG = 'org.hibernate.grammars.importsql'
    static final String GRAPH_PCKG      = 'org.hibernate.grammars.graph'
    static final String ORDER_PCKG      = 'org.hibernate.grammars.ordering'

    List<GrammarDescriptor> grammarDescriptors = [
            new GrammarDescriptor( HQL_PCKG, 'HqlLexer' ),
            new GrammarDescriptor( HQL_PCKG, 'HqlParser' ),
            new GrammarDescriptor( IMPORT_SQL_PCKG, 'SqlStatementLexer' ),
            new GrammarDescriptor( IMPORT_SQL_PCKG, 'SqlStatementParser' ),
            new GrammarDescriptor( GRAPH_PCKG, 'GraphLanguageLexer' ),
            new GrammarDescriptor( GRAPH_PCKG, 'GraphLanguageParser' ),
            new GrammarDescriptor( ORDER_PCKG, 'OrderingLexer' ),
            new GrammarDescriptor( ORDER_PCKG, 'OrderingParser' )
    ]

    @InputFiles
    @SkipWhenEmpty
    FileCollection getSource() {
        // only used for UP-TO-DATE checking
        return project.files( grammarDescriptors*.resolveSourceFile( project ) )
    }

    @OutputDirectory
    File getOutputDirectory() {
        // only used for UP-TO-DATE checking
        return project.file( "${project.buildDir}/${project.baseAntlrOutputPath}" )
    }

    @TaskAction
    void antlrGeneration() {
        logger.lifecycle( "Starting custom Antlr (v4) grammar generation" )

        grammarDescriptors.forEach( { grammarDescriptor -> generate( grammarDescriptor ) } )
    }

    def generate(GrammarDescriptor grammarDescriptor) {
        final File sourceFile = grammarDescriptor.resolveSourceFile( project )
        final File outputFile = grammarDescriptor.resolveOutputFile( project )

        logger.lifecycle( "Starting Antlr grammar generation `${grammarDescriptor.grammarName} : [${sourceFile.absolutePath}] -> [${outputFile.absolutePath}]" )

        outputFile.parentFile.mkdirs()

        project.javaexec {
            main 'org.antlr.v4.Tool'
            classpath project.configurations.antlr
            args '-o', outputFile.parentFile.absolutePath
//            args '-lib', sourceFile.parentFile.absolutePath
            args '-long-messages'
            args '-listener'
            args '-visitor'
            args sourceFile.absolutePath
        }
    }

}
//Create the task that runs the integration tests found from the
//configured source directory and uses the correct classpath.
task testJavassist(type: Test) {
    testClassesDirs = sourceSets.testJavassist.output.classesDirs
    classpath = sourceSets.testJavassist.runtimeClasspath
    //If you want to ensure that integration tests are run every time when you invoke
    //this task, uncomment the following line.
    //outputs.upToDateWhen { false }
}

check.dependsOn testJavassist
testJavassist.mustRunAfter test