//
//  Create a global expando class to hold global variables
def JatsGlobals = new Expando( noAndroidProjectSeen:0)

//
//  Create a hook before any of the projects are evaluated
gradle.projectsLoaded { g ->
    println 'Gradle Version          : ' + gradle.gradleVersion;
    println 'Gradle Home Dir         : ' + gradle.gradleHomeDir;
    println 'Gradle UserHome Dir     : ' + gradle.gradleUserHomeDir;
    println 'GBE_VERSION_NAME        : ' + gradle.rootProject.GBE_VERSION_NAME
    println 'GBE_VERSION_CODE        : ' + gradle.rootProject.GBE_VERSION_CODE

//  gradle.rootProject.properties.sort{it.key}.each { k,v->
//      println "   Root Property: $k = $v"
//  }

//  System.properties.sort{it.key}.each { k,v->
//      println "   System Property: $k = $v"
//  }
//
//  gradle.properties.sort{it.key}.each { k,v->
//      println "   Gradle Property: $k = $v"
//  }
}

//
//  Create a hook after all the projects have been evaluted
gradle.projectsEvaluated { g ->
//  JatsGlobals.properties.sort{it.key}.each { k,v->
//      println "JatsGlobals Property: $k = $v"
//  }

    //  Ensure that we have seen an android project with injected version information
    //
    if (JatsGlobals.noAndroidProjectSeen < 1)
    {
        logger.error ("ERROR: No android projects found")
        throw new GradleException('JATS Version Check failed')
    }
    logger.warn ('JATS version injection checked OK')
}

allprojects {

        afterEvaluate { project ->
        //logger.info "-------- allprojects::afterEvaluate"
        logger.info 'Project : ' + project.name
        JatsGlobals.setProperty('Project_' + project.name, 1);

        //---------------------------------------------------------------------
        // Configure RoboElectric for offline operation
        // Force here for all builds done under JATS
        project.tasks.withType(Test) {
            systemProperties.put('robolectric.offline', 'true')
        }

        //---------------------------------------------------------------------
        //  Remove network based repositories from the projects repositories
        //
        project.repositories
        {
            all 
            { 
                ArtifactRepository repo ->
                    def repoUrl = 'Repo has no URL'
                    def repoDir = ''
                    if (repo.hasProperty('url'))
                    {
                        repoUrl = repo.url.toString()
                        if (repoUrl.startsWith('file:/'))
                        {
                            repoDir = repoUrl
                        }
                    }
                    if (repo.name.startsWith('flatDir') && repo.hasProperty('dirs'))
                    {
                        repoDir = repo.dirs.toString()
                        repoUrl = repoDir
                    }

                    logger.info 'Repo:' + repo.name + "["+ repoUrl +"]" 

                    //  Allow
                    //      flatDir* - these are used for JATS dependencies
                    //      Repos that have a URL that starts with file:/ - these a local repos
                    if (repoDir.length() == 0)
                    {
                        logger.warn "WARNING: Repository: ${repo.name}. Url: ${repoUrl} removed. Only local repositories allowed"
                        remove repo
                    }
            }
        }


        //---------------------------------------------------------------------
        //  Ensure that the JATS generated Version information is being used by 
        //  the android projects to version the generated XML
        //
        logger.info "Global Version information"
        logger.info "  project.GBE_VERSION_NAME:" + project.GBE_VERSION_NAME
        logger.info "  project.GBE_VERSION_CODE:" + project.GBE_VERSION_CODE

        if (project.hasProperty('android'))
        {
            logger.info "defaultConfig Properties"
            logger.info "project.android.defaultConfig.versionName:" + project.android.defaultConfig.versionName
            logger.info "project.android.defaultConfig.versionCode:" + project.android.defaultConfig.versionCode

            if (project.GBE_VERSION_NAME != project.android.defaultConfig.versionName)
            {
                logger.error ("ERROR: Android defaultConfig. VersionName is not controlled by JATS")
                logger.error (" Project Version Name:" + project.GBE_VERSION_NAME)
                logger.error (" Default Version Name:" + project.android.defaultConfig.versionName)
                throw new GradleException('JATS Version Check failed')
            }

            if (Integer.parseInt(project.GBE_VERSION_CODE) != project.android.defaultConfig.versionCode)
            {
                logger.error ("ERROR: Android defaultConfig. VersionCode is not controlled by JATS")
                logger.error (" Project Version Code:" + project.GBE_VERSION_CODE)
                logger.error (" Default Version Code:" + project.android.defaultConfig.versionCode)
                throw new GradleException('JATS Version Check failed')
            }

            logger.warn (':' + project.name + ':JATS version injecting checked OK')
            JatsGlobals.noAndroidProjectSeen += 1
        }

        //
        //  Insert a dummy task so that we can perform testing from within JATS
        //  Tasks have stuff to do
        //      doFirst adds stuff to the beginning of the action chain
        //      doLast adds stuff to the end of the action chain
        task('JatsInfo') 
        {
            description 'A task used by jats for sanity testing'

            doFirst {
                logger.info "Global Version information"
                logger.info "  project.GBE_VERSION_NAME:" + getProject().GBE_VERSION_NAME
                logger.info "  project.GBE_VERSION_CODE:" + getProject().GBE_VERSION_CODE
            }
        }
    }
}