build.gradle.sample

import java.text.SimpleDateFormat

buildscript {
    ext {
        gradleVersion = '8.12'
        teswizVersion = '1.0.12'
    }
    repositories {
        mavenLocal()
    }
}

plugins {
    id "java"
    id "idea"
    id "maven-publish"
}

version '0.0.1'
project.ext.log4jProperties = "src/test/resources/log4j2.properties"

java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

repositories {
    mavenLocal()
    flatDir {
        dirs 'libs'
    }
    mavenCentral()
    maven {
        url 'https://jitpack.io'
    }
}

configurations {
    cucumberRuntime {
        extendsFrom testImplementation
    }
}

// Define the libs directory in the project root
ext.libsDir = file("$projectDir/libs")

def downloadDependency(String name, String type, Map<String, String> params) {
    if (!libsDir.exists()) {
        libsDir.mkdirs()
    }

    println "Download dependency: ${name} from ${type}"
    def jarFile = new File(libsDir, "${name}-${params.version}.jar")
    if (jarFile.exists()) {
        println "\tDependency $name already exists at: $jarFile. No need to redownload it"
        return jarFile
    }

    def jarUrl
    if (type == "github") {
        println "\tFetching latest GitHub release information for ${params.repoUrl}..."
        def jsonResponse = new URL(params.repoUrl).text
        def jsonSlurper = new groovy.json.JsonSlurper()
        def releaseInfo = jsonSlurper.parseText(jsonResponse)

        // Ensure assets field is a list and each asset is a Map
        def assets = releaseInfo.assets
        if (!(assets instanceof List)) {
            throw new GradleException("Assets field is not a list: $assets")
        }

        def jarAsset = releaseInfo.assets.find { it.name.matches(/${name}-\d+\.\d+\.\d+\.jar/) }
        if (!jarAsset) {
            throw new GradleException("No ${name} JAR file found in the latest GitHub release.")
        }
        jarUrl = jarAsset.browser_download_url
    } else if (type == "jitpack") {
        jarUrl = "https://jitpack.io/${params.group.replace('.', '/')}/${params.artifact}/${params.version}/${params.artifact}-${params.version}${params.fileNameSuffix}.jar"
    } else {
        throw new GradleException("Unknown type: $type")
    }

    println "\tDownloading ${name} JAR from ${jarUrl}"
    def downloadCommand
    if (System.getProperty("os.name").toLowerCase().contains("win")) {
        downloadCommand = ["cmd", "/c", "curl", "-o", jarFile.absolutePath, jarUrl]
    } else {
        downloadCommand = ["wget", "-O", jarFile.absolutePath, jarUrl]
    }
    // Explicitly convert all elements to String
    downloadCommand = downloadCommand.collect { it.toString() }

    println "\tDownloading using command: ${downloadCommand}"

    def process = new ProcessBuilder(downloadCommand).redirectErrorStream(true).start()
    process.inputStream.eachLine { println it }
    process.waitFor()

    if (process.exitValue() != 0) {
        throw new GradleException("Failed to download ${name} JAR.")
    }

    println "${name} JAR downloaded to $jarFile"
    return jarFile
}

// Define a custom task to download dependencies
task downloadDependencies {
    doLast {
        println "Downloading required dependencies..."
        def dependencies = [
                [
                        name  : "teswiz",
                        type  : "github",
                        params: [
                                repoUrl: "https://api.github.com/repos/znsio/teswiz/releases/latest",
                                version : "$project.teswizVersion"                        ]
                ]
        ]

        println "\n---------------------------------------------"

        dependencies.each { dep ->
            println "Processing dependency: ${dep.name}"
            downloadDependency(dep.name, dep.type, dep.params)
            println "\n---------------------------------------------"

        }
    }
}

// Ensure dependencies are downloaded before compiling
tasks.compileJava {
    dependsOn downloadDependencies
}

// Ensure dependencies are downloaded before compiling
tasks.compileJava {
    dependsOn downloadDependencies
    options.encoding = "UTF-8"
}

dependencies {
    implementation fileTree(dir: "$project.projectDir/libs", include: ['*.jar'])
}

static def getCurrentDatestamp() {
    Date today = new Date()
    SimpleDateFormat df = new SimpleDateFormat("MM-dd-yyyy")
    return df.format(today)
}

static def getMonth() {
    Date today = new Date()
    SimpleDateFormat df = new SimpleDateFormat("MMM-yyyy")
    return df.format(today)
}

static def getCurrentTimestamp() {
    Date today = new Date()
    SimpleDateFormat df = new SimpleDateFormat("HH-mm-ss")
    return df.format(today)
}

project.ext.logDir = "./target/" + getMonth() + "/" + getCurrentDatestamp() + "/" + getCurrentTimestamp()

def copyRpPropertiesIfMissing() {
    def rpFile = file('src/test/resources/reportportal.properties')
    def rpTemplateFile = file('src/test/resources/reportportal.properties.template')

    if (!rpFile.exists() && rpTemplateFile.exists()) {
        println "Copying $rpTemplateFile to $rpFile"
        rpFile.text = rpTemplateFile.text
    } else if (!rpTemplateFile.exists()) {
        println "$rpTemplateFile does not exist. Please create it."
    } else {
        println "$rpFile already exists."
    }
    System.setProperty("reportportal.properties.file", rpFile.absolutePath)
}

task copyRpPropertiesIfMissing {
    doLast {
        copyRpPropertiesIfMissing()
    }
}

gradle.taskGraph.whenReady { taskGraph ->
    if (taskGraph.hasTask(':build') || taskGraph.hasTask(':run')) {
        copyRpPropertiesIfMissing()
    }
}

tasks.register('run', JavaExec) {
    doFirst {
        println "Using LOG_DIR: ${project.logDir}"
        System.setProperty "LOG_DIR", "${project.logDir}"
        environment "APPLITOOLS_LOG_DIR", "${project.logDir}/applitools_logs"

        def configFile = System.getenv("CONFIG")
        if (null == configFile || !file(configFile).exists()) {
            println("CONFIG file not provided, or does not exist")
            println("Run the test by providing the CONFIG file not provided, or does not exist")
            assert file(configFile).exists()
        }

        def hostname = InetAddress.getLocalHost().getHostName()
        println "Hostname: $hostname"
        def ipAddress = InetAddress.getAllByName(hostname)
                .find { it.hostAddress.startsWith("192") || it.hostAddress.startsWith("172") || it.hostAddress.startsWith("10") }
                ?.hostAddress
        println "IP Address of this machine: $ipAddress"
        if (null == ipAddress) {
            println "Unable to get local IP address. NOT updating BASE_URL and REMOTE_WEBDRIVER_GRID_HOST_NAME"
        } else {
//            println "Updating BASE_URL ('http://$ipAddress:3000') and REMOTE_WEBDRIVER_GRID_HOST_NAME ('$ipAddress')"
//            environment "BASE_URL", "http://$ipAddress:3000"
            environment "REMOTE_WEBDRIVER_GRID_HOST_NAME", "$ipAddress"
        }

//      You can also specify which config file to use based on the value of RUN_IN_CI as shown below
//
//        def isRunInCI = Boolean.parseBoolean(System.getenv("RUN_IN_CI"))
//        println "isRunningInCI: $isRunInCI"
//        def configFile = isRunInCI
//                ? "./configs/theapp/theapp_pcloudy_config.properties"
//                : "./configs/theapp/theapp_local_android_config.properties"
//        configFile = System.getenv("CONFIG") ? System.getenv("CONFIG") : configFile

        systemProperties = System.properties as Map<String, ?>
        def runnerArgs = [
                "${configFile}",
                "com/znsio/teswiz/steps",
                "./src/test/resources/com/znsio/teswiz/features"
        ]
        args = runnerArgs

        println("Debug mode: " + System.getProperty('debug', 'false'))
        // attach debugger
        // example: ./gradlew run -Ddebug=true
        if (System.getProperty('debug', 'false') == 'true') {
            println("In debug mode")
            jvmArgs '-Xdebug', '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,' +
                    'address=*:5005'
        }
    }
    mainClass = "com.znsio.teswiz.runner.Runner"
    classpath = configurations.cucumberRuntime + sourceSets.main.output + sourceSets.test.output
}

wrapper {
    gradleVersion = project.gradleVersion // version from gradle.properties
}

tasks.withType(JavaCompile).configureEach {
    options.compilerArgs += ['--release', '17']
}

tasks.withType(JavaExec).configureEach {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
}