// task to generate the dependency graph of the project
// taken from https://github.com/JakeWharton/SdkSearch/blob/master/gradle/projectDependencyGraph.gradle
// with changes to support AGP 4.1
task projectDependencyGraph {
    doLast {
        def dot = new File(rootProject.projectDir, 'dependency-graph/project.dot')
        dot.parentFile.mkdirs()
        dot.delete()

        dot << 'digraph {\n'
        dot << "  graph [label=\"${rootProject.name}\\n \",labelloc=t,fontsize=30,ranksep=1.4];\n"
        dot << '  node [style=filled, fillcolor="#bbbbbb"];\n'
        dot << '  rankdir=TB;\n'

        // the root of the project, typically the app module
        def rootProjects = []
        def queue = [rootProject]
        while (!queue.isEmpty()) {
            def project = queue.remove(0)
            rootProjects.add(project)
            queue.addAll(project.childProjects.values())
        }

        def projects = new LinkedHashSet<Project>()
        def dependencies = new LinkedHashMap<Tuple2<Project, Project>, List<String>>()
        def multiplatformProjects = []
        def jsProjects = []
        def androidProjects = []
        def javaProjects = []

        queue = [rootProject] //begin with the root project
        while (!queue.isEmpty()) {
            def project = queue.remove(0)
            queue.addAll(project.childProjects.values()) //add its children to the queue for the next level of the tree

            if (project.plugins.hasPlugin('org.jetbrains.kotlin.multiplatform')) {
                multiplatformProjects.add(project)
            }
            if (project.plugins.hasPlugin('org.jetbrains.kotlin.js')) {
                jsProjects.add(project)
            }
            if (project.plugins.hasPlugin('com.android.library') || project.plugins.hasPlugin('com.android.application')) {
                androidProjects.add(project)
            }
            if (project.plugins.hasPlugin('java-library') || project.plugins.hasPlugin('java')) {
                javaProjects.add(project)
            }

            project.configurations.all { config ->
            }

            project.configurations.findAll { config ->
                // Avoid Android modules pointing to themselves on AGP 4.1+
                // https://developer.android.com/studio/releases/gradle-plugin?hl=de#library-unit-tests
                !(isAndroid(project) && isTest(config))
            }.each { config ->
                //for each of the current module's dependencies
                config.dependencies
                        .withType(ProjectDependency)
                        .collect { it.dependencyProject }
                        .each { dependency ->

                            if (!config.name.toLowerCase().endsWith('debugimplementation')) {
                                projects.add(project)
                                projects.add(dependency)
                                rootProjects.remove(dependency)

                                def graphKey = new Tuple2<Project, Project>(project, dependency)
                                def traits = dependencies.computeIfAbsent(graphKey) { new ArrayList<String>() }

                                if (config.name.toLowerCase().endsWith('implementation')) {
                                    traits.add('style=solid')
                                }
                            }
                        }
            }
        }

        projects = projects.sort { it.path }

        dot << '\n  # Projects\n\n'
        for (project in projects) {
            def traits = []

            if (rootProjects.contains(project)) {
                traits.add('shape=box')
            }

            if (multiplatformProjects.contains(project)) {
                traits.add('fillcolor="#ffd2b3"')
            } else if (jsProjects.contains(project)) {
                traits.add('fillcolor="#ffffba"')
            } else if (androidProjects.contains(project)) {
                traits.add('fillcolor="#dbd1c7"')
            } else if (javaProjects.contains(project)) {
                traits.add('fillcolor="#ffb3ba"')
            } else {
                traits.add('fillcolor="#eeeeee"')
            }

            dot << "  \"${project.path}\" [${traits.join(", ")}];\n"
        }

        dot << '\n  {rank = same;'
        for (project in projects) {
            if (rootProjects.contains(project)) {
                dot << " \"${project.path}\";"
            }
        }
        dot << '}\n'

        dot << '\n  # Dependencies\n\n'
        dependencies.forEach { key, traits ->
            dot << "  \"${key.first.path}\" -> \"${key.second.path}\""
            if (!traits.isEmpty()) {
                dot << " [${traits.join(", ")}]"
            }
            dot << '\n'
        }

        dot << '}\n'

        def p = 'dot -Tpng -O project.dot'.execute([], dot.parentFile)
        p.waitFor()
        if (p.exitValue() != 0) {
            throw new RuntimeException(p.errorStream.text)
        }

        println("Project module dependency graph created at ${dot.absolutePath}.png")
    }
}

static def isAndroid(Project project) {
    project.plugins.hasPlugin('com.android.library') || project.plugins.hasPlugin('com.android.application')
}

static def isTest(Configuration config) {
    config.name.toLowerCase().contains('androidtest') || config.name.toLowerCase().contains('unittest')
}