build.gradle

/*
 * Bearsampp Module Node.js - Gradle Build (Bruno-style)
 *
 * This is a 100% Gradle build configuration for the Node.js module.
 * It handles downloading, extracting, and packaging Node.js releases.
 *
 * VERSION RESOLUTION STRATEGY:
 *   1. Remote modules-untouched nodejs.properties (primary source)
 *      URL: https://github.com/Bearsampp/modules-untouched/blob/main/modules/nodejs.properties
 *   2. Standard URL format construction (fallback)
 *
 * DOCUMENTATION:
 *   All build documentation is located in /.gradle-docs/
 *   See /.gradle-docs/README.md for complete documentation index
 *
 * Usage:
 *   gradle tasks                              - List all available tasks
 *   gradle release -PbundleVersion=24.6.0     - Build release for specific version
 *   gradle releaseAll                         - Build all versions
 *   gradle clean                              - Clean build artifacts
 *   gradle info                               - Display build information
 *   gradle verify                             - Verify build environment
 *   gradle listVersions                       - List available versions
 *   gradle listReleases                       - List releases from modules-untouched
 *   gradle checkModulesUntouched              - Check modules-untouched integration
 */

plugins {
    id 'base'
}

// ============================================================================
// PROJECT CONFIGURATION
// ============================================================================

// Load build properties
def buildProps = new Properties()
file('build.properties').withInputStream { buildProps.load(it) }

// Project information
group = 'com.bearsampp.modules'
version = buildProps.getProperty('bundle.release', '1.0.0')
description = "Bearsampp Module - ${buildProps.getProperty('bundle.name', 'nodejs')}"

// Define project paths
ext {
    projectBasedir = projectDir.absolutePath
    rootDir = projectDir.parent
    devPath = file("${rootDir}/dev").absolutePath

    // Bundle properties from build.properties
    bundleName = buildProps.getProperty('bundle.name', 'nodejs')
    bundleRelease = buildProps.getProperty('bundle.release', '1.0.0')
    bundleType = buildProps.getProperty('bundle.type', 'bins')
    bundleFormat = buildProps.getProperty('bundle.format', '7z')

    // Build paths - with configurable base path
    def buildPathFromProps = buildProps.getProperty('build.path', '').trim()
    def buildPathFromEnv = System.getenv('BEARSAMPP_BUILD_PATH') ?: ''
    def defaultBuildPath = "${rootDir}/bearsampp-build"

    buildBasePath = buildPathFromProps ?: (buildPathFromEnv ?: defaultBuildPath)

    // Shared bearsampp-build/tmp structure
    buildTmpPath = file("${buildBasePath}/tmp").absolutePath
    bundleTmpBuildPath = file("${buildTmpPath}/bundles_build/${bundleType}/${bundleName}").absolutePath
    bundleTmpPrepPath = file("${buildTmpPath}/bundles_prep/${bundleType}/${bundleName}").absolutePath
    bundleTmpSrcPath = file("${buildTmpPath}/bundles_src").absolutePath

    // Download and extract paths
    bundleTmpDownloadPath = file("${buildTmpPath}/downloads/${bundleName}").absolutePath
    bundleTmpExtractPath = file("${buildTmpPath}/extract/${bundleName}").absolutePath
}

// Align with Bruno: place Gradle's own buildDir under the shared bearsampp-build tmp tree
// This prevents creating a local ./build folder in the repository
buildDir = file("${buildBasePath}/tmp/gradle/${bundleName}")

// Verify dev path exists
if (!file(ext.devPath).exists()) {
    throw new GradleException("Dev path not found: ${ext.devPath}. Please ensure the 'dev' project exists in ${ext.rootDir}")
}

// Repositories
repositories {
    mavenCentral()
}

// ============================================================================
// HELPER FUNCTIONS
// ============================================================================

// Function to fetch nodejs.properties from modules-untouched repository
def fetchModulesUntouchedProperties() {
    def propsUrl = "https://raw.githubusercontent.com/Bearsampp/modules-untouched/main/modules/nodejs.properties"

    println "Fetching nodejs.properties from modules-untouched repository..."
    println "  URL: ${propsUrl}"

    def tempFile = file("${bundleTmpDownloadPath}/nodejs-untouched.properties")
    tempFile.parentFile.mkdirs()

    try {
        new URL(propsUrl).withInputStream { input ->
            tempFile.withOutputStream { output ->
                output << input
            }
        }

        def props = new Properties()
        tempFile.withInputStream { props.load(it) }

        println "  ✓ Successfully loaded ${props.size()} versions from modules-untouched"
        return props
    } catch (Exception e) {
        println "  ✗ Warning: Could not fetch nodejs.properties from modules-untouched: ${e.message}"
        println "  Will fall back to standard URL format if needed"
        return null
    }
}

// Function to download from modules-untouched repository (or fallback)
def downloadFromModulesUntouched(String version, File destDir) {
    println "Checking modules-untouched repository..."

    def untouchedProps = fetchModulesUntouchedProperties()
    def untouchedUrl = null

    if (untouchedProps) {
        untouchedUrl = untouchedProps.getProperty(version)
        if (untouchedUrl) {
            println "Found version ${version} in modules-untouched nodejs.properties"
            println "Downloading from:"
            println "  ${untouchedUrl}"
        } else {
            println "Version ${version} not found in modules-untouched nodejs.properties"
            println "Attempting to construct URL based on standard format..."
            // Windows x64 standard URL (fallback) — aligns with Bearsampp packaging
            untouchedUrl = "https://github.com/Bearsampp/modules-untouched/releases/download/nodejs-${version}/nodejs-${version}-win-x64.7z"
            println "  ${untouchedUrl}"
        }
    } else {
        println "Could not fetch nodejs.properties, using standard URL format..."
        untouchedUrl = "https://github.com/Bearsampp/modules-untouched/releases/download/nodejs-${version}/nodejs-${version}-win-x64.7z"
        println "  ${untouchedUrl}"
    }

    // Determine filename and ensure download dir
    def filename = untouchedUrl.substring(untouchedUrl.lastIndexOf('/') + 1)
    def downloadDir = file(bundleTmpDownloadPath)
    downloadDir.mkdirs()

    def downloadedFile = file("${downloadDir}/${filename}")

    if (!downloadedFile.exists()) {
        println "  Downloading to: ${downloadedFile}"
        try {
            new URL(untouchedUrl).withInputStream { input ->
                downloadedFile.withOutputStream { output ->
                    def buffer = new byte[8192]
                    def bytesRead
                    while ((bytesRead = input.read(buffer)) != -1) {
                        output.write(buffer, 0, bytesRead)
                    }
                }
            }
            println "  Download complete from modules-untouched"
        } catch (Exception e) {
            throw new GradleException("""
                Failed to download from modules-untouched: ${e.message}

                Tried URL: ${untouchedUrl}

                Please verify:
                1. Version ${version} exists in modules-untouched repository
                2. The URL is correct in nodejs.properties or matches format: nodejs-{version}/nodejs-{version}-win-x64.7z
                3. You have internet connectivity
            """.stripIndent())
        }
    } else {
        println "  Using cached file: ${downloadedFile}"
    }

    return downloadedFile
}

// Download and extract Node.js binaries
def downloadAndExtractNode(String version, File destDir) {
    def downloadedFile = downloadFromModulesUntouched(version, destDir)

    def extractDir = file(bundleTmpExtractPath)
    extractDir.mkdirs()
    println "  Extracting archive..."
    def extractPath = file("${extractDir}/${version}")
    if (extractPath.exists()) { delete extractPath }
    extractPath.mkdirs()

    def filename = downloadedFile.name

    if (filename.endsWith('.7z')) {
        def sevenZipPath = find7ZipExecutable()
        if (sevenZipPath) {
            def command = [
                sevenZipPath.toString(),
                'x',
                downloadedFile.absolutePath.toString(),
                "-o${extractPath.absolutePath}".toString(),
                '-y'
            ]
            def process = new ProcessBuilder(command as String[])
                .directory(extractPath)
                .redirectErrorStream(true)
                .start()

            process.inputStream.eachLine { line -> if (line.trim()) println "    ${line}" }
            def exitCode = process.waitFor()
            if (exitCode != 0) {
                throw new GradleException("7zip extraction failed with exit code: ${exitCode}")
            }
        } else {
            throw new GradleException("7zip not found. Please install 7zip or extract manually.")
        }
    } else if (filename.endsWith('.zip')) {
        copy { from zipTree(downloadedFile); into extractPath }
    } else {
        throw new GradleException("Unsupported archive format: ${filename}")
    }

    println "  Extraction complete"

    def nodeDir = findNodeDirectory(extractPath)
    if (!nodeDir) {
        throw new GradleException("Could not find Node.js directory in extracted files")
    }

    println "  Found Node.js directory: ${nodeDir.name}"
    println ""
    println "NOTE: Version ${version} was sourced from modules-untouched (or fallback URL)."

    return nodeDir
}

// Find Node.js directory (looks for node.exe)
def findNodeDirectory(File extractPath) {
    def hasNodeExe = { File dir ->
        new File(dir, 'node.exe').exists() || new File(dir, 'Node.exe').exists()
    }

    if (!extractPath?.exists()) { return null }
    if (hasNodeExe(extractPath)) { return extractPath }

    File found = null
    def stack = new ArrayDeque<File>()
    extractPath.listFiles()?.findAll { it.isDirectory() }?.each { stack.push(it) }
    while (!stack.isEmpty() && found == null) {
        def dir = stack.pop()
        if (hasNodeExe(dir)) { found = dir; break }
        dir.listFiles()?.findAll { it.isDirectory() }?.each { stack.push(it) }
    }
    return found
}

// ============================================================================
// GRADLE TASKS
// ============================================================================

// Info task
tasks.register('info') {
    group = 'help'
    description = 'Display build configuration information'

    def projectName = project.name
    def projectVersion = project.version
    def projectDescription = project.description
    def projectBasedirValue = projectBasedir
    def rootDirValue = rootDir
    def devPathValue = devPath
    def bundleNameValue = bundleName
    def bundleReleaseValue = bundleRelease
    def bundleTypeValue = bundleType
    def bundleFormatValue = bundleFormat
    def buildBasePathValue = buildBasePath
    def buildTmpPathValue = buildTmpPath
    def bundleTmpPrepPathValue = bundleTmpPrepPath
    def bundleTmpBuildPathValue = bundleTmpBuildPath
    def bundleTmpSrcPathValue = bundleTmpSrcPath
    def bundleTmpDownloadPathValue = bundleTmpDownloadPath
    def bundleTmpExtractPathValue = bundleTmpExtractPath
    def javaVersion = JavaVersion.current()
    def javaHome = System.getProperty('java.home')
    def gradleVersion = gradle.gradleVersion
    def gradleHome = gradle.gradleHomeDir

    doLast {
        println """
        ================================================================
                  Bearsampp Module Node.js - Build Info
        ================================================================

        Project:        ${projectName}
        Version:        ${projectVersion}
        Description:    ${projectDescription}

        Bundle Properties:
          Name:         ${bundleNameValue}
          Release:      ${bundleReleaseValue}
          Type:         ${bundleTypeValue}
          Format:       ${bundleFormatValue}

        Paths:
          Project Dir:  ${projectBasedirValue}
          Root Dir:     ${rootDirValue}
          Dev Path:     ${devPathValue}
          Build Base:   ${buildBasePathValue}
          Build Tmp:    ${buildTmpPathValue}
          Tmp Prep:     ${bundleTmpPrepPathValue}
          Tmp Build:    ${bundleTmpBuildPathValue}
          Tmp Src:      ${bundleTmpSrcPathValue}
          Tmp Download: ${bundleTmpDownloadPathValue}
          Tmp Extract:  ${bundleTmpExtractPathValue}

        Java:
          Version:      ${javaVersion}
          Home:         ${javaHome}

        Gradle:
          Version:      ${gradleVersion}
          Home:         ${gradleHome}

        Available Task Groups:
          * build        - Build and package tasks
          * help         - Help and information tasks
          * verification - Verification tasks

        Quick Start:
          gradle tasks                              - List all available tasks
          gradle info                               - Show this information
          gradle release -PbundleVersion=24.6.0     - Build specific version
          gradle releaseAll                         - Build all versions
          gradle clean                              - Clean build artifacts
          gradle verify                             - Verify build environment
        """.stripIndent()
    }
}

// Main release task - build a specific version
tasks.register('release') {
    group = 'build'
    description = 'Build release package for a specific version (use -PbundleVersion=X.X.X or run interactively)'

    def versionProperty = project.findProperty('bundleVersion')

    doLast {
        def versionToBuild = versionProperty

        if (!versionToBuild) {
            // Interactive prompt
            def availableVersions = getAvailableVersions()
            if (availableVersions.isEmpty()) {
                throw new GradleException("No versions found in bin/ directory")
            }

            println ""
            println "=".multiply(70)
            println "Interactive Release Mode"
            println "=".multiply(70)
            println ""
            println "Available versions:"

            def binDir = file("${projectDir}/bin")
            def archivedDir = file("${projectDir}/bin/archived")

            availableVersions.eachWithIndex { version, index ->
                def location = ""
                if (binDir.exists() && file("${binDir}/${bundleName}${version}").exists()) {
                    location = "[bin]"
                } else if (archivedDir.exists() && file("${archivedDir}/${bundleName}${version}").exists()) {
                    location = "[bin/archived]"
                }
                println "  ${(index + 1).toString().padLeft(2)}. ${version.padRight(15)} ${location}"
            }
            println ""
            println "Enter version to build (index or version string):"
            println ""

            def input = null
            try {
                def reader = new BufferedReader(new InputStreamReader(System.in))
                input = reader.readLine()
            } catch (Exception e) {
                throw new GradleException("""
                    Failed to read input. Please use non-interactive mode:
                      gradle release -PbundleVersion=X.X.X

                    Available versions: ${availableVersions.join(', ')}
                """.stripIndent())
            }

            if (!input || input.trim().isEmpty()) {
                throw new GradleException("""
                    No version selected. Please use non-interactive mode:
                      gradle release -PbundleVersion=X.X.X

                    Available versions: ${availableVersions.join(', ')}
                """.stripIndent())
            }

            def cleaned = input.trim()
            if (cleaned.isInteger()) {
                def idx = cleaned.toInteger()
                if (idx < 1 || idx > availableVersions.size()) {
                    throw new GradleException("""
                        Invalid selection index: ${cleaned}

                        Please choose a number between 1 and ${availableVersions.size()} or enter a version string.
                    """.stripIndent())
                }
                versionToBuild = availableVersions[idx - 1]
            } else {
                versionToBuild = cleaned
                if (!availableVersions.contains(versionToBuild)) {
                    throw new GradleException("""
                        Invalid version: ${versionToBuild}

                        Please choose from available versions:
                        ${availableVersions.collect { "  - ${it}" }.join('\n')}
                    """.stripIndent())
                }
            }

            println ""
            println "Selected version: ${versionToBuild}"
        }

        println ""
        println "=".multiply(70)
        println "Building ${bundleName} ${versionToBuild}"
        println "=".multiply(70)
        println ""

        // Validate version exists in bin or archived
        def bundlePath = file("${projectDir}/bin/${bundleName}${versionToBuild}")
        if (!bundlePath.exists()) {
            bundlePath = file("${projectDir}/bin/archived/${bundleName}${versionToBuild}")
            if (!bundlePath.exists()) {
                throw new GradleException("Bundle version not found in bin/ or bin/archived/\n\nAvailable versions:\n${getAvailableVersions().collect { "  - ${it}" }.join('\n')}")
            }
        }

        println "Bundle path: ${bundlePath}"
        println ""

        def bundleFolder = bundlePath.name
        def bundleVersion = bundleFolder.replace(bundleName, '')

        def bundleSrcDest = bundlePath
        def bundleSrcFinal = bundleSrcDest

        def nodeExe = file("${bundleSrcFinal}/node.exe")
        if (!nodeExe.exists()) {
            // Try cached extract first
            def tmpExtractPath = file("${bundleTmpExtractPath}/${bundleVersion}")
            def tmpNodeDir = findNodeDirectory(tmpExtractPath)

            if (tmpNodeDir && tmpNodeDir.exists()) {
                println "Using cached Node.js binaries from bearsampp-build/tmp"
                bundleSrcFinal = tmpNodeDir
            } else {
                println ""
                println "Node.js binaries not found"
                println "Downloading Node.js ${bundleVersion}..."
                println ""

                try {
                    bundleSrcFinal = downloadAndExtractNode(bundleVersion, file(bundleTmpExtractPath))
                } catch (Exception e) {
                    throw new GradleException("""
                                Failed to download Node.js binaries: ${e.message}

                                You can manually download and extract Node.js binaries to:
                                  ${bundleSrcDest}/

                                Or check that version ${bundleVersion} exists in modules-untouched nodejs.properties
                            """.stripIndent())
                }
            }
        }

        nodeExe = file("${bundleSrcFinal}/node.exe")
        if (!nodeExe.exists()) {
            throw new GradleException("node.exe not found at ${nodeExe}")
        }

        println "Source folder: ${bundleSrcFinal}"
        println ""

        // Prep directory
        def prepPath = file("${bundleTmpPrepPath}/${bundleName}${bundleVersion}")
        if (prepPath.exists()) { delete prepPath }
        prepPath.mkdirs()

        // Copy Node.js files from extracted/downloaded location
        println "Copying Node.js files..."
        copy { from bundleSrcFinal; into prepPath }

        // Overlay files from bin bundle directory
        println "Overlaying bundle files from bin directory..."
        copy { from bundleSrcDest; into prepPath }

        println ""
        println "Copying to bundles_build directory..."
        def buildPathOut = file("${bundleTmpBuildPath}/${bundleName}${bundleVersion}")
        if (buildPathOut.exists()) { delete buildPathOut }
        buildPathOut.mkdirs()
        copy { from prepPath; into buildPathOut }
        println "Non-zip version available at: ${buildPathOut}"

        println ""
        println "Preparing archive..."

        // Output path bearsampp-build/{type}/{name}/{release}
        def buildPath = file(buildBasePath)
        def buildBinsPath = file("${buildPath}/${bundleType}/${bundleName}/${bundleRelease}")
        buildBinsPath.mkdirs()

        def destFile = file("${buildBinsPath}/bearsampp-${bundleName}-${bundleVersion}-${bundleRelease}")

        if (bundleFormat == '7z') {
            def archiveFile = file("${destFile}.7z")
            if (archiveFile.exists()) { delete archiveFile }

            println "Compressing (including top-level folder) ${bundleName}${bundleVersion} to ${archiveFile.name}..."

            def sevenZipExe = find7ZipExecutable()
            if (!sevenZipExe) { throw new GradleException("7-Zip not found. Please install 7-Zip or set 7Z_HOME environment variable.") }
            println "Using 7-Zip: ${sevenZipExe}"

            // IMPORTANT: run from the parent directory and add the folder name explicitly
            def parentDir = prepPath.parentFile
            def folderName = prepPath.name
            def command = [ sevenZipExe, 'a', '-t7z', archiveFile.absolutePath.toString(), folderName ]
            def process = new ProcessBuilder(command as String[])
                .directory(parentDir)
                .redirectErrorStream(true)
                .start()
            process.inputStream.eachLine { line -> if (line.trim()) println "  ${line}" }
            def exitCode = process.waitFor()
            if (exitCode != 0) { throw new GradleException("7zip compression failed with exit code: ${exitCode}") }

            println "Archive created: ${archiveFile}"
            println "Generating hash files..."
            generateHashFiles(archiveFile)
        } else {
            def archiveFile = file("${destFile}.zip")
            if (archiveFile.exists()) { delete archiveFile }

            println "Compressing (including top-level folder) ${bundleName}${bundleVersion} to ${archiveFile.name}..."
            // Use Zip task but include the folder itself so the archive contains nodejs{version}/...
            task("zipArchive_${bundleVersion}", type: Zip) {
                from(prepPath.parentFile) {
                    include "${prepPath.name}/**"
                }
                destinationDirectory = archiveFile.parentFile
                archiveFileName = archiveFile.name
            }.execute()

            println "Archive created: ${archiveFile}"
            println "Generating hash files..."
            generateHashFiles(archiveFile)
        }

        println ""
        println "=".multiply(70)
        println "[SUCCESS] Release build completed successfully for version ${versionToBuild}"
        println "Output directory: ${buildPathOut}"
        println "Archive: ${destFile}.${bundleFormat}"
        println "=".multiply(70)
    }
}

// Find 7-Zip executable
def find7ZipExecutable() {
    def sevenZipHome = System.getenv('7Z_HOME')
    if (sevenZipHome) {
        def exe = file("${sevenZipHome}/7z.exe")
        if (exe.exists()) { return exe.absolutePath }
    }
    def commonPaths = [
        'C:/Program Files/7-Zip/7z.exe',
        'C:/Program Files (x86)/7-Zip/7z.exe',
        'D:/Program Files/7-Zip/7z.exe',
        'D:/Program Files (x86)/7-Zip/7z.exe'
    ]
    for (path in commonPaths) {
        def exe = file(path)
        if (exe.exists()) { return exe.absolutePath }
    }
    try {
        def process = ['where', '7z.exe'].execute()
        process.waitFor()
        if (process.exitValue() == 0) {
            def output = process.text.trim()
            if (output) { return output.split('\n')[0].trim() }
        }
    } catch (Exception e) { }
    return null
}

// Generate hash files for an archive
def generateHashFiles(File file) {
    if (!file.exists()) { throw new GradleException("File not found for hashing: ${file}") }

    def md5File = new File("${file.absolutePath}.md5")
    def md5Hash = calculateHash(file, 'MD5')
    md5File.text = "${md5Hash} ${file.name}\n"
    println "  Created: ${md5File.name}"

    def sha1File = new File("${file.absolutePath}.sha1")
    def sha1Hash = calculateHash(file, 'SHA-1')
    sha1File.text = "${sha1Hash} ${file.name}\n"
    println "  Created: ${sha1File.name}"

    def sha256File = new File("${file.absolutePath}.sha256")
    def sha256Hash = calculateHash(file, 'SHA-256')
    sha256File.text = "${sha256Hash} ${file.name}\n"
    println "  Created: ${sha256File.name}"

    def sha512File = new File("${file.absolutePath}.sha512")
    def sha512Hash = calculateHash(file, 'SHA-512')
    sha512File.text = "${sha512Hash} ${file.name}\n"
    println "  Created: ${sha512File.name}"
}

// Calculate hash
def calculateHash(File file, String algorithm) {
    def digest = java.security.MessageDigest.getInstance(algorithm)
    file.withInputStream { stream ->
        def buffer = new byte[8192]
        def bytesRead
        while ((bytesRead = stream.read(buffer)) != -1) {
            digest.update(buffer, 0, bytesRead)
        }
    }
    return digest.digest().collect { String.format('%02x', it) }.join('')
}

// Get available versions from bin and bin/archived
def getAvailableVersions() {
    def versions = []

    def binDir = file("${projectDir}/bin")
    if (binDir.exists()) {
        def binVersions = binDir.listFiles()
            ?.findAll { it.isDirectory() && it.name.startsWith(bundleName) && it.name != 'archived' }
            ?.collect { it.name.replace(bundleName, '') } ?: []
        versions.addAll(binVersions)
    }

    def archivedDir = file("${projectDir}/bin/archived")
    if (archivedDir.exists()) {
        def archivedVersions = archivedDir.listFiles()
            ?.findAll { it.isDirectory() && it.name.startsWith(bundleName) }
            ?.collect { it.name.replace(bundleName, '') } ?: []
        versions.addAll(archivedVersions)
    }

    return versions.unique().sort()
}

// Build all available versions (prep only)
tasks.register('releaseAll') {
    group = 'build'
    description = 'Build release packages for all available versions in bin/ directory'

    doLast {
        def binDir = file("${projectDir}/bin")
        if (!binDir.exists()) { throw new GradleException("bin/ directory not found") }

        def versions = getAvailableVersions()
        if (versions.isEmpty()) { throw new GradleException("No versions found in bin/ directory") }

        println ""
        println "=".multiply(70)
        println "Building releases for ${versions.size()} ${bundleName} versions"
        println "=".multiply(70)
        println ""

        def successCount = 0
        def failedVersions = []

        versions.each { version ->
            println "=".multiply(70)
            println "[${successCount + 1}/${versions.size()}] Building ${bundleName} ${version}..."
            println "=".multiply(70)

            try {
                def bundlePath = file("${projectDir}/bin/${bundleName}${version}")
                if (!bundlePath.exists()) { throw new GradleException("Bundle path not found: ${bundlePath}") }

                println "Bundle path: ${bundlePath}"
                println ""

                def bundleFolder = bundlePath.name
                def bundleVersion = bundleFolder.replace(bundleName, '')
                def bundleSrcDest = bundlePath

                def nodeExe = file("${bundleSrcDest}/node.exe")
                if (!nodeExe.exists()) { throw new GradleException("node.exe not found at ${nodeExe}") }

                println "Source folder: ${bundleSrcDest}"
                println ""

                def prepPath = file("${bundleTmpPrepPath}/${bundleName}${bundleVersion}")
                if (prepPath.exists()) { delete prepPath }
                prepPath.mkdirs()

                println "Copying Node.js files..."
                copy { from bundleSrcDest; into prepPath }

                println ""
                println "[SUCCESS] ${bundleName} ${version} completed"
                println "Output: ${prepPath}"
                successCount++

            } catch (Exception e) {
                println ""
                println "[FAILED] ${bundleName} ${version}: ${e.message}"
                failedVersions.add(version)
            }

            println ""
        }

        println "=".multiply(70)
        println "Build Summary"
        println "=".multiply(70)
        println "Total versions: ${versions.size()}"
        println "Successful:     ${successCount}"
        println "Failed:         ${failedVersions.size()}"

        if (!failedVersions.isEmpty()) {
            println ""
            println "Failed versions:"
            failedVersions.each { v -> println "  - ${v}" }
        }

        println "=".multiply(70)

        if (failedVersions.isEmpty()) {
            println "[SUCCESS] All versions built successfully!"
        } else {
            throw new GradleException("${failedVersions.size()} version(s) failed to build")
        }
    }
}

// Clean task enhancement (only Gradle artifacts for this script)
tasks.named('clean') {
    group = 'build'
    description = 'Clean build artifacts and temporary files'
    doLast {
        def buildDir = file("${projectDir}/build")
        if (buildDir.exists()) { delete buildDir }
        println "[SUCCESS] Build artifacts cleaned"
    }
}

// Verify environment
tasks.register('verify') {
    group = 'verification'
    description = 'Verify build environment and dependencies'
    doLast {
        println "Verifying build environment for module-nodejs..."
        def checks = [:]
        def javaVersion = JavaVersion.current()
        checks['Java 8+'] = javaVersion >= JavaVersion.VERSION_1_8
        checks['build.properties'] = file('build.properties').exists()
        checks['dev directory'] = file(devPath).exists()
        checks['bin directory'] = file("${projectDir}/bin").exists()
        if (bundleFormat == '7z') { checks['7-Zip'] = find7ZipExecutable() != null }

        println "\nEnvironment Check Results:"
        println "-".multiply(60)
        checks.each { name, passed ->
            def status = passed ? "[PASS]" : "[FAIL]"
            println "  ${status.padRight(10)} ${name}"
        }
        println "-".multiply(60)

        def allPassed = checks.values().every { it }
        if (allPassed) {
            println "\n[SUCCESS] All checks passed! Build environment is ready."
            println "\nYou can now run:"
            println "  gradle release -PbundleVersion=24.6.0   - Build release for version"
            println "  gradle listVersions                     - List available versions"
        } else {
            println "\n[WARNING] Some checks failed. Please review the requirements."
            throw new GradleException("Build environment verification failed")
        }
    }
}

// List releases from modules-untouched
tasks.register('listReleases') {
    group = 'help'
    description = 'List all available releases from modules-untouched nodejs.properties'
    doLast {
        def props = fetchModulesUntouchedProperties()
        if (!props) {
            println "\n[WARNING] Could not fetch modules-untouched nodejs.properties."
            println "No release information available."
            return
        }
        println "\nAvailable Node.js Releases (modules-untouched):"
        println "-".multiply(80)
        props.sort { a, b -> a.key <=> b.key }.each { version, url -> println "  ${version.padRight(10)} -> ${url}" }
        println "-".multiply(80)
        println "Total releases: ${props.size()}"
    }
}

// List versions available locally
tasks.register('listVersions') {
    group = 'help'
    description = 'List all available bundle versions in bin/ and bin/archived/ directories'
    doLast {
        def versions = getAvailableVersions()
        if (versions.isEmpty()) { println "\nNo versions found in bin/ or bin/archived/ directories"; return }

        println "\nAvailable ${bundleName} versions:"
        println "-".multiply(60)

        def binDir = file("${projectDir}/bin")
        def archivedDir = file("${projectDir}/bin/archived")

        versions.each { version ->
            def location = ""
            if (binDir.exists() && file("${binDir}/${bundleName}${version}").exists()) { location = "[bin]" }
            else if (archivedDir.exists() && file("${archivedDir}/${bundleName}${version}").exists()) { location = "[bin/archived]" }
            println "  ${version.padRight(15)} ${location}"
        }
        println "-".multiply(60)
        println "Total versions: ${versions.size()}"
        if (!versions.isEmpty()) {
            println "\nTo build a specific version:"
            println "  gradle release -PbundleVersion=${versions.last()}"
        }
    }
}

// Validate build.properties
tasks.register('validateProperties') {
    group = 'verification'
    description = 'Validate build.properties configuration'
    doLast {
        println "Validating build.properties..."
        def required = ['bundle.name', 'bundle.release', 'bundle.type', 'bundle.format']
        def missing = []
        required.each { prop -> if (!buildProps.containsKey(prop) || buildProps.getProperty(prop).trim().isEmpty()) { missing.add(prop) } }
        if (missing.isEmpty()) {
            println "[SUCCESS] All required properties are present:"
            required.each { prop -> println "    ${prop} = ${buildProps.getProperty(prop)}" }
        } else {
            println "[ERROR] Missing required properties:"
            missing.each { prop -> println "    - ${prop}" }
            throw new GradleException("build.properties validation failed")
        }
    }
}

// Check modules-untouched integration
tasks.register('checkModulesUntouched') {
    group = 'verification'
    description = 'Check modules-untouched repository integration and available versions'
    doLast {
        println ""
        println "=".multiply(70)
        println "Modules-Untouched Integration Check"
        println "=".multiply(70)
        println ""

        def propsUrl = "https://raw.githubusercontent.com/Bearsampp/modules-untouched/main/modules/nodejs.properties"
        println "Repository URL:"
        println "  ${propsUrl}"
        println ""

        println "Fetching nodejs.properties from modules-untouched..."
        def untouchedProps = fetchModulesUntouchedProperties()

        if (untouchedProps) {
            println ""
            println "=".multiply(70)
            println "Available Versions in modules-untouched"
            println "=".multiply(70)

            def sortedVersions = untouchedProps.sort { a, b ->
                def aParts = a.key.tokenize('.')
                def bParts = b.key.tokenize('.')
                for (int i = 0; i < Math.min(aParts.size(), bParts.size()); i++) {
                    def aNum = aParts[i].toInteger()
                    def bNum = bParts[i].toInteger()
                    if (aNum != bNum) return aNum <=> bNum
                }
                return aParts.size() <=> bParts.size()
            }

            sortedVersions.each { version, url -> println "  ${version.padRight(10)}" }

            println "=".multiply(70)
            println "Total versions: ${untouchedProps.size()}"
            println ""
            println ""
            println "=".multiply(70)
            println "[SUCCESS] modules-untouched integration is working"
            println "=".multiply(70)
            println ""
            println "Version Resolution Strategy:"
            println "  1. Check modules-untouched nodejs.properties (remote)"
            println "  2. Construct standard URL format (fallback)"
            println ""
            println "Documentation: /.gradle-docs/MODULES_UNTOUCHED_INTEGRATION.md"
        } else {
            println ""
            println "=".multiply(70)
            println "[WARNING] Could not fetch nodejs.properties from modules-untouched"
            println "=".multiply(70)
            println ""
            println "This may be due to:"
            println "  - Network connectivity issues"
            println "  - Repository access problems"
            println "  - File not available at expected location"
            println ""
            println "The build system will fall back to:"
            println "  1. Standard URL format construction"
        }
    }
}

// ============================================================================
// BUILD LIFECYCLE HOOKS
// ============================================================================

gradle.taskGraph.whenReady { graph ->
    println """
    ================================================================
      Bearsampp Module Node.js - Gradle Build
    ================================================================
    """.stripIndent()
}

// ============================================================================
// DEFAULT TASK
// ============================================================================

defaultTasks 'info'