canalhandia/src/main/java/dev/marcospaulo/canalhandia/DeathLog.java

package dev.marcospaulo.canalhandia;

import org.bukkit.configuration.file.YamlConfiguration;

import java.io.File;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

/**
 * A short history of where and how each player died.
 *
 * <p>The {@code mortes} module already knows all of this at death time and then
 * throws it away once the coordinates have been delivered on respawn. Keeping it
 * costs a few lines of YAML and answers the question people actually ask a day
 * later: "onde foi que eu morri com o pico de diamante?"
 *
 * <p>Bounded per player, oldest dropped first. This is a recent-history feature,
 * not an archive — on a server where someone dies fifty times a night, an
 * unbounded log would grow without ever being read.
 */
final class DeathLog {

    /** One recorded death. {@code at} is a wall-clock millisecond timestamp. */
    record Entry(String playerId, String flavor, String world, int x, int y, int z, long at) {

        String coords() {
            return x + ", " + y + ", " + z;
        }

        String place() {
            return coords() + (world == null || world.isBlank() ? "" : " (" + world + ")");
        }
    }

    /**
     * How many deaths are kept per player. Ten covers "where did I die
     * recently" without turning the file into a diary.
     */
    static final int MAX_PER_PLAYER = 10;

    private final File file;
    private final List<Entry> entries = new ArrayList<>();

    DeathLog(File file) {
        this.file = file;
        load();
    }

    void load() {
        YamlConfiguration yaml = file.exists() ? YamlConfiguration.loadConfiguration(file) : null;
        synchronized (entries) {
            entries.clear();
            if (yaml == null) {
                return;
            }
            for (String key : yaml.getKeys(false)) {
                String playerId = yaml.getString(key + ".jogador-id");
                if (playerId == null) {
                    continue;
                }
                entries.add(new Entry(playerId,
                        yaml.getString(key + ".causa", "bateu as botas"),
                        yaml.getString(key + ".mundo", ""),
                        yaml.getInt(key + ".x"),
                        yaml.getInt(key + ".y"),
                        yaml.getInt(key + ".z"),
                        yaml.getLong(key + ".em", 0)));
            }
        }
    }

    /** Records a death, evicting this player's oldest once past the cap. */
    void record(String playerId, String flavor, String world, int x, int y, int z) {
        synchronized (entries) {
            entries.add(new Entry(playerId, flavor, world, x, y, z, System.currentTimeMillis()));
            // Evict only this player's oldest. A global cap would let one
            // player's bad night erase everyone else's history.
            List<Entry> mine = forPlayerLocked(playerId);
            while (mine.size() > MAX_PER_PLAYER) {
                Entry oldest = mine.remove(mine.size() - 1);
                entries.remove(oldest);
            }
        }
        save();
    }

    /** This player's deaths, newest first. */
    List<Entry> forPlayer(String playerId) {
        synchronized (entries) {
            return forPlayerLocked(playerId);
        }
    }

    /** Caller must hold the lock. Newest first. */
    private List<Entry> forPlayerLocked(String playerId) {
        List<Entry> out = new ArrayList<>();
        for (Entry entry : entries) {
            if (entry.playerId().equals(playerId)) {
                out.add(entry);
            }
        }
        out.sort(Comparator.comparingLong(Entry::at).reversed());
        return out;
    }

    int size() {
        synchronized (entries) {
            return entries.size();
        }
    }

    void clear(String playerId) {
        synchronized (entries) {
            entries.removeIf(entry -> entry.playerId().equals(playerId));
        }
        save();
    }

    private void save() {
        YamlConfiguration yaml = new YamlConfiguration();
        synchronized (entries) {
            for (int i = 0; i < entries.size(); i++) {
                Entry entry = entries.get(i);
                String key = "d" + i;
                yaml.set(key + ".jogador-id", entry.playerId());
                yaml.set(key + ".causa", entry.flavor());
                yaml.set(key + ".mundo", entry.world());
                yaml.set(key + ".x", entry.x());
                yaml.set(key + ".y", entry.y());
                yaml.set(key + ".z", entry.z());
                yaml.set(key + ".em", entry.at());
            }
        }
        try {
            yaml.save(file);
        } catch (Exception e) {
            throw new IllegalStateException("não consegui gravar " + file, e);
        }
    }
}