build.gradle

import java.util.regex.Matcher
import java.util.regex.Pattern

buildscript
{
    repositories 
    {
        jcenter()
        maven { url = "http://files.minecraftforge.net/maven" }
    }

    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
        classpath 'org.yaml:snakeyaml:1.18'
    }
}

apply plugin: 'net.minecraftforge.gradle.forge'

if (project.hasProperty("dev")) 
{
    version += "-dev" + dev
}

group = "mchorse.blockbuster"
archivesBaseName = "blockbuster"
sourceCompatibility = targetCompatibility = "1.8"

compileJava 
{
    sourceCompatibility = targetCompatibility = "1.8"
}

/* Minecraft configuration */

minecraft 
{
    version = "${mc_version}-${forge_version}"
    runDir = "run"
    mappings = snapshot
    
    clientJvmArgs = ["-Xmx5G", "-Dfml.coreMods.load=" + coremodPath]
    serverJvmArgs = ["-Xmx5G"]
    
    replace "%VERSION%", project.version
    replace "%METAMORPH%", project.metamorph
    replace "%MCLIB%", project.mclib
    replace "%APERTURE%", project.aperture
    replace "%EMOTICONS%", project.emoticons
    replace "%MINEMA%", project.minema
}

dependencies 
{
	compile files("run/libs/mclib-${mclib}-${project.minecraft.version}-dev.jar")
	compile files("run/libs/metamorph-${metamorph}-${project.minecraft.version}-dev.jar")
	compile files("run/libs/aperture-${aperture}-${project.minecraft.version}-dev.jar")
    compile files("run/libs/Minema-${minema}-${project.minecraft.version}-dev.jar")
}

jar {
   manifest {
       attributes 'FMLCorePlugin': coremodPath, 'FMLCorePluginContainsFMLMod': 'true'
   }
}

eclipse
{
    classpath
    {
        file
        {
            whenMerged
            { classpath -> 
                def ver = project.minecraft.version
                /* Fucking gradle 2.14 doesn't have fileReference() method,
                 * screw you piece of shit */
                def getMeReference = { File file ->
                	return [
                		getFile: { return file },
                		getPath: { return file.getAbsolutePath() },
                		getJarURL: { return file.getAbsolutePath() },
                		isRelativeToPathVariable: { return false }
                	] as org.gradle.plugins.ide.eclipse.model.FileReference
                }
                
                def lib = entries.find { it.path.contains "metamorph-${metamorph}" }
                lib.sourcePath = getMeReference(file("run/libs/metamorph-${metamorph}-${ver}-sources.jar"))
                
                lib = entries.find { it.path.contains "aperture-${aperture}" } 
                lib.sourcePath = getMeReference(file("run/libs/aperture-${aperture}-${ver}-sources.jar"))
                
                lib = entries.find { it.path.contains "mclib-${mclib}" } 
                lib.sourcePath = getMeReference(file("run/libs/mclib-${mclib}-${ver}-sources.jar"))
            }
        }
    }
}

processResources
{
    inputs.property "version", project.version
    inputs.property "mcversion", project.minecraft.version

	project.version += "-" + project.minecraft.version

    from(sourceSets.main.resources.srcDirs) {
        include 'mcmod.info'
                
        expand 'version':project.version, 'mcversion':project.minecraft.version
    }
        
    from(sourceSets.main.resources.srcDirs) {
        exclude 'mcmod.info'
    }
}

/* Dev build */
task deobfJar(type: Jar) {
    from sourceSets.main.output
    classifier = 'dev'
}

task sourcesJar(type: Jar) {
    from sourceSets.main.allJava
    classifier = 'sources'
}

artifacts {
    archives deobfJar
    archives sourcesJar
}

/* Build language files from YML */

task buildLangFiles {
    doLast {
        def help = file("help")
        def flatten
        
        /**
         * Flattens the map
         */
        flatten = { Map map, Map original, String prefix ->
            for (entry in original.entrySet())
            {
                def value = entry.getValue();
                
                if (value instanceof String)
                {
                    map.put(prefix + entry.getKey(), value)
                }
                else if (value instanceof Map)
                {
                    flatten(map, value, prefix + entry.getKey() + ".")
                }
                else
                {
                    map.put(prefix + entry.getKey(), value.toString())
                }
            }
        }
        
        /**
         * Process the string read from the YML.
         * 
         * This method replaces new line symbols to escaped new line symbols
         * and processes {} formatting to § Minecraft formatting.
         */
        def processString = { String str ->
            return str.replace("\n", "\\n").replaceAll('\\{([\\w\\d_]+)\\}', '§$1')
        }
        
        /**
         * Compile YML file's contents to ini string
         */
        def compile = {File file ->
            def output = "\n\n# " + file.getName() + "\n";
            def yaml = new org.yaml.snakeyaml.Yaml()
            def map = yaml.load(file.text)
            def flat_map = new HashMap()
            
            flatten(flat_map, map, "")
            
            for (entry in flat_map.entrySet())
            {
                output += "${entry.getKey()}=${processString(entry.getValue())}\n";
            }
            
            return output
        }

        def replaceNestedLanguageKeys = {File langFile ->
            String newLangText = langFile.text

            /* replace {yamlfile.key_bla_bla} with the value of the language key in the current language dir */
            Matcher m = Pattern.compile('\\{([\\w\\d_.]+)\\}').matcher(newLangText);

            while (m.find())
            {
                String match = m.group()
                String langKey = project.archivesBaseName + "." + match.replace('{', '').replace('}', '')

                int indexKey = newLangText.indexOf(langKey)

                int end = indexKey
                int begin = -1

                while (end < newLangText.length())
                {
                    if (newLangText[end] == "\n" || newLangText[end] == "\r\n")
                    {
                        break
                    }

                    if (newLangText[end].equals("=") && begin == -1)
                    {
                        begin = end + 1
                    }

                    end++
                }

                String value = newLangText.substring(begin, end)

                if (value != null)
                {
                    newLangText = newLangText.replace(match, '"' + value + '"')
                }

                m = Pattern.compile('\\{([\\w\\d_.]+)\\}').matcher(newLangText);
            }

            return newLangText
        }
        
        /**
         * Convert given langauge dir from YML to ini
         */
        def convert = { File lang_dir ->
            /* Forge directive that allows \n symbols to be allowed in the chat */
            def output = "#PARSE_ESCAPES"
            def output_file = file("src/main/resources/assets/${project.archivesBaseName}/lang/${lang_dir.getName()}.lang")
            
            for (file in lang_dir.listFiles())
            {
                if (file.getName().endsWith(".yml"))
                {
                    output += compile(file)
                }
            }
            
            def parentFile = output_file.getParentFile()
            
            if (!parentFile.exists())
            {
                parentFile.mkdirs();
            }

            OutputStream os = new FileOutputStream(output_file);
            PrintWriter writer = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
            
            writer.println(output.trim())
            writer.close()
        }
        
        if (help.exists())
        {
            for (lang_dir in help.listFiles())
            {
                if (lang_dir.isDirectory())
                {
                    convert(lang_dir)
                    println "Converted ${lang_dir.getName()} to language file"
                }
            }

            def langFile = file("src/main/resources/assets/${project.archivesBaseName}/lang/")

            if (langFile.exists())
            {
                for (file in langFile.listFiles())
                {
                    String output = replaceNestedLanguageKeys(file)

                    OutputStream os = new FileOutputStream(file);
                    PrintWriter writer = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));

                    writer.print(output.trim())
                    writer.close()
                }
            }
            else
            {
                println "Directory 'lang' is not found!"
            }
        }
        else
        {
            println "Directory 'help' is not found!"
        }
    }
}

tasks.processResources.dependsOn('buildLangFiles')

/* Comparing keys */
task compareLangFiles {
    doLast {
        def help = file("src/main/resources/assets/${project.archivesBaseName}/lang/")
        def parse = { File file ->
            def map = new HashMap()
            def splits = file.text.split("\n");

            for (split in splits) {
                def index = split.indexOf("=")

                if (index == -1) {
                    continue
                }

                map.put(split.substring(0, index), true)
            }

            return map
        }

        if (!help.exists()) {
            return
        }

        def en = file("${help.getAbsolutePath()}/en_US.lang")
        def en_map = parse(en)

        for (lang_file in help.listFiles()) {
            if (!lang_file.name.endsWith(".lang") || lang_file.name.startsWith("en_US")) {
                continue
            }

            def lang_map = parse(lang_file)
            def missing = new ArrayList()
            def extra = new ArrayList()

            for (key in en_map.keySet()) {
                if (!lang_map.containsKey(key)) {
                    missing.add(key)
                }
            }

            for (key in lang_map.keySet()) {
                if (!en_map.containsKey(key)) {
                    extra.add(key)
                }
            }

            missing.sort()
            extra.sort()

            print("\n")

            if (!missing.isEmpty() || !extra.isEmpty()) {
                if (!missing.isEmpty()) {
                    print("Language file ${lang_file.getName()} misses following keys:\n")

                    for (key in missing) {
                        print("- ${key}\n")
                    }
                }

                if (!extra.isEmpty()) {
                    print("Language file ${lang_file.getName()} has additional keys:\n")

                    for (key in extra) {
                        print("- ${key}\n")
                    }
                }
            }
            else {
                print("Language file ${lang_file.getName()} fully matches ${en.getName()}!\n")
            }
        }
    }
}