ThefuckDidIJustDo.java

package com.riagenic.BlockFarmer.core.asm.utils;

import com.google.common.collect.Maps;
import net.minecraftforge.fml.common.FMLLog;
import net.minecraftforge.fml.common.ObfuscationReflectionHelper;
import net.minecraftforge.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper;

import java.io.IOException;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Map;

/**
 * projects / com.riagenic.BlockFarmer.core.asm.utils
 * -----------------------------------------------
 * User: Scott
 * Date: 2/9/2016
 * Time: 7:20 PM
 * -----------------------------------------------
 * Handles all required MCP-to-SRG Mapping needs that get used during
 * Dev-time. Once the code is ready for production this entire class
 * becomes dormant and unused.
 */
public class ObfMappings {

    private final static Map<String,Map<String,String>> srgMaps = ObfuscationReflectionHelper.getPrivateValue(FMLDeobfuscatingRemapper.class, FMLDeobfuscatingRemapper.INSTANCE, "rawMethodMaps");
    private final static Map<String,Map<String,String>> srgFields = ObfuscationReflectionHelper.getPrivateValue(FMLDeobfuscatingRemapper.class, FMLDeobfuscatingRemapper.INSTANCE, "rawFieldMaps");

    private static Map<String,Map<String,String>> mcpMethodMappings = Maps.newHashMap();
    private static Map<String,Map<String,String>> mcpFieldMappings = Maps.newHashMap();
    public static boolean IsLocalMappingEnabled = false;
    private static String mappingDump;
    public static ObfMappings INSTANCE = new ObfMappings();

    public ObfMappings() {
        mappingDump = "--REPLACEME--";
        mappingDump = "";
        WriteFile();
    }

    public static void WriteFile() {
        Path templatePath = Paths.get("x:/Workspace/src/main/resources/ObfMappings.txt");
        Path srcPath = Paths.get("x:/Workspace/src/main/resources/ObfMappings_Latest.src");
        URL t = ObfMappings.class.getProtectionDomain().getCodeSource().getLocation();
        Charset charset = StandardCharsets.UTF_8;
        try {
            String content = new String(Files.readAllBytes(templatePath), charset);
            content = content.replaceAll("mappingDump = \"--"+"REPLACEME"+"--\";", mappingDump);
            Files.write(srcPath, content.getBytes(charset));


        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    private static void RegisterMCPMethod(String owner, String mcpName, String srgName) {
        mappingDump += String.format("RegisterMCPMethod(\"%s\",\"%s\",\"%s\");\n",owner,mcpName,srgName);

        if(!mcpMethodMappings.containsKey(owner)) {
            mcpMethodMappings.put(owner, Maps.<String,String>newHashMap());;
        }
        Map<String, String> node = mcpMethodMappings.get(owner);
        node.putIfAbsent(mcpName,srgName);
        mcpMethodMappings.put(owner,node);
    }

    private static void RegisterMCPField(String owner, String mcpName, String srgName) {
        mappingDump += String.format("RegisterMCPField(\"%s\",\"%s\",\"%s\");\n",owner,mcpName,srgName);

        if(!mcpFieldMappings.containsKey(owner)) {
            mcpFieldMappings.put(owner, Maps.<String,String>newHashMap());;
        }
        Map<String, String> node = mcpFieldMappings.get(owner);
        node.putIfAbsent(mcpName,srgName);
        mcpFieldMappings.put(owner,node);
    }

    private static String getLocalMethodMapping(String owner, String mcpName) {

        if (!ObfHelper.isObfuscated() || !mcpMethodMappings.containsKey(owner) || !mcpMethodMappings.get(owner).containsKey(mcpName))
            return mcpName;

        return mcpMethodMappings.get(owner).get(mcpName);
    }

    private static String getLocalFieldMapping(String owner, String mcpName) {

        if (!ObfHelper.isObfuscated() || !mcpFieldMappings.containsKey(owner) || !mcpFieldMappings.get(owner).containsKey(mcpName))
            return mcpName;

        return mcpFieldMappings.get(owner).get(mcpName);
    }

    private static void ValidateLocalMappingStatus() {
        // At runtime this file won't exist. Therefore we infer this is no longer a dev situation
        final String gradleStartProp = System.getProperty("net.minecraftforge.gradle.GradleStart.srg.srg-mcp");
        IsLocalMappingEnabled = gradleStartProp == null;
    }

    public static String getMCPMethod(String mcpName, String owner) {
        String mcpPath = ObfHelper.getInternalClassName(owner);
        ValidateLocalMappingStatus();

        if(IsLocalMappingEnabled) {
            String obsField = getLocalMethodMapping(owner, mcpName);
            FMLLog.info("Converting  " + mcpName + " to " + obsField );
            return obsField;
        }

        // At Dev time this all should kickin.
        if(srgMaps == null) {
            FMLLog.bigWarning("Cannot Deobsufcate Method/Class Names. They fucked things up!");
            return null;
        } else {

            Map<String, String> methodKey = srgMaps.get(mcpPath);

            for (Map.Entry<String, String> entry : methodKey.entrySet()) {

                String key = entry.getKey();
                String value = entry.getValue();
                String obsMethod = key.split("\\(")[0];

                if(value.contains(mcpName)) {
                    FMLLog.info("Writing Method:  " + mcpName + " to " + obsMethod );
                    RegisterMCPMethod(owner,mcpName,obsMethod);
                    return getLocalMethodMapping(owner, mcpName);
                }
            }
        }
        FMLLog.bigWarning("Failed to Deobsfucate Method: " + mcpName + " on " + mcpPath);
        return null;
    }

    public static String getMCPField(String mcpName, String owner) {
        String mcpPath = ObfHelper.getInternalClassName(owner);

        ValidateLocalMappingStatus();

        if(IsLocalMappingEnabled) {
            String obsMethod = getLocalFieldMapping(owner, mcpName);
            FMLLog.info("Converting  " + mcpName + " to " + obsMethod );
            return obsMethod;
        }


        // At Dev time this all should kickin.
        if(srgFields == null) {
            FMLLog.bigWarning("Cannot Deobsufcate Fields Names. They fucked things up!");
            return null;
        } else {

            Map<String, String> methodKey = srgFields.get(mcpPath);

            for (Map.Entry<String, String> entry : methodKey.entrySet()) {

                String key = entry.getKey();
                String value = entry.getValue();
                String obsMethod = key.split(":")[0];

                if(value.contains(mcpName)) {
                    //FMLLog.info("Writing Field:  " + mcpName + " to " + obsMethod );
                    RegisterMCPField(owner,mcpName,obsMethod);
                    return getLocalFieldMapping(owner, mcpName);
                }
            }
        }
        FMLLog.bigWarning("Failed to Deobsfucate Field: " + mcpName + " on " + mcpPath);
        return null;
    }

}