EnderIO/src/main/java/crazypants/util/UserIdent.java

package crazypants.util;

import java.util.UUID;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.common.UsernameCache;

import com.enderio.core.common.util.PlayerUtil;
import com.google.common.base.Charsets;
import com.mojang.authlib.GameProfile;

import crazypants.enderio.Log;

public class UserIdent {

    private static final String NONE_MARKER = "none";
    private final @Nullable UUID uuid;
    private final @Nonnull UUID uuid_offline;
    private final @Nonnull String playerName;

    public @Nonnull String getPlayerName() {
        if (uuid != null) {
            String lastKnownName = UsernameCache.getLastKnownUsername(uuid);
            if (lastKnownName != null) {
                return lastKnownName;
            }
        }
        return playerName;
    }

    public UUID getUUID() {
        return uuid != null ? uuid : uuid_offline;
    }

    @SuppressWarnings("null")
    // it's final(!), eclipse...
    public String getUUIDString() {
        return uuid != null ? uuid.toString() : NONE_MARKER;
    }

    /**
     * Create a UserIdent from a UUID object and a name. Use this when reading stored data, it will check for username
     * changes, implement them and write a log message.
     */
    public static @Nonnull UserIdent create(@Nullable UUID uuid, @Nullable String playerName) {
        if (uuid != null) {
            if (nobody.equals(uuid)) {
                return nobody;
            }
            if (playerName != null) {
                String lastKnownName = UsernameCache.getLastKnownUsername(uuid);
                if (lastKnownName != null && !lastKnownName.equals(playerName)) {
                    Log.warn(
                            "The user with the UUID " + uuid
                                    + " changed name from '"
                                    + playerName
                                    + "' to '"
                                    + lastKnownName
                                    + "'");
                    return new UserIdent(uuid, lastKnownName);
                }
            }
            return new UserIdent(uuid, playerName);
        } else if (playerName != null) {
            return new UserIdent(null, playerName);
        } else {
            return nobody;
        }
    }

    /**
     * Create a UserIdent from a UUID string and a name. Use this when reading stored data, it will check for username
     * changes, implement them and write a log message.
     */
    public static @Nonnull UserIdent create(@Nonnull String suuid, @Nullable String playerName) {
        if (NONE_MARKER.equals(suuid)) {
            return new UserIdent(null, playerName);
        }
        try {
            UUID uuid = UUID.fromString(suuid);
            if (nobody.equals(uuid)) {
                return nobody;
            }
            return create(uuid, playerName);
        } catch (IllegalArgumentException e) {
            return nobody;
        }
    }

    /**
     * Create a UserIdent from a legacy string. The string can either be a UUID or a player name. Use this when reading
     * legacy data or user configured values.
     */
    public static @Nonnull UserIdent create(@Nullable String legacyData) {
        UUID uuid = PlayerUtil.getPlayerUIDUnstable(legacyData);
        if (uuid != null) {
            return new UserIdent(uuid, legacyData);
        } else if (legacyData != null) {
            return new UserIdent(null, legacyData);
        } else {
            return nobody;
        }
    }

    /**
     * Create a UserIdent from a GameProfile. Use this when creating a UserIdent for a currently active player.
     */
    public static @Nonnull UserIdent create(@Nullable GameProfile gameProfile) {
        if (gameProfile != null && (gameProfile.getId() != null || gameProfile.getName() != null)) {
            if (gameProfile.getId() != null && gameProfile.getName() != null
                    && gameProfile.getId().equals(offlineUUID(gameProfile.getName()))) {
                return new UserIdent(null, gameProfile.getName());
            } else {
                return new UserIdent(gameProfile.getId(), gameProfile.getName());
            }
        } else {
            return nobody;
        }
    }

    private static @Nonnull UUID offlineUUID(String playerName) {
        UUID result = UUID.nameUUIDFromBytes(("OfflinePlayer:" + playerName).getBytes(Charsets.UTF_8));
        return result != null ? result : new UUID(-1, -1);
    }

    private UserIdent(UUID uuid, String playerName) {
        this.uuid = uuid;
        this.uuid_offline = offlineUUID(playerName);
        this.playerName = playerName != null ? playerName : "[" + uuid + "]";
    }

    @SuppressWarnings("null")
    // it's final(!), eclipse...
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + playerName.hashCode();
        result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
        return result;
    }

    /**
     * Please note that a UserIdent will successfully equal against GameProfiles and UUIDs.
     */
    @SuppressWarnings("null")
    // it's final(!), eclipse...
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof UserIdent) {
            UserIdent other = (UserIdent) obj;
            if (this.uuid != null && other.uuid != null) {
                return this.uuid.equals(other.uuid);
            }
            return this.uuid_offline.equals(other.uuid_offline);
        } else if (obj instanceof GameProfile) {
            GameProfile other = (GameProfile) obj;
            UUID other_uuid = other.getId();
            if (this.uuid != null && other_uuid != null) {
                return this.uuid.equals(other_uuid);
            }
            UUID uuid_offline_other = offlineUUID(other.getName());
            return uuid_offline_other.equals(this.uuid) || this.uuid_offline.equals(uuid_offline_other);
        } else if (obj instanceof UUID) {
            return obj.equals(uuid) || obj.equals(uuid_offline);
        }
        return false;
    }

    @SuppressWarnings("null")
    // it's final(!), eclipse...
    public void saveToNbt(NBTTagCompound nbt, String prefix) {
        if (uuid != null) {
            nbt.setString(prefix + ".uuid", uuid.toString());
        }
        nbt.setString(prefix + ".login", playerName);
    }

    public static boolean existsInNbt(NBTTagCompound nbt, String prefix) {
        return nbt.hasKey(prefix + ".uuid") || nbt.hasKey(prefix + ".login");
    }

    public static @Nonnull UserIdent readfromNbt(NBTTagCompound nbt, String prefix) {
        String suuid = nbt.getString(prefix + ".uuid");
        String login = nbt.getString(prefix + ".login");
        if (Nobody.NOBODY_MARKER.equals(suuid)) {
            return nobody;
        }
        try {
            UUID uuid = UUID.fromString(suuid);
            return create(uuid, login);
        } catch (IllegalArgumentException e) {
            if (login != null && !login.isEmpty()) {
                return new UserIdent(null, login);
            } else {
                return nobody;
            }
        }
    }

    @Override
    public String toString() {
        return "User [uuid=" + (uuid != null ? uuid : "(unknown)") + ", name=" + playerName + "]";
    }

    public static final @Nonnull Nobody nobody = new Nobody();

    private static class Nobody extends UserIdent {

        private static final String NOBODY_MARKER = "nobody";

        private Nobody() {
            super(null, "[unknown player]");
        }

        @Override
        public boolean equals(Object obj) {
            return this == obj;
        }

        @Override
        public void saveToNbt(NBTTagCompound nbt, String prefix) {
            nbt.setString(prefix + ".uuid", NOBODY_MARKER);
        }
    }
}