import org.apache.tools.ant.filters.FixCrLfFilter
import org.gradle.internal.os.OperatingSystem

import java.security.MessageDigest

apply plugin: 'com.android.library'

static def calcSha256(file) {
    def md = MessageDigest.getInstance("SHA-256")
    file.eachByte 4096, { bytes, size ->
        md.update(bytes, 0, size)
    }
    return md.digest().encodeHex()
}

ext {
    module_name = "EdXposed"
    jar_dest_dir = "${projectDir}/template_override/system/framework/"
    is_windows = OperatingSystem.current().isWindows()
    module_id = "riru_edxposed"
    authors = "solohsu, MlgmXyysd"

    riruModuleId = "edxp"

    moduleMinRiruApiVersion = 10
    moduleMinRiruVersionName = "v23.0"
    moduleMaxRiruApiVersion = 10
}

repositories {
    mavenLocal()
    jcenter()
    maven { url 'https://dl.bintray.com/rikkaw/Libraries' }
}

dependencies {
    implementation 'rikka.ndk:riru:10'
}

android {
    compileSdkVersion androidCompileSdkVersion.toInteger()
    defaultConfig {
        minSdkVersion androidMinSdkVersion.toInteger()
        targetSdkVersion androidTargetSdkVersion.toInteger()

        buildFeatures {
            prefab true
        }

        externalNativeBuild {
            cmake {
                abiFilters 'arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64'
                cppFlags "-std=c++17 -ffixed-x18 -Qunused-arguments -frtti -fomit-frame-pointer"
                cFlags "-std=gnu99 -ffixed-x18 -Qunused-arguments -frtti -fomit-frame-pointer"
                arguments "-DRIRU_MODULE_API_VERSION=$moduleMaxRiruApiVersion",
                        "-DRIRU_MODULE_VERSION=$rootProject.ext.versionCode",
                        "-DRIRU_MODULE_VERSION_NAME:STRING=\"$rootProject.ext.versionName\""
            }
        }
    }

    buildTypes {
        debug {
            externalNativeBuild {
                cmake {
                    cppFlags "-O0"
                    cFlags "-O0"
                }
            }
        }
        release {
            externalNativeBuild {
                cmake {
                    cppFlags "-fvisibility=hidden -fvisibility-inlines-hidden -O2 -s -Wno-unused-value -fomit-frame-pointer"
                    cFlags "-fvisibility=hidden -fvisibility-inlines-hidden -O2 -s -Wno-unused-value -fomit-frame-pointer"
                }
            }
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    externalNativeBuild {
        cmake {
            path "src/main/cpp/CMakeLists.txt"
        }
    }
    ndkVersion androidCompileNdkVersion
}

task cleanTemplate(type: Delete) {
    delete file(templateSystemx86Path)
}

afterEvaluate {

    android.libraryVariants.all { variant ->

        def variantCapped = variant.name.capitalize()
        def variantLowered = variant.name.toLowerCase()

        delete file(zipPathMagiskReleasePath)

        def prepareJarsTask = task("prepareJars${variantCapped}") {
            dependsOn cleanTemplate
            dependsOn tasks.getByPath(":dexmaker:copyDex${variantCapped}")
            dependsOn tasks.getByPath(":dalvikdx:copyDex${variantCapped}")
            dependsOn tasks.getByPath(":edxp-service:copyDex${variantCapped}")
            dependsOn tasks.getByPath(":edxp-yahfa:copyDex${variantCapped}")
            dependsOn tasks.getByPath(":edxp-sandhook:copyDex${variantCapped}")
        }

        def prepareMagiskFilesTask = task("prepareMagiskFiles${variantCapped}", type: Delete) {
            dependsOn prepareJarsTask, "assemble${variantCapped}"
            doFirst {
                copy {
                    from "${projectDir}/tpl/module.prop.tpl"
                    into templateRootPath
                    rename "module.prop.tpl", "module.prop"
                    expand(moduleId: module_id,
                            versionName: "$rootProject.ext.versionName",
                            versionCode: "$rootProject.ext.versionCode", authorList: authors,
                            apiCode: "$apiCode", minApi: "$moduleMinRiruApiVersion")
                    filter(FixCrLfFilter.class, eol: FixCrLfFilter.CrLf.newInstance("lf"))
                }
            }
            def libPathRelease = "${buildDir}/intermediates/cmake/${variantLowered}/obj"
            def exclude_list = ["riru.sh"]
            doLast {
                copy {
                    from "${projectDir}/template_override"
                    into zipPathMagiskReleasePath
                    exclude exclude_list
                }
                copy {
                    from "${projectDir}/template_override"
                    into zipPathMagiskReleasePath
                    include 'util_functions.sh'
                    filter { line ->
                        line.replaceAll('%%%RIRU_MODULE_ID%%%', riruModuleId)
                                .replaceAll('%%%RIRU_MIN_API_VERSION%%%', moduleMinRiruApiVersion.toString())
                                .replaceAll('%%%RIRU_MIN_VERSION_NAME%%%', moduleMinRiruVersionName)
                    }
                    filter(FixCrLfFilter.class,
                            eol: FixCrLfFilter.CrLf.newInstance("lf"))
                }
                copy {
                    include "libriru_edxp.so"
                    from "$libPathRelease/armeabi-v7a"
                    into "$zipPathMagiskReleasePath/system/lib"
                }
                copy {
                    include "libriru_edxp.so"
                    from "$libPathRelease/arm64-v8a"
                    into "$zipPathMagiskReleasePath/system/lib64"
                }
                copy {
                    include "libriru_edxp.so"
                    from "$libPathRelease/x86"
                    into "$zipPathMagiskReleasePath/system_x86/lib"
                }
                copy {
                    include "libriru_edxp.so"
                    from "$libPathRelease/x86_64"
                    into "$zipPathMagiskReleasePath/system_x86/lib64"
                }
                // generate sha1sum
                fileTree(zipPathMagiskReleasePath).matching {
                    exclude "README.md", "META-INF"
                }.visit { f ->
                    if (f.directory) return
                    file(f.file.path + ".s").text = calcSha256(f.file)
                }
            }
        }

        def zipTask = task("zip${variantCapped}", type: Zip) {
            dependsOn prepareMagiskFilesTask
            archiveName "${module_name}-${rootProject.ext.versionName}-${variantLowered}.zip"
            destinationDir file("$projectDir/release")
            from "$zipPathMagiskReleasePath"
        }

        task("push${variantCapped}", type: Exec) {
            dependsOn zipTask
            workingDir "${projectDir}/release"
            def commands = [android.adbExecutable, "push",
                            "${module_name}-${rootProject.ext.versionName}-${variantLowered}.zip",
                            "/data/local/tmp/"]
            if (is_windows) {
                commandLine 'cmd', '/c', commands.join(" ")
            } else {
                commandLine commands
            }
        }
        task("flash${variantCapped}", type: Exec) {
            dependsOn tasks.getByPath("push${variantCapped}")
            workingDir "${projectDir}/release"
            def commands = [android.adbExecutable, "shell", "su", "-c",
                            "magisk --install-module /data/local/tmp/${module_name}-${rootProject.ext.versionName}-${variantLowered}.zip"]
            if (is_windows) {
                commandLine 'cmd', '/c', commands.join(" ")
            } else {
                commandLine commands
            }
        }
        task("flashAndReboot${variantCapped}", type: Exec) {
            dependsOn tasks.getByPath("flash${variantCapped}")
            workingDir "${projectDir}/release"
            def commands = [android.adbExecutable, "shell", "reboot"]
            if (is_windows) {
                commandLine 'cmd', '/c', commands.join(" ")
            } else {
                commandLine commands
            }
        }
    }

}