apply plugin: 'cpp'

String bulletSrcPath = bulletFolder + '/src'

if (!hasProperty('mainClass')) {
    ext.mainClass = ''
}

dependencies {
    compile project(':jme3-bullet')
}

// Defines created C++ libraries
libraries {
    bulletjme {
    }
    all {
        binaries.all {
            if (toolChain in VisualCpp) {
                cppCompiler.args "/I${org.gradle.internal.jvm.Jvm.current().javaHome}\\include"
            } else{
                cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include"
            }

            if (targetPlatform.operatingSystem.name == "osx") {
                cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include/darwin"
            } else if (targetPlatform.operatingSystem.name == "linux") {
                cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include/linux"
                cppCompiler.args "-fPIC"
                cppCompiler.args "-fpermissive"
//                cppCompiler.args "-static-libgcc"
//                cppCompiler.args "-static-libstdc++"
//                linker.args "-static-libgcc"
//                linker.args "-static-libstdc++"
            } else if (targetPlatform.operatingSystem.name == "windows") {
                if (toolChain in Gcc) {
                    if (toolChain.name.startsWith('mingw')) {
                        cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include/linux"
                    } else {
                        cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include/win32"
                    }
                    cppCompiler.args "-fpermissive"
                    cppCompiler.args "-static"
                    linker.args "-static"
                }
                else if (toolChain in VisualCpp) {
                    cppCompiler.args "/I${org.gradle.internal.jvm.Jvm.current().javaHome}\\include\\win32"
                }
                cppCompiler.define('WIN32')
//                linker.args 'Shlwapi.lib', 'Advapi32.lib'
            }
        }
    }
}

// C++ sources for binary compilation
sources {
    bulletjme {
        cpp {
            source {
                srcDir 'src/native/cpp'
                srcDir bulletSrcPath
                exclude 'BulletMultiThreaded/GpuSoftBodySolvers/**'
                include '**/*.cpp'
            }
            exportedHeaders {
                srcDir 'src/native/cpp'
                srcDir bulletSrcPath
                include '**/*.h'
            }
        }
    }
}

// Java source sets for IDE acces and source jar bundling / mavenization
sourceSets {
    main {
        java {
            srcDir 'src/native/cpp'
        }
    }
}

// Set of target platforms, will be available based on build system
model {

    toolChains {
        gcc(Gcc)
        mingw_x86(Gcc) {
            eachPlatform() {
                cCompiler.executable "i686-w64-mingw32-gcc"
                cppCompiler.executable "i686-w64-mingw32-g++"
                linker.executable "i686-w64-mingw32-g++"
                assembler.executable "i686-w64-mingw32-g++"
                staticLibArchiver.executable "i686-w64-mingw32-gcc-ar"
            }
            target("windows_x86")
        }
        mingw_x86_64(Gcc) {
            eachPlatform() {
                cCompiler.executable "x86_64-w64-mingw32-gcc"
                cppCompiler.executable "x86_64-w64-mingw32-g++"
                linker.executable "x86_64-w64-mingw32-g++"
                assembler.executable "x86_64-w64-mingw32-g++"
                staticLibArchiver.executable "x86_64-w64-mingw32-gcc-ar"
            }
            target("windows_x86_64")
        }
    }

    platforms{
//    osx_universal { // TODO: universal binary doesn't work?
//        architecture 'x86_64'
//        architecture 'x86'
//        operatingSystem 'osx'
//    }
        osx_x86 {
            architecture "x86"
            operatingSystem "osx"
        }
        osx_x86_64 {
            architecture "x86_64"
            operatingSystem "osx"
        }
        linux_x86 {
            architecture "x86"
            operatingSystem "linux"
        }
        linux_x86_64 {
            architecture "x86_64"
            operatingSystem "linux"
        }
        windows_x86 {
            architecture "x86"
            operatingSystem "windows"
        }
        windows_x86_64 {
            architecture "x86_64"
            operatingSystem "windows"
        }
    }
}

// Download bullet if not available
task downloadBullet(type: MyDownload) {
    sourceUrl = bulletUrl
    target = file(bulletZipFile)
}

// Unzip bullet if not available
task unzipBullet(type: Copy) {
    def zipFile = file(bulletZipFile)
    def outputDir = file(".")

    from zipTree(zipFile)
    into outputDir
}
unzipBullet.dependsOn {
    def zipFilePath = project.projectDir.absolutePath + File.separator + bulletZipFile
    def zipFile = new File(zipFilePath)
    if (!zipFile.exists()) {
        downloadBullet
    }
}

compileJava.dependsOn {
    if(buildNativeProjects=="true"){
        def bulletUnzipDir = new File(project.projectDir.absolutePath + File.separator + bulletFolder)
        if (!bulletUnzipDir.isDirectory()) {
            unzipBullet
        }
    }
}

binaries.withType(StaticLibraryBinarySpec) {
    buildable = false
}

// Adds all available binaries to java jar task
binaries.withType(SharedLibraryBinary) { binary ->
    // For all binaries that can't be built on the current system
    if(buildNativeProjects!="true"){
        buildable = false;
    }
    if (!buildable) {
        //Get from libs folder if no fresh build is available in the build folder and add to jar file
        if(!binary.tasks.outputFile.get(0).exists()){
            def fileName = binary.tasks.outputFile.get(0).getName();
            def precompiledFile = new File(project.projectDir.absolutePath + File.separator + "libs" + File.separator + "native" + File.separator + "${targetPlatform.operatingSystem.name}" + File.separator + "${targetPlatform.architecture.name}" + File.separator + "${fileName}")
            if(precompiledFile.exists()){
                jar.into("native/${targetPlatform.operatingSystem.name}/${targetPlatform.architecture.name}") { from precompiledFile }
            }
            return
        } else{
            // Add binary to jar file if the binary exists in the build folder already,
            // e.g. when the build of jme3-bullet-native has been run on a virtual box
            // and the project hasn't been cleaned yet.
            jar.into("native/${targetPlatform.operatingSystem.name}/${targetPlatform.architecture.name}") { from binary.tasks.outputFile }
            return
        }
    }

    // For all binaries that can be built on the current system
    def builderTask = binary.tasks
    // Add output to jar file
    jar.into("native/${targetPlatform.operatingSystem.name}/${targetPlatform.architecture.name}") { from builderTask.outputFile }
    // Add depend on build
    jar.dependsOn builderTask
    // Add output to libs folder
    task "copyBinaryToLibs${targetPlatform}"(type: Copy, dependsOn: builderTask) {
        from builderTask.outputFile
        into "libs/native/${targetPlatform.operatingSystem.name}/${targetPlatform.architecture.name}"
    }
    // Add depend on copy
    jar.dependsOn("copyBinaryToLibs${targetPlatform}")
}

// Helper class to wrap ant dowload task
class MyDownload extends DefaultTask {
    @Input
    String sourceUrl

    @OutputFile
    File target

    @TaskAction
    void download() {
       ant.get(src: sourceUrl, dest: target)
    }
}