build.gradle

plugins {
    id 'org.asciidoctor.jvm.convert' version '4.0.5'
    id 'org.asciidoctor.jvm.pdf' version '4.0.5'
}

// Read language settings from gradle.properties
def languages = project.findProperty('languages')?.split(',')?.collect { it.trim() } ?: ['DE']

repositories {
    mavenCentral()
    gradlePluginPortal()
}

asciidoctorj {
    modules {
        pdf.version = '2.3.19'
    }
}

tasks.withType(org.asciidoctor.gradle.jvm.AsciidoctorTask) {
    // Set encoding through the asciidoctorj configuration instead
    asciidoctorj {
        options = [
            doctype: 'book'
        ]
        attributes = [
            'encoding': 'UTF-8'
        ]
    }
    
    configure {
        forkOptions {
            jvmArgs(
                '--add-opens=java.base/sun.nio.ch=ALL-UNNAMED',
                '--add-opens=java.base/java.io=ALL-UNNAMED'
            )
        }
    }
}

// Function to load version properties
def loadVersionProperties(language) {
    def props = new Properties()
    def propFile = file("${language}/version.properties")
    if (!propFile.exists()) {
        throw new GradleException("Version properties file not found for language ${language}: ${propFile}")
    }
    propFile.withInputStream { 
        props.load(new InputStreamReader(it, "UTF-8")) // Use UTF-8 when reading properties
    }
    return [
        'revnumber': props.revnumber ?: 'UNKNOWN',
        'revdate': props.revdate ?: 'UNKNOWN',
        'revremark': props.revremark ?: ''
    ]
}

// Collect version info for all languages upfront
def allVersionInfo = languages.collectEntries { lang ->
    [lang, loadVersionProperties(lang)]
}

// Function to validate image references in AsciiDoc files
def validateImageReferences(String language, File sourceDir, File imagesDir) {
    def results = [
        language: language,
        missingImages: [],
        totalChecked: 0
    ]

    // Find all .adoc files recursively
    def adocFiles = fileTree(sourceDir) {
        include '**/*.adoc'
    }

    // Define regex patterns for image references
    // Block images: image::filename[alt]
    // Inline images: image:filename[alt] (but not image:: with double colon)
    def blockPattern = ~/image::([^\[]+)\[/
    def inlinePattern = ~/(?<!:)image:([^:\[]+)\[/

    // Scan each file for image references
    adocFiles.each { file ->
        def lineNumber = 0
        file.eachLine('UTF-8') { line ->
            lineNumber++

            // Check for block images (image::)
            def blockMatcher = line =~ blockPattern
            blockMatcher.each { match ->
                def imageName = match[1].trim()
                checkImageExists(imageName, file, lineNumber, imagesDir, results)
            }

            // Check for inline images (image:)
            def inlineMatcher = line =~ inlinePattern
            inlineMatcher.each { match ->
                def imageName = match[1].trim()
                checkImageExists(imageName, file, lineNumber, imagesDir, results)
            }
        }
    }

    return results
}

// Helper function to check if an image file exists
def checkImageExists(String imageName, File sourceFile, int lineNumber, File imagesDir, Map results) {
    results.totalChecked++
    def imageFile = new File(imagesDir, imageName)

    if (!imageFile.exists()) {
        results.missingImages << [
            file: sourceFile.path,
            line: lineNumber,
            imageName: imageName,
            expectedPath: imageFile.absolutePath
        ]
    }
}

// Configure common AsciiDoc attributes
ext {
    asciidocAttributes = [
        'source-highlighter': 'coderay',
        'toc': 'left',
        'toclevels': '3',
        'doctype': 'book',
        'encoding': 'UTF-8',
        'lang': 'en' // This will be overridden for each language
    ]
}

// Print version information at configuration phase
println "\nBuilding arc42 documentation with the following versions:"
allVersionInfo.each { lang, version ->
    println "  ${lang}: Version ${version.revnumber} (${version.revdate}) ${version.revremark}"
}
println ""

// Create HTML and PDF tasks for each configured language
languages.each { language ->
    def versionInfo = allVersionInfo[language]

    def sourceDirFile
    def imagesDirAttr
    def pdfThemeBaseDir

    if (language in ['DE', 'EN', 'CZ', 'ES', 'FR', 'IT', 'NL', 'PT', 'RU', 'UKR', 'ZH']) {
        sourceDirFile = file(language)
        imagesDirAttr = file("${language}/images").absolutePath
        pdfThemeBaseDir = file(language)
    } else {
        sourceDirFile = file("${language}/asciidoc")
        imagesDirAttr = "${projectDir}/images"
        pdfThemeBaseDir = file("${language}/asciidoc")
    }

    // Register image validation task for this language
    tasks.register("validateImages${language}") {
        group = 'Verification'
        description = "Validates that all image references in ${language} AsciiDoc files exist"

        doLast {
            def results = validateImageReferences(language, sourceDirFile, file("${language}/images"))

            if (results.missingImages.isEmpty()) {
                logger.lifecycle("✓ Image validation for ${language}: All ${results.totalChecked} image references are valid")
            } else {
                logger.warn("")
                logger.warn("=" * 70)
                logger.warn("⚠ Image Reference Validation: ${language}")
                logger.warn("=" * 70)
                logger.warn("")
                logger.warn("WARNING: Missing image references found:")
                logger.warn("")

                results.missingImages.each { missing ->
                    logger.warn("  File: ${missing.file}:${missing.line}")
                    logger.warn("  Missing: ${missing.imageName}")
                    logger.warn("  Expected: ${missing.expectedPath}")
                    logger.warn("")
                }

                logger.warn("Summary: ${results.missingImages.size()} missing image(s) in ${language}")
                logger.warn("Build will continue, but output may have broken image placeholders.")
                logger.warn("=" * 70)
                logger.warn("")
            }
        }
    }

    // Define HTML conversion task for this language
    tasks.register("asciidoctorHtml${language}", org.asciidoctor.gradle.jvm.AsciidoctorTask) {
        dependsOn tasks.named("validateImages${language}")
        sourceDir = sourceDirFile
        sources {
            include 'arc42-template.adoc'
        }
        outputDir = file("build/${language}/html")
        baseDirFollowsSourceDir()

        attributes asciidocAttributes + [
            'imagesdir': imagesDirAttr,
            'revnumber': versionInfo.revnumber,
            'revdate': versionInfo.revdate,
            'revremark': versionInfo.revremark,
            'lang': language.toLowerCase() // Set the language code
        ]

        doLast {
            def newName = "arc42-template-${language}.html"
            file("${outputDir}/arc42-template.html").renameTo(file("${outputDir}/${newName}"))
            println "HTML conversion completed for ${language} (v${versionInfo.revnumber})"
            println "  Output: ${outputDir}/${newName}"
        }
    }

    // Define PDF conversion task for this language
    tasks.register("asciidoctorPdf${language}", org.asciidoctor.gradle.jvm.pdf.AsciidoctorPdfTask) {
        dependsOn tasks.named("validateImages${language}")
        sourceDir = sourceDirFile
        sources {
            include 'arc42-template.adoc'
        }
        outputDir = file("build/${language}/pdf")
        baseDirFollowsSourceDir()

        attributes asciidocAttributes + [
            'imagesdir': imagesDirAttr,
            'pdf-page-size': 'A4',
            'revnumber': versionInfo.revnumber,
            'revdate': versionInfo.revdate,
            'revremark': versionInfo.revremark,
            'lang': language.toLowerCase() // Set the language code
        ]

        //load PDF theme YAML file (font files) to render non-Latin languages (like Chinese,Japanese,Korean) correctly in pdf
        def pdfThemeYmlFile = file("${pdfThemeBaseDir}/pdf-theme/${language.toLowerCase()}-theme.yml")
        if( pdfThemeYmlFile.exists()){
            println "load pdf theme from ${pdfThemeYmlFile.absolutePath}"

            attributes asciidocAttributes + [
                'pdf-theme': pdfThemeYmlFile.absolutePath,
                'pdf-fontsdir': file("${pdfThemeBaseDir}/pdf-theme/fonts").absolutePath,
                // Activates line break rules for CJK languages (specifically Chinese and Japanese).
                'script': 'cjk',
                'text-align': 'left'
            ]
            println "asciidocAttributes for ${language}: ${asciidocAttributes}"
        }

        doLast {
            def newName = "arc42-template-${language}.pdf"
            file("${outputDir}/arc42-template.pdf").renameTo(file("${outputDir}/${newName}"))
            println "PDF conversion completed for ${language} (v${versionInfo.revnumber})"
            println "  Output: ${outputDir}/${newName}"
        }
    }
}

// Create aggregate tasks for all languages
tasks.register('asciidoctorHtmlAll') {
    description = 'Builds HTML for all configured languages'
    group = 'Documentation'
    
    doFirst {
        println "\nStarting HTML generation for all languages"
    }
    
    languages.each { language ->
        dependsOn tasks.named("asciidoctorHtml${language}")
    }
    
    doLast {
        println "\nHTML generation completed for all languages"
    }
}

tasks.register('asciidoctorPdfAll') {
    description = 'Builds PDF for all configured languages'
    group = 'Documentation'

    doFirst {
        println "\nStarting PDF generation for all languages"
    }

    languages.each { language ->
        dependsOn tasks.named("asciidoctorPdf${language}")
    }

    doLast {
        println "\nPDF generation completed for all languages"
    }
}

tasks.register('validateImagesAll') {
    description = 'Validates image references for all configured languages'
    group = 'Verification'

    languages.each { language ->
        dependsOn tasks.named("validateImages${language}")
    }

    doLast {
        println "\nImage validation completed for all languages"
    }
}

// Synonym for validateImagesAll
tasks.register('validateImages') {
    description = 'Validates image references for all configured languages (synonym for validateImagesAll)'
    group = 'Verification'

    dependsOn tasks.named('validateImagesAll')
}

// Short validation task
tasks.register('validate') {
    description = 'Validates image references for all configured languages (short form)'
    group = 'Verification'

    dependsOn tasks.named('validateImagesAll')
}

tasks.register('asciidoctorAll') {
    description = 'Builds HTML and PDF for all configured languages'
    group = 'Documentation'
    
    dependsOn tasks.named('asciidoctorHtmlAll')
    dependsOn tasks.named('asciidoctorPdfAll')
    
    doLast {
        println "\nDocumentation build summary:"
        allVersionInfo.each { lang, version ->
            println "  ${lang}: Version ${version.revnumber} built to build/${lang}/{html,pdf}"
        }
    }
}

tasks.named('clean') {
    description = 'Deletes the build directory'
    group = 'Build'
    
    doLast {
        delete 'build'
        println "Build directory cleaned"
    }
}

defaultTasks 'asciidoctorAll'

gradle.taskGraph.whenReady { taskGraph ->
    if (taskGraph.hasTask(':asciidoctorAll') ||
        taskGraph.hasTask(':asciidoctorHtmlAll') ||
        taskGraph.hasTask(':asciidoctorPdfAll')) {
        println "\nBuilding arc42 documentation with the following configuration:"
        println "  Languages: ${languages.join(', ')}"
        def sourceDirs = languages.collect { lang ->
            if (lang in ['DE', 'EN', 'CZ', 'ES', 'FR', 'IT', 'NL', 'PT', 'RU', 'UKR', 'ZH']) {
                return lang
            } else {
                return "${lang}/asciidoc"
            }
        }
        println "  Source directories: ${sourceDirs.join(', ')}"
        println "  Main file: arc42-template.adoc"
    }
}