apply plugin: AndroidFilterPlugin

class AndroidFilterPlugin implements Plugin<Project> {
    void apply(Project project) {
        project.afterEvaluate {
            if (project.plugins.hasPlugin("com.android.application")) {
                def android = project.extensions.getByName("android")
                android.applicationVariants.all { def variant ->
                    def variantData = variant.getVariantData()
                    def scope = variantData.scope

                    File filterFile = project.file('filter.properties')
                    boolean hasChanged = true

                    String md5 = java.security.MessageDigest.getInstance("MD5").digest(GFileUtils.readFile(filterFile).bytes).encodeHex().toString()
                    File filterMD5File = project.file("${project.buildDir}/filter-md5/${variant.dirName}/md5.txt")
                    if (filterMD5File.exists()) {
                        String oldMd5 = GFileUtils.readFile(filterMD5File)
                        if (md5 != null && md5.equals(oldMd5)) {
                            hasChanged = false
                        } else {
                            GFileUtils.writeFile(md5, filterMD5File)
                        }
                    } else {
                        GFileUtils.writeFile(md5, filterMD5File)
                    }

                    def filterTaskName = scope.getTaskName("filter")
                    def filterTask = project.task(filterTaskName)
                    filterTask.setGroup("filter")


                    if (project.file('filter.properties').exists()) {
                        def compileJavaWithJavacTask = project.tasks.findByName("compile${variant.name.capitalize()}JavaWithJavac")
                        def filterAndroidSourceTaskName = scope.getTaskName("filter", "AndroidSources")
                        Properties properties = new Properties()
                        properties.load(new FileInputStream(project.file('filter.properties')))
                        def filterAndroidSourceTask = project.task(type: Copy, filterAndroidSourceTaskName) {
                            GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-sources"))
                            from(compileJavaWithJavacTask.source) {
                                filesMatching('**/*.java') {
                                    filter(org.apache.tools.ant.filters.ReplaceTokens, tokens: properties, beginToken: '${', endToken: '}')
                                }
                            }
                            into "${project.buildDir}/generated-android-sources"
                        }
                        filterAndroidSourceTask.setGroup("filter")

                        def compileJavaWithJavacTaskDependsOn = new HashSet<>()
                        compileJavaWithJavacTaskDependsOn.addAll(compileJavaWithJavacTask.getDependsOn())
                        filterAndroidSourceTask.dependsOn compileJavaWithJavacTaskDependsOn
                        compileJavaWithJavacTask.dependsOn filterAndroidSourceTask
                        filterTask.dependsOn filterAndroidSourceTask
                        compileJavaWithJavacTask.doFirst {
                            compileJavaWithJavacTask.setSource(filterAndroidSourceTask.outputs.files)
                        }
                        compileJavaWithJavacTask.doLast {
                            GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-sources"))
                        }
                        if (hasChanged) {
                            compileJavaWithJavacTask.outputs.upToDateWhen { false }
                        }
                    }

                    if (project.file('filter.properties').exists()) {
                        def processJavaResourcesTask = project.tasks.findByName("process${variant.name.capitalize()}JavaRes")
                        def filterJavaResourcesTaskName = scope.getTaskName("filter", "JavaResources")
                        def filterJavaResourcesTask = project.task(filterJavaResourcesTaskName)
                        filterJavaResourcesTask.setGroup("filter")
                        filterJavaResourcesTask.doLast {
                            Properties properties = new Properties()
                            properties.load(new FileInputStream(project.file('filter.properties')))

                            GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-java-resources"))
                            project.copy {
                                from(processJavaResourcesTask.destinationDir) {
                                    filesMatching('**') {
                                        filter(org.apache.tools.ant.filters.ReplaceTokens, tokens: properties, beginToken: '${', endToken: '}')
                                    }
                                }
                                into("${project.buildDir}/generated-java-resources/")
                            }
                            project.copy {
                                GFileUtils.deleteDirectory(processJavaResourcesTask.destinationDir)
                                from("${project.buildDir}/generated-java-resources/")
                                into(processJavaResourcesTask.destinationDir)
                            }
                            GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-java-resources"))
                        }

                        filterJavaResourcesTask.dependsOn processJavaResourcesTask
                        processJavaResourcesTask.finalizedBy filterJavaResourcesTask
                        filterTask.dependsOn filterJavaResourcesTask
                        if (hasChanged) {
                            processJavaResourcesTask.outputs.upToDateWhen { false }
                        }
                    }

                    if (project.file('filter.properties').exists()) {
                        def mergeAssetsTask = project.tasks.findByName("merge${variant.name.capitalize()}Assets")
                        def filterAssetsTaskName = scope.getTaskName("filter", "Assets")
                        def filterAssetsTask = project.task(filterAssetsTaskName)
                        filterAssetsTask.setGroup("filter")
                        filterAssetsTask.doLast {
                            Properties properties = new Properties()
                            properties.load(new FileInputStream(project.file('filter.properties')))

                            GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-assets"))
                            project.copy {
                                from(mergeAssetsTask.outputDir) {
                                    filesMatching('**') {
                                        filter(org.apache.tools.ant.filters.ReplaceTokens, tokens: properties, beginToken: '${', endToken: '}')
                                    }
                                }
                                into("${project.buildDir}/generated-android-assets/")
                            }
                            project.copy {
                                GFileUtils.deleteDirectory(mergeAssetsTask.outputDir)
                                from("${project.buildDir}/generated-android-assets/")
                                into(mergeAssetsTask.outputDir)
                            }
                            GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-assets"))
                        }

                        filterAssetsTask.dependsOn mergeAssetsTask
                        mergeAssetsTask.finalizedBy filterAssetsTask
                        filterTask.dependsOn filterAssetsTask
                        if (hasChanged) {
                            mergeAssetsTask.outputs.upToDateWhen { false }
                        }
                    }

                    if (project.file('filter.properties').exists()) {
                        def mergeResourcesTask = project.tasks.findByName("merge${variant.name.capitalize()}Resources")
                        def filterAndroidResourcesTaskName = scope.getTaskName("filter", "AndroidResources")
                        def filterAndroidResourcesTask = project.task(filterAndroidResourcesTaskName)
                        filterAndroidResourcesTask.setGroup("filter")
                        filterAndroidResourcesTask.doLast {
                            Properties properties = new Properties()
                            properties.load(new FileInputStream(project.file('filter.properties')))

                            GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-resources"))
                            project.copy {
                                from(mergeResourcesTask.outputDir) {
                                    filesMatching('**') {
                                        filter(org.apache.tools.ant.filters.ReplaceTokens, tokens: properties, beginToken: '${', endToken: '}')
                                    }
                                }
                                into("${project.buildDir}/generated-android-resources/")
                            }
                            project.copy {
                                GFileUtils.deleteDirectory(mergeResourcesTask.outputDir)
                                from("${project.buildDir}/generated-android-resources/")
                                into(mergeResourcesTask.outputDir)
                            }
                            GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-resources"))
                        }

                        filterAndroidResourcesTask.dependsOn mergeResourcesTask
                        mergeResourcesTask.finalizedBy filterAndroidResourcesTask
                        filterTask.dependsOn filterAndroidResourcesTask
                        if (hasChanged) {
                            mergeResourcesTask.outputs.upToDateWhen { false }
                        }
                    }

                    if (project.file('filter.properties').exists()) {
                        def processManifestTask = project.tasks.findByName("process${variant.name.capitalize()}Manifest")

                        def filterManifestTaskName = scope.getTaskName("filter", "Manifest")
                        def filterManifestTask = project.task(filterManifestTaskName)
                        filterManifestTask.setGroup("filter")
                        filterManifestTask.doLast {
                            File manifestOutputFile = null
                            File instantRunManifestOutputFile = null
                            try {
                                manifestOutputFile = processManifestTask.getManifestOutputFile()
                            } catch (Throwable e) {
                                try {
                                    manifestOutputFile = new File(processManifestTask.getManifestOutputDirectory(), "AndroidManifest.xml")
                                } catch (Throwable e1) {
                                    manifestOutputFile = null
                                }
                            }
                            try {
                                instantRunManifestOutputFile = processManifestTask.getInstantRunManifestOutputFile()
                            } catch (Throwable e) {
                                try {
                                    instantRunManifestOutputFile = new File(processManifestTask.getInstantRunManifestOutputDirectory(), "AndroidManifest.xml")
                                } catch (Throwable e1) {
                                    instantRunManifestOutputFile = null
                                }
                            }
                            Properties properties = new Properties()
                            properties.load(new FileInputStream(project.file('filter.properties')))

                            if (manifestOutputFile && manifestOutputFile.exists()) {
                                GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-manifests"))
                                project.copy {
                                    from(manifestOutputFile.getParentFile()) {
                                        filesMatching('**') {
                                            filter(org.apache.tools.ant.filters.ReplaceTokens, tokens: properties, beginToken: '#{', endToken: '}')
                                        }
                                    }
                                    into("${project.buildDir}/generated-android-manifests/")
                                }
                                project.copy {
                                    GFileUtils.deleteQuietly(manifestOutputFile)
                                    from("${project.buildDir}/generated-android-manifests/")
                                    into(manifestOutputFile.getParentFile())
                                }
                                GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-manifests"))
                            }
                            if (instantRunManifestOutputFile && instantRunManifestOutputFile.exists()) {
                                GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-manifests"))
                                project.copy {
                                    from(instantRunManifestOutputFile.getParentFile()) {
                                        filesMatching('**') {
                                            filter(org.apache.tools.ant.filters.ReplaceTokens, tokens: properties, beginToken: '@{', endToken: '}')
                                        }
                                    }
                                    into("${project.buildDir}/generated-android-manifests/")
                                }
                                project.copy {
                                    GFileUtils.deleteQuietly(instantRunManifestOutputFile)
                                    from("${project.buildDir}/generated-android-manifests/")
                                    into(instantRunManifestOutputFile.getParentFile())
                                }
                                GFileUtils.deleteDirectory(project.file("${project.buildDir}/generated-android-manifests"))
                            }
                        }

                        filterManifestTask.dependsOn processManifestTask
                        processManifestTask.finalizedBy filterManifestTask
                        filterTask.dependsOn filterManifestTask
                        if (hasChanged) {
                            processManifestTask.outputs.upToDateWhen { false }
                        }
                    }
                }
            }
        }
    }