plugins {
	id 'org.hibernate.build.xjc'
}

/*
 * 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

description = 'Hibernate\'s core ORM functionality'

apply from: rootProject.file( 'gradle/published-java-module.gradle' )
apply plugin: 'org.hibernate.orm.antlr'
apply plugin: 'org.hibernate.matrix-test'

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

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

    javassist {
        description "Dependencies for compiling and running the Javassist tests in the `javassist` source-set"
    }
}

sourceSets {
    main {
        // add the XJC generated JAXB classes to the main source-set
        java.srcDir project.jaxbTargetDir
    }

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

    testJavassist {
        // define the testJavassist source-set
        java {
            compileClasspath += main.output + test.output + configurations.javassist
            runtimeClasspath += main.output + test.output + configurations.javassist
        }
    }
}

dependencies {
    api libraries.jpa
    api libraries.jta
    api libraries.jandex
    api libraries.classmate
    api libraries.commons_annotations
    api libraries.jaxb_api

    implementation libraries.byteBuddy
    implementation libraries.activation
    implementation libraries.jaxb_runtime
    implementation libraries.antlr

    compileOnly libraries.jacc
    compileOnly libraries.validation
    compileOnly libraries.ant
    compileOnly libraries.cdi
    compileOnly libraries.javassist

    testImplementation project(':hibernate-testing')
    testImplementation libraries.shrinkwrap_api
    testImplementation libraries.shrinkwrap
    testImplementation libraries.shrinkwrap_descriptors_api_javaee
    testImplementation libraries.shrinkwrap_descriptors_impl_javaee
    testImplementation libraries.jacc
    testImplementation libraries.validation
    testImplementation( libraries.validator ) {
        // for test runtime
        transitive = true
    }
    testImplementation libraries.jandex
    testImplementation libraries.classmate
    testImplementation libraries.mockito
    testImplementation libraries.mockito_inline
    testImplementation libraries.jodaTime
    testImplementation libraries.assertj
    testImplementation libraries.cdi
    testImplementation libraries.jboss_ejb_spec_jar
    testImplementation libraries.jboss_annotation_spec_jar

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

    testAnnotationProcessor project( ':hibernate-jpamodelgen' )

    antlr libraries.antlr

    xjc libraries.jaxb_runtime
    xjc libraries.jaxb_xjc
    xjc libraries.jaxb2_basics
    xjc libraries.jaxb2_basics_ant
    xjc libraries.activation
}

jar {
    manifest {
        attributes(
                'Main-Class': 'org.hibernate.Version',

                // BND Plugin instructions (for OSGi):
                'Import-Package': [
                         'javax.security.auth;resolution:=optional',
                         // Make javax.security.jacc optional and do not reference a version range (because that's what we used to do)
                        'javax.security.jacc;resolution:=optional;version=!',
                        // Make javax.validation optional and do not reference a version range (because that's what we used to do)
                        'javax.validation;resolution:=optional;version=!',
                        'javax.validation.constraints;resolution:=optional;version=!',
                        'javax.validation.groups;resolution:=optional;version=!',
                        'javax.validation.metadata;resolution:=optional;version=!',
                        // Make javax.enterprise optional and do not reference a version range (because that's what we used to do)
                        '!javax.enterprise*',
                        'javax.enterprise.context.spi;resolution:=optional;version=!',
                        'javax.enterprise.inject.spi;resolution:=optional;version=!',
                        // For JPA, we don't want to target the automatically generated range, but a specific version
                         "javax.persistence;version=\"${project.jpaVersion.osgiName}\"",
                         // optionals
                         'jakarta.persistence.spi;resolution:=optional',
                         '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.inject;resolution:=optional',
                         'net.bytebuddy.*;resolution:=optional',
                         'org.objectweb.jonas_tm;resolution:=optional',
                         'com.ibm.websphere.jtaextensions;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}\"",
                        // Temporarily support JTA 1.1 -- Karaf and other frameworks still
                        // use it.  Without this, the plugin generates [1.2,2).
                        'javax.transaction;version="[1.1,2)"',
                        // Also import every package referenced in the code
                        '*'
                ].join( ',' ),
                '-exportcontents': [
                        // Legacy resource packages containing XSDs that were traditionally not exported
                        "!org.hibernate.xsd.cfg",
                        "!org.hibernate.xsd.mapping",
                        // TODO: Uncomment once EntityManagerFactoryBuilderImpl no longer uses ClassLoaderServiceImpl.
                        //'org.hibernate.boot.registry.classloading.internal',
                        "*;version=${project.version}"
                ].join( ',' ),
        )
    }
}

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

sourceSets {
    main {
        java {
            srcDir project.jaxbTargetDir
        }
    }
    test {
        resources {
            // resources inherently exclude Java sources
            srcDir 'src/test/java'
        }
    }
}

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

xjc {
    outputDirectory = project.jaxbTargetDir

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


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

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

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

    doFirst {
        ext.bundlesTargetDir.mkdirs()
    }
}

processTestResources {
    dependsOn copyBundleResources
    duplicatesStrategy = DuplicatesStrategy.WARN
}

sourcesJar {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE

}

task testJar(type: Jar, dependsOn: testClasses) {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    archiveClassifier.set( '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" )
}

tasks.withType( Test.class ).each { test ->
    test.systemProperty 'file.encoding', 'utf-8'

    if ( gradle.ext.javaVersions.test.launcher.asInt() >= 9 ) {
        // See org.hibernate.boot.model.naming.NamingHelperTest.DefaultCharset.set
        test.jvmArgs( ['--add-opens', 'java.base/java.nio.charset=ALL-UNNAMED'] )
        // Weld needs this to generate proxies
        test.jvmArgs( ['--add-opens', 'java.base/java.security=ALL-UNNAMED'] )
        test.jvmArgs( ['--add-opens', 'java.base/java.lang=ALL-UNNAMED'] )
    }

    test.beforeTest { descriptor ->
        //println "Starting test: " + descriptor
    }

    // Allow to exclude specific tests
    if (project.hasProperty('excludeTests')) {
        test.filter {
            excludeTestsMatching project.property('excludeTests').toString()
        }
    }

    // widen the overall 6.0 filter to include various package-protected tests
    test.include 'org/hibernate/bytecode/internal/bytebuddy/**'
    test.include 'org/hibernate/event/service/internal/**'
    test.include 'org/hibernate/tool/schema/internal/**'
}