path: root/src/main/java/gregtech/common/misc/GlobalMetricsCoverDatabase.java

package gregtech.common.misc;

import static net.minecraftforge.common.util.Constants.NBT.TAG_BYTE_ARRAY;
import static net.minecraftforge.common.util.Constants.NBT.TAG_COMPOUND;

import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagByteArray;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.StatCollector;
import net.minecraft.world.WorldSavedData;
import net.minecraft.world.storage.MapStorage;
import net.minecraftforge.common.ForgeHooks;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.entity.item.ItemExpireEvent;
import net.minecraftforge.event.world.BlockEvent;
import net.minecraftforge.event.world.ExplosionEvent.Detonate;
import net.minecraftforge.event.world.WorldEvent;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import gregtech.api.enums.GT_Values;
import gregtech.api.util.GT_Utility;
import gregtech.common.covers.CoverInfo;
import gregtech.common.covers.GT_Cover_Metrics_Transmitter;
import gregtech.common.events.MetricsCoverDataEvent;
import gregtech.common.events.MetricsCoverHostDeconstructedEvent;
import gregtech.common.events.MetricsCoverSelfDestructEvent;

/**
 * Catches and provides data transmitted from deployed Metrics Transmitter covers. Only stores one result per frequency
 * at a time. Metrics covers are intended to overwrite an old result every time they emit a new event.
 * <br />
 * <br />
 * This information is only partially persisted; frequencies that are in a non-operational state will be written to
 * disk, while operational frequencies are volatile. The assumption is that any frequency with a broadcasting card will,
 * fairly quickly, re-assert its presence. Conversely, one-time events like deconstruction or self-destruction can occur
 * while the card is in a container, rotting on the ground, etc.
 */
public class GlobalMetricsCoverDatabase extends WorldSavedData {

    private static GlobalMetricsCoverDatabase INSTANCE;

    /** Holds received metrics. */
    private static final Map<UUID, Data> DATABASE = new ConcurrentHashMap<>();
    /** Used to speed up event handlers dealing with block breaking and explosions. Not persisted. */
    private static final Map<Coordinates, Set<UUID>> REVERSE_LOOKUP = new ConcurrentHashMap<>();

    private static final String DATA_NAME = "GregTech_MetricsCoverDatabase";
    private static final String DECONSTRUCTED_KEY = "GregTech_MetricsCoverDatabase_Deconstructed";
    private static final String SELF_DESTRUCTED_KEY = "GregTech_MetricsCoverDatabase_SelfDestructed";

    public GlobalMetricsCoverDatabase() {
        this(DATA_NAME);
    }

    public GlobalMetricsCoverDatabase(String name) {
        super(name);
    }

    @SuppressWarnings("unused")
    @SubscribeEvent
    public void receiveMetricsData(MetricsCoverDataEvent event) {
        final Coordinates coordinates = event.getCoordinates();
        store(event.getFrequency(), State.OPERATIONAL, event.getPayload(), coordinates);

        if (!REVERSE_LOOKUP.containsKey(coordinates)) {
            REVERSE_LOOKUP.put(coordinates, new HashSet<>());
        }
        REVERSE_LOOKUP.get(coordinates)
            .add(event.getFrequency());
    }

    @SuppressWarnings("unused")
    @SubscribeEvent
    public void receiveHostDeconstructed(MetricsCoverHostDeconstructedEvent event) {
        cullReverseLookupEntry(event.getFrequency());
        store(event.getFrequency(), State.HOST_DECONSTRUCTED);
    }

    @SuppressWarnings("unused")
    @SubscribeEvent
    public void receiveSelfDestruct(MetricsCoverSelfDestructEvent event) {
        cullReverseLookupEntry(event.getFrequency());
        store(event.getFrequency(), State.SELF_DESTRUCTED);
    }

    @SuppressWarnings("unused")
    @SubscribeEvent
    public void onWorldLoad(WorldEvent.Load event) {
        if (event.world.isRemote || event.world.provider.dimensionId != 0) {
            return;
        }

        DATABASE.clear();

        final MapStorage storage = event.world.mapStorage;
        INSTANCE = (GlobalMetricsCoverDatabase) storage.loadData(GlobalMetricsCoverDatabase.class, DATA_NAME);
        if (INSTANCE == null) {
            INSTANCE = new GlobalMetricsCoverDatabase();
            storage.setData(DATA_NAME, INSTANCE);
        }

        INSTANCE.markDirty();
    }

    @SuppressWarnings("unused")
    @SubscribeEvent
    public void onBlockBreak(BlockEvent.BreakEvent event) {
        final Coordinates coords = new Coordinates(event.world.provider.getDimensionName(), event.x, event.y, event.z);
        // In case someone else wants to listen to these, go the roundabout way.
        final Set<UUID> uuids = REVERSE_LOOKUP.get(coords);
        if (uuids != null) {
            uuids.forEach(
                uuid -> MinecraftForge.EVENT_BUS.post(
                    ForgeHooks.canHarvestBlock(event.block, event.getPlayer(), event.blockMetadata)
                        && !event.getPlayer().capabilities.isCreativeMode ? new MetricsCoverHostDeconstructedEvent(uuid)
                            : new MetricsCoverSelfDestructEvent(uuid)));
        }
    }

    @SuppressWarnings("unused")
    @SubscribeEvent
    public void onExplosion(Detonate event) {
        final String dimensionName = event.world.provider.getDimensionName();

        event.getAffectedBlocks()
            .forEach(chunkPosition -> {
                final Set<UUID> uuids = REVERSE_LOOKUP.get(
                    new Coordinates(
                        dimensionName,
                        chunkPosition.chunkPosX,
                        chunkPosition.chunkPosY,
                        chunkPosition.chunkPosZ));

                if (uuids != null) {
                    uuids.forEach(uuid -> MinecraftForge.EVENT_BUS.post(new MetricsCoverSelfDestructEvent(uuid)));
                }
            });

        event.getAffectedEntities().forEach(entity -> {
            if (entity instanceof final EntityItem entityItem) {
                getCoverUUIDsFromItemStack(entityItem.getEntityItem())
                    .forEach(uuid -> MinecraftForge.EVENT_BUS.post(new MetricsCoverSelfDestructEvent(uuid)));
            }
        });
    }

    @SuppressWarnings("unused")
    @SubscribeEvent
    public void onItemExpiration(ItemExpireEvent event) {
        getCoverUUIDsFromItemStack(event.entityItem.getEntityItem())
            .forEach(uuid -> MinecraftForge.EVENT_BUS.post(new MetricsCoverSelfDestructEvent(uuid)));
    }

    /**
     * Get the data for a frequency, if it exists.
     *
     * @param frequency The UUID corresponding to the frequency to retrieve.
     * @return An Optional with the frequency's data, or an empty Optional if it doesn't exist.
     */
    @NotNull
    public static Optional<Data> getData(UUID frequency) {
        return Optional.ofNullable(DATABASE.get(frequency));
    }

    /**
     * Once a card has received the fact that it has self-destructed, this method can be called to free up its spot
     * in the database. Does nothing if the frequency is missing or is not in a self-destructed state.
     *
     * @param frequency The UUID corresponding to the frequency to possibly cull.
     */
    public static void clearSelfDestructedFrequency(UUID frequency) {
        getData(frequency).ifPresent(data -> {
            if (data.getState() == State.SELF_DESTRUCTED) {
                DATABASE.remove(frequency);
                tryMarkDirty();
            }
        });
    }

    @Override
    public void readFromNBT(NBTTagCompound nbtTagCompound) {
        final NBTTagList deconstructed = nbtTagCompound.getTagList(DECONSTRUCTED_KEY, TAG_BYTE_ARRAY);
        final NBTTagList selfDestructed = nbtTagCompound.getTagList(SELF_DESTRUCTED_KEY, TAG_BYTE_ARRAY);

        for (int i = 0; i < deconstructed.tagCount(); i++) {
            final NBTTagByteArray byteArray = (NBTTagByteArray) deconstructed.removeTag(0);
            reconstituteUUID(byteArray.func_150292_c())
                .ifPresent(uuid -> DATABASE.put(uuid, new Data(State.HOST_DECONSTRUCTED)));
        }

        for (int i = 0; i < selfDestructed.tagCount(); i++) {
            final NBTTagByteArray byteArray = (NBTTagByteArray) selfDestructed.removeTag(0<