build.gradle

/*
 * Bearsampp Module Bruno - Gradle Build
 *
 * This is a 100% Gradle build configuration for the Bruno module.
 * It handles downloading, extracting, and packaging Bruno releases.
 *
 * VERSION RESOLUTION STRATEGY:
 *   1. Remote modules-untouched bruno.properties (primary source)
 *      URL: https://github.com/Bearsampp/modules-untouched/blob/main/modules/bruno.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=2.13.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', 'bruno')}"

// 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', 'bruno')
    bundleRelease = buildProps.getProperty('bundle.release', '1.0.0')
    bundleType = buildProps.getProperty('bundle.type', 'tools')
    bundleFormat = buildProps.getProperty('bundle.format', '7z')

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

    buildBasePath = buildPathFromProps ?: (buildPathFromEnv ?: defaultBuildPath)

    // Use shared bearsampp-build/tmp directory structure (same as Ant builds)
    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 - use bearsampp-build/tmp instead of local build/
    bundleTmpDownloadPath = file("${buildTmpPath}/downloads/${bundleName}").absolutePath
    bundleTmpExtractPath = file("${buildTmpPath}/extract/${bundleName}").absolutePath
}

// 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}")
}

// Configure repositories
repositories {
    mavenCentral()
}

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

// NOTE: Local releases.properties is no longer used. Versions are sourced from
//       modules-untouched bruno.properties or constructed URL as fallback.

// Function to fetch bruno.properties from modules-untouched repository
// This is the primary source for version information
def fetchModulesUntouchedProperties() {
    def propsUrl = "https://raw.githubusercontent.com/Bearsampp/modules-untouched/main/modules/bruno.properties"

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

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

    try {
        // Download using Java URL connection instead of Ant
        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 bruno.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
def downloadFromModulesUntouched(String version, File destDir) {
    println "Checking modules-untouched repository..."

    // First, try to fetch bruno.properties from modules-untouched
    def untouchedProps = fetchModulesUntouchedProperties()
    def untouchedUrl = null

    if (untouchedProps) {
        untouchedUrl = untouchedProps.getProperty(version)
        if (untouchedUrl) {
            println "Found version ${version} in modules-untouched bruno.properties"
            println "Downloading from:"
            println "  ${untouchedUrl}"
        } else {
            println "Version ${version} not found in modules-untouched bruno.properties"
            println "Attempting to construct URL based on standard format..."
            // Fallback to constructed URL
            untouchedUrl = "https://github.com/Bearsampp/modules-untouched/releases/download/bruno-${version}/bruno-${version}-win64.7z"
            println "  ${untouchedUrl}"
        }
    } else {
        println "Could not fetch bruno.properties, using standard URL format..."
        // Fallback to constructed URL
        untouchedUrl = "https://github.com/Bearsampp/modules-untouched/releases/download/bruno-${version}/bruno-${version}-win64.7z"
        println "  ${untouchedUrl}"
    }

    // Determine filename from URL
    def filename = untouchedUrl.substring(untouchedUrl.lastIndexOf('/') + 1)
    def downloadDir = file(bundleTmpDownloadPath)
    downloadDir.mkdirs()

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

    // Download if not already present
    if (!downloadedFile.exists()) {
        println "  Downloading to: ${downloadedFile}"
        try {
            // Download using Java URL connection instead of Ant
            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 bruno.properties or matches format: bruno-{version}/bruno-{version}-win64.7z
                3. You have internet connectivity
            """.stripIndent())
        }
    } else {
        println "  Using cached file: ${downloadedFile}"
    }

    return downloadedFile
}

// Function to download and extract Bruno binaries
def downloadAndExtractBruno(String version, File destDir) {
    // Always source versions/URLs from modules-untouched bruno.properties,
    // falling back to the standard constructed URL when missing.
    def downloadedFile = downloadFromModulesUntouched(version, destDir)

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

    // Determine filename from downloaded file
    def filename = downloadedFile.name

    // Use 7zip or built-in extraction
    if (filename.endsWith('.7z')) {
        // Try to use 7zip if available
        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"

    // Find the Bruno directory in the extracted files
    def brunoDir = findBrunoDirectory(extractPath)
    if (!brunoDir) {
        throw new GradleException("Could not find Bruno directory in extracted files")
    }

    println "  Found Bruno directory: ${brunoDir.name}"

    // Note about source
    println ""
    println "NOTE: Version ${version} was sourced from modules-untouched (or fallback URL)."

    return brunoDir
}

// Function to find Bruno directory in extracted files
def findBrunoDirectory(File extractPath) {
    // Helper to detect bruno.exe in a directory (case-insensitive variants)
    def hasBrunoExe = { File dir ->
        return new File(dir, 'bruno.exe').exists() || new File(dir, 'Bruno.exe').exists()
    }

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

    // Case 1: Files extracted directly into the root of extractPath
    if (hasBrunoExe(extractPath)) {
        return extractPath
    }

    // Case 2: Recursively search any depth for a directory that contains bruno.exe
    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 (hasBrunoExe(dir)) {
            found = dir
            break
        }
        dir.listFiles()?.findAll { it.isDirectory() }?.each { stack.push(it) }
    }

    return found
}

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

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

    // Capture values at configuration time to avoid deprecation warnings
    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 Bruno - 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=2.13.0     - Build specific version
          gradle releaseAll                         - Build all versions
          gradle clean                              - Clean build artifacts
          gradle verify                             - Verify build environment
        """.stripIndent()
    }
}

// Task: 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)'

    // Capture property at configuration time to avoid deprecation warning
    def versionProperty = project.findProperty('bundleVersion')

    doLast {
        def versionToBuild = versionProperty

        if (!versionToBuild) {
            // Interactive mode - prompt for version
            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:"

            // Show versions with location tags
            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 ""

            // Read input using Gradle's standard input
            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()

            // Accept either an index (1..N) or an explicit version string
            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
                // Validate the entered version string exists
                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 - check both bin and bin/archived directories
        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 ""

        // Get the bundle folder and version
        def bundleFolder = bundlePath.name
        def bundleVersion = bundleFolder.replace(bundleName, '')

        // Determine source paths
        def bundleSrcDest = bundlePath
        def bundleSrcFinal = bundleSrcDest

        // Check if bruno.exe exists in bin/ directory
        def brunoExe = file("${bundleSrcFinal}/bruno.exe")
        if (!brunoExe.exists()) {
            // Bruno binaries not found in bin/ - check if already downloaded to bearsampp-build/tmp
            def tmpExtractPath = file("${bundleTmpExtractPath}/${bundleVersion}")
            def tmpBrunoDir = findBrunoDirectory(tmpExtractPath)

            if (tmpBrunoDir && tmpBrunoDir.exists()) {
                println "Using cached Bruno binaries from bearsampp-build/tmp"
                bundleSrcFinal = tmpBrunoDir
            } else {
                // Download and extract to bearsampp-build/tmp
                println ""
                println "Bruno binaries not found"
                println "Downloading Bruno ${bundleVersion}..."
                println ""

                try {
                    // Download and extract to bearsampp-build/tmp
                    bundleSrcFinal = downloadAndExtractBruno(bundleVersion, file(bundleTmpExtractPath))
                } catch (Exception e) {
                    throw new GradleException("""
                                Failed to download Bruno binaries: ${e.message}

                                You can manually download and extract Bruno binaries to:
                                  ${bundleSrcDest}/

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

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

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

        // Prepare output directory
        def brunoPrepPath = file("${bundleTmpPrepPath}/${bundleName}${bundleVersion}")
        if (brunoPrepPath.exists()) {
            delete brunoPrepPath
        }
        brunoPrepPath.mkdirs()

        // Copy Bruno binaries from extracted/downloaded location
        println "Copying Bruno files..."
        copy {
            from bundleSrcFinal
            into brunoPrepPath
        }

        // Overlay files from bin bundle directory (mirror Ant behavior)
        // Ant copies all files from bundle.srcdest to ${bundle.tmp.prep.path}/${bundle.folder}
        // then copies everything from bundle.path on top with overwrite=true.
        println "Overlaying bundle files from bin directory..."
        copy {
            from bundleSrcDest
            into brunoPrepPath
            // Gradle copy overwrites by default; matches Ant overwrite="true"
        }

        // Copy to bundles_build directory (non-zip version for development/testing)
        println ""
        println "Copying to bundles_build directory..."
        def brunoBuildPath = file("${bundleTmpBuildPath}/${bundleName}${bundleVersion}")
        if (brunoBuildPath.exists()) {
            delete brunoBuildPath
        }
        brunoBuildPath.mkdirs()

        copy {
            from brunoPrepPath
            into brunoBuildPath
        }
        println "Non-zip version available at: ${brunoBuildPath}"

        println ""
        println "Preparing archive..."

        // Determine build output path following Apache pattern
        // bearsampp-build/tools/bruno/{bundleRelease} for tools
        // bearsampp-build/bins/apache/{bundleRelease} for bins
        def buildPath = file(buildBasePath)
        def buildBinsPath = file("${buildPath}/${bundleType}/${bundleName}/${bundleRelease}")
        buildBinsPath.mkdirs()

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

        // Compress based on format
        if (bundleFormat == '7z') {
            // 7z format
            def archiveFile = file("${destFile}.7z")
            if (archiveFile.exists()) {
                delete archiveFile
            }

            println "Compressing ${bundleName}${bundleVersion} to ${archiveFile.name}..."

            // Find 7z executable
            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}"

            // Create 7z archive including the version folder (match Ant behavior)
            // Run 7z from the parent directory and add the folder name, so the
            // archive root contains `${bundleName}${bundleVersion}` directory.
            def command = [
                sevenZipExe,
                'a',
                '-t7z',
                archiveFile.absolutePath.toString(),
                "${bundleName}${bundleVersion}"
            ]

            def process = new ProcessBuilder(command as String[])
                .directory(file(bundleTmpPrepPath))
                .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}"

            // Generate hash files
            println "Generating hash files..."
            generateHashFiles(archiveFile)

        } else {
            // ZIP format - using native Gradle zip task
            def archiveFile = file("${destFile}.zip")
            if (archiveFile.exists()) {
                delete archiveFile
            }

            println "Compressing ${bundleName}${bundleVersion} to ${archiveFile.name}..."

            // Create ZIP archive using Gradle's built-in zip functionality
            // Ensure the version folder is included at archive root to match Ant
            task("zipArchive_${bundleVersion}", type: Zip) {
                from(brunoPrepPath) {
                    into "${bundleName}${bundleVersion}"
                }
                destinationDirectory = archiveFile.parentFile
                archiveFileName = archiveFile.name
            }.execute()

            println "Archive created: ${archiveFile}"

            // Generate hash files
            println "Generating hash files..."
            generateHashFiles(archiveFile)
        }

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

// Helper function to find 7-Zip executable
def find7ZipExecutable() {
    // Check environment variable
    def sevenZipHome = System.getenv('7Z_HOME')
    if (sevenZipHome) {
        def exe = file("${sevenZipHome}/7z.exe")
        if (exe.exists()) {
            return exe.absolutePath
        }
    }

    // Check common installation paths
    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 to find in PATH
    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) {
        // Ignore
    }

    return null
}

// Helper function to generate hash files
def generateHashFiles(File file) {
    if (!file.exists()) {
        throw new GradleException("File not found for hashing: ${file}")
    }

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

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

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

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

// Helper function to 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('')
}

// Helper function to get available versions
def getAvailableVersions() {
    def versions = []

    // Check bin directory
    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)
    }

    // Check bin/archived subdirectory
    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)
    }

    // Remove duplicates and sort
    return versions.unique().sort()
}

// Task: Build all available versions
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 {
                // Call the release task logic for this version
                def bundlePath = file("${projectDir}/bin/${bundleName}${version}")

                if (!bundlePath.exists()) {
                    throw new GradleException("Bundle path not found: ${bundlePath}")
                }

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

                // Get the bundle folder and version
                def bundleFolder = bundlePath.name
                def bundleVersion = bundleFolder.replace(bundleName, '')

                // Determine source paths
                def bundleSrcDest = bundlePath
                def bundleSrcFinal = bundleSrcDest

                // Check if bruno.exe exists
                def brunoExe = file("${bundleSrcFinal}/bruno.exe")
                if (!brunoExe.exists()) {
                    throw new GradleException("bruno.exe not found at ${brunoExe}")
                }

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

                // Prepare output directory
                def brunoPrepPath = file("${bundleTmpPrepPath}/${bundleName}${bundleVersion}")
                if (brunoPrepPath.exists()) {
                    delete brunoPrepPath
                }
                brunoPrepPath.mkdirs()

                // Copy Bruno files
                println "Copying Bruno files..."
                copy {
                    from bundleSrcDest
                    into brunoPrepPath
                }

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

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

            println ""
        }

        // Summary
        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")
        }
    }
}

// Task: Enhanced clean task
tasks.named('clean') {
    group = 'build'
    description = 'Clean build artifacts and temporary files'

    doLast {
        // Clean Gradle build directory
        def buildDir = file("${projectDir}/build")
        if (buildDir.exists()) {
            delete buildDir
        }

        println "[SUCCESS] Build artifacts cleaned"
    }
}

// Task: Verify build environment
tasks.register('verify') {
    group = 'verification'
    description = 'Verify build environment and dependencies'

    doLast {
        println "Verifying build environment for module-bruno..."

        def checks = [:]

        // Check Java version
        def javaVersion = JavaVersion.current()
        checks['Java 8+'] = javaVersion >= JavaVersion.VERSION_1_8

        // Check required files
        checks['build.properties'] = file('build.properties').exists()

        // Check dev directory
        checks['dev directory'] = file(devPath).exists()

        // Check bin directory
        checks['bin directory'] = file("${projectDir}/bin").exists()

        // Check 7-Zip if format is 7z
        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=2.13.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")
        }
    }
}

// Task: List all bundle versions from modules-untouched bruno.properties
tasks.register('listReleases') {
    group = 'help'
    description = 'List all available releases from modules-untouched bruno.properties'

    doLast {
        def props = fetchModulesUntouchedProperties()
        if (!props) {
            println "\n[WARNING] Could not fetch modules-untouched bruno.properties."
            println "No release information available."
            return
        }

        println "\nAvailable Bruno 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()}"
    }
}

// Task: List available bundle versions in bin and bin/archived directories
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)

        // Show which directory each version is in
        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()}"
        }
    }
}

// Task: 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")
        }
    }
}

// Task: 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/bruno.properties"
        println "Repository URL:"
        println "  ${propsUrl}"
        println ""

        println "Fetching bruno.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 ->
                // Simple version comparison
                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 bruno.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 bruno.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 Bruno - Gradle Build
    ================================================================
    """.stripIndent()
}

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

defaultTasks 'info'