UUIDConverter.java

import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;

//TODO download and import BothWaysMap.java from http://pastebin.com/bM6iQ96r
//TODO download and import GsonIO.java from http://pastebin.com/HEpdCki9

public class UUIDConverter {
    private static final long maxTime = 1000 * 60 * 60 * 24;

    private static Players players;
    private static Map<UUID, Long> lastUpdates;
    private static Map<Runnable, Tuple<UUID[], String[]>> tasks;
    private static boolean updateFile;
    private static List<String> nullNames;

    public static void onEnable(){ //TODO call onEnable in the main class
        lastUpdates = new HashMap<UUID, Long>();
        tasks = new HashMap<Runnable, Tuple<UUID[], String[]>>();
        updateFile = false;
        nullNames = new ArrayList<String>();
        loadPlayers();
    }

    @SuppressWarnings("deprecation")
    private static void loadPlayers(){
        players = GsonIO.getObject(new File(uuidFile), Players.class); //TODO replace uuidFile with a directory
        if (players == null) players = new Players();
        for (Player p : Bukkit.getOnlinePlayers())
            savePlayer(p);
    }

    public static void onDisable(){ //TODO call onDisable in the main class
        Bukkit.getServer().getScheduler().cancelTasks(Main.plugin);
    }

    public static void onJoin(PlayerJoinEvent e){ //TODO call onJoin in the main class
        savePlayer(e.getPlayer());
    }

    public static void onQuit(PlayerQuitEvent e){ //TODO call onQuit in the main class
        savePlayer(e.getPlayer());
    }

    private static void savePlayer(Player p){
        save(p.getUniqueId(), p.getName());
    }

    /*
    TODO call update in the main class
    put this in onEnable:
    getServer().getScheduler().runTaskTimer(plugin, new Runnable() {
        UUIDConverter.update();
    }, 1, 1);
    */
    public static void update(){
        outerloop:
        for (Runnable task : tasks.keySet()){
            for (UUID uuid : tasks.get(task).first)
                if (!players.containsKey(uuid))
                    continue outerloop;

            for (String name : tasks.get(task).second)
                if (!players.containsValue(name) && !nullNames.contains(name))
                    continue outerloop;

            for (String name : tasks.get(task).second)
                if (nullNames.contains(name))
                    nullNames.remove(name);

            try {
                task.run();
            }
            catch (Exception e){
                e.printStackTrace();
            }

            tasks.remove(task);
        }
        if (updateFile){
            updateFile = false;
            GsonIO.createFile(Path.uuidFile, players); //TODO replace uuidFile with a directory
        }
    }

    public static void convertUuids(UUID[] uuids, String[] names, Runnable task){
        for (UUID uuid : uuids)
            updateUUID(uuid);
        for (String name : names)
            updateName(name);
        tasks.put(task, new Tuple<UUID[], String[]>(uuids, names));
    }

    public static String getName(UUID uuid){
        if (players.containsKey(uuid)) return players.get(uuid);
        else return null;
    }

    public static UUID getUUID(String name){
        if (players.containsValue(name)) return players.getKey(name);
        else return null;
    }

    private static void updateUUID(UUID uuid){
        if (!players.containsKey(uuid) || !lastUpdates.containsKey(uuid) ||
                System.currentTimeMillis() - lastUpdates.get(uuid) > maxTime)
            lookUpUUID(uuid);
    }

    private static void updateName(String name){
        if (!players.containsValue(name) || !lastUpdates.containsKey(players.getKey(name)) ||
                System.currentTimeMillis() - lastUpdates.get(players.getKey(name)) > maxTime)
            lookUpName(name);
    }

    private static void lookUpUUID(UUID uuid){
        lastUpdates.put(uuid, System.currentTimeMillis());
        Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() { //TODO replace plugin with the plugin object
            @Override
            public void run() {
                save(uuid, getNameOnline(uuid));
            }
        });
    }

    private static void lookUpName(String name){
        lastUpdates.put(players.getKey(name), System.currentTimeMillis());
        Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() { //TODO replace plugin with the plugin object
            @Override
            public void run() {
                save(getUUIDOnline(name), name);
            }
        });
    }

    private static void save(UUID uuid, String name){
        if (name != null){
            if (players.containsValue(name) && !players.getKey(name).equals(uuid))
                lookUpUUID(players.getKey(name));
            if (uuid != null){
                players.put(uuid, name);
                lastUpdates.put(uuid, System.currentTimeMillis());
                updateFile = true;
            }
            else
                nullNames.add(name);
        }
    }

    private static String getNameOnline(UUID uuid){
        try {
            String uuidString = uuid.toString();
            URL url = new URL("https://api.mojang.com/user/profiles/" + uuidString.replaceAll("-", "") + "/names");
            BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
            String line = in.readLine();
            String name = find("name", line);
            return name;
        }
        catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    private static UUID getUUIDOnline(String name){
        try {
            URL url = new URL("https://api.mojang.com/users/profiles/minecraft/" + name);
            BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
            String line = in.readLine();
            String uuidString = find("id", line);
            uuidString = uuidString.substring(0, 8) + "-" + uuidString.substring(8, 12) + "-" + uuidString.substring(12, 16)
                    + "-" + uuidString.substring(16, 20) + "-" + uuidString.substring(20, 32);
            UUID uuid = UUID.fromString(uuidString);
            return uuid;
        }
        catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    private static String find(String key, String string){
        return string.split("\"" + key + "\":\"")[1].split("\"")[0];
    }

    private static class Players extends BothWaysMap<UUID, String> {}

    private static class Tuple<A, B> {
        public A first;
        public B second;

        public Tuple(A first, B second){
            this.first = first;
            this.second = second;
        }
    }
}