package com.tiedup.remake.cells;

import com.tiedup.remake.core.TiedUpMod;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import net.minecraft.core.BlockPos;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.ListTag;
import net.minecraft.nbt.Tag;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.level.saveddata.SavedData;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

/**
 * Global registry for camp ownership linking camps to their SlaveTrader.
 *
 * This registry tracks:
 * - Camp UUID -> CampData (trader, maid, alive status)
 * - When a trader dies, the camp becomes inactive
 *
 * Persists across server restarts using Minecraft's SavedData system.
 */
public class CampOwnership extends SavedData {

    private static final String DATA_NAME = "tiedup_camp_ownership";

    // Camp UUID -> CampData
    private final Map<UUID, CampData> camps = new ConcurrentHashMap<>();

    // Prisoners that have been processed (to avoid re-processing)
    private final Set<UUID> processedPrisoners = ConcurrentHashMap.newKeySet();

    // ==================== CAMP DATA CLASS ====================

    /**
     * Data structure representing a camp and its owner.
     * Uses thread-safe collections for concurrent access.
     */
    /** Maid respawn delay in ticks (5 minutes = 6000 ticks) */
    public static final long MAID_RESPAWN_DELAY = 6000;

    public static class CampData {

        private final UUID campId;
        private volatile UUID traderUUID;
        private volatile UUID maidUUID;
        private volatile boolean isAlive = true;
        private volatile BlockPos center;
        private final Set<UUID> linkedKidnapperUUIDs =
            ConcurrentHashMap.newKeySet();

        /** Time when maid died (for respawn timer), -1 if alive */
        private volatile long maidDeathTime = -1;

        /** Cached positions of LOOT chests (below LOOT markers) */
        private final List<BlockPos> lootChestPositions = new ArrayList<>();

        public CampData(UUID campId) {
            this.campId = campId;
        }

        public CampData(
            UUID campId,
            UUID traderUUID,
            @Nullable UUID maidUUID,
            BlockPos center
        ) {
            this.campId = campId;
            this.traderUUID = traderUUID;
            this.maidUUID = maidUUID;
            this.center = center;
            this.isAlive = true;
        }

        // Getters
        public UUID getCampId() {
            return campId;
        }

        public UUID getTraderUUID() {
            return traderUUID;
        }

        public UUID getMaidUUID() {
            return maidUUID;
        }

        public boolean isAlive() {
            return isAlive;
        }

        public BlockPos getCenter() {
            return center;
        }

        // Setters
        public void setTraderUUID(UUID traderUUID) {
            this.traderUUID = traderUUID;
        }

        public void setMaidUUID(UUID maidUUID) {
            this.maidUUID = maidUUID;
        }

        public void setAlive(boolean alive) {
            this.isAlive = alive;
        }

        public void setCenter(BlockPos center) {
            this.center = center;
        }

        // Maid death/respawn
        public long getMaidDeathTime() {
            return maidDeathTime;
        }

        public void setMaidDeathTime(long time) {
            this.maidDeathTime = time;
        }

        public boolean isMaidDead() {
            return maidDeathTime >= 0;
        }

        public boolean canRespawnMaid(long currentTime) {
            return (
                isMaidDead() &&
                (currentTime - maidDeathTime) >= MAID_RESPAWN_DELAY
            );
        }

        // Loot chest management
        public List<BlockPos> getLootChestPositions() {
            return lootChestPositions;
        }

        public void addLootChestPosition(BlockPos pos) {
            if (!lootChestPositions.contains(pos)) {
                lootChestPositions.add(pos);
            }
        }

        // Kidnapper management
        public void addKidnapper(UUID kidnapperUUID) {
            linkedKidnapperUUIDs.add(kidnapperUUID);
        }

        public void removeKidnapper(UUID kidnapperUUID) {
            linkedKidnapperUUIDs.remove(kidnapperUUID);
        }

        public Set<UUID> getLinkedKidnappers() {
            return Collections.unmodifiableSet(linkedKidnapperUUIDs);
        }

        public boolean hasKidnapper(UUID kidnapperUUID) {
            return linkedKidnapperUUIDs.contains(kidnapperUUID);
        }

        public int getKidnapperCount() {
            return linkedKidnapperUUIDs.size();
        }

        // NBT Serialization
        public CompoundTag save() {
            CompoundTag tag = new CompoundTag();
            tag.putUUID("campId", campId);
            if (traderUUID != null) tag.putUUID("traderUUID", traderUUID);
            if (maidUUID != null) tag.putUUID("maidUUID", maidUUID);
            tag.putBoolean("isAlive", isAlive);
            if (center != null) {
                tag.putInt("centerX", center.getX());
                tag.putInt("centerY", center.getY());
                tag.putInt("centerZ", center.getZ());
            }
            // Save linked kidnappers
            if (!linkedKidnapperUUIDs.isEmpty()) {
                ListTag kidnapperList = new ListTag();
                for (UUID uuid : linkedKidnapperUUIDs) {
                    CompoundTag uuidTag = new CompoundTag();
                    uuidTag.putUUID("uuid", uuid);
                    kidnapperList.add(uuidTag);
                }
                tag.put("linkedKidnappers", kidnapperList);
            }
            // Save maid death time
            tag.putLong("maidDeathTime", maidDeathTime);
            // Save loot chest positions
            if (!lootChestPositions.isEmpty()) {
                ListTag lootList = new ListTag();
                for (BlockPos pos : lootChestPositions) {
                    CompoundTag posTag = new CompoundTag();
                    posTag.putInt("x", pos.getX());
                    posTag.putInt("y", pos.getY());
                    posTag.putInt("z", pos.getZ());
                    lootList.add(posTag);
                }
                tag.put("lootChestPositions", lootList);
            }
            return tag;
        }

        public static CampData load(CompoundTag tag) {
            UUID campId = tag.getUUID("campId");
            CampData data = new CampData(campId);
            if (tag.contains("traderUUID")) data.traderUUID = tag.getUUID(
                "traderUUID"
            );
            if (tag.contains("maidUUID")) data.maidUUID = tag.getUUID(
                "maidUUID"
            );
            data.isAlive = tag.getBoolean("isAlive");
            if (tag.contains("centerX")) {
                data.center = new BlockPos(
                    tag.getInt("centerX"),
                    tag.getInt("centerY"),
                    tag.getInt("centerZ")
                );
            }
            // Load linked kidnappers
            if (tag.contains("linkedKidnappers")) {
                ListTag kidnapperList = tag.getList(
                    "linkedKidnappers",
                    Tag.TAG_COMPOUND
                );
                for (int i = 0; i < kidnapperList.size(); i++) {
                    CompoundTag uuidTag = kidnapperList.getCompound(i);
                    if (uuidTag.contains("uuid")) {
                        data.linkedKidnapperUUIDs.add(uuidTag.getUUID("uuid"));
                    }
                }
            }
            // Load maid death time
            if (tag.contains("maidDeathTime")) {
                data.maidDeathTime = tag.getLong("maidDeathTime");
            }
            // Load loot chest positions
            if (tag.contains("lootChestPositions")) {
                ListTag lootList = tag.getList(
                    "lootChestPositions",
                    Tag.TAG_COMPOUND
                );
                for (int i = 0; i < lootList.size(); i++) {
                    CompoundTag posTag = lootList.getCompound(i);
                    data.lootChestPositions.add(
                        new BlockPos(
                            posTag.getInt("x"),
                            posTag.getInt("y"),
                            posTag.getInt("z")
                        )
                    );
                }
            }
            return data;
        }
    }

    // ==================== STATIC ACCESS ====================

    /**
     * Get the CampOwnership registry for a server level.
     */
    public static CampOwnership get(ServerLevel level) {
        return level
            .getDataStorage()
            .computeIfAbsent(
                CampOwnership::load,
                CampOwnership::new,
                DATA_NAME
            );
    }

    /**
     * Get the CampOwnership from a MinecraftServer.
     */
    public static CampOwnership get(MinecraftServer server) {
        ServerLevel overworld = server.overworld();
        return get(overworld);
    }

    // ==================== CAMP MANAGEMENT ====================

    /**
     * Register a new camp with its trader and maid.
     *
     * @param campId      The camp/structure UUID
     * @param traderUUID  The SlaveTrader entity UUID
     * @param maidUUID    The Maid entity UUID (can be null)
     * @param center      The center position of the camp
     */
    public void registerCamp(
        UUID campId,
        UUID traderUUID,
        @Nullable UUID maidUUID,
        BlockPos center
    ) {
        CampData data = new CampData(campId, traderUUID, maidUUID, center);
        camps.put(campId, data);
        setDirty();
    }

    /**
     * Check if a camp is alive (has living trader).
     *
     * @param campId The camp UUID
     * @return true if camp exists and is alive
     */
    public boolean isCampAlive(UUID campId) {
        CampData data = camps.get(campId);
        return data != null && data.isAlive();
    }

    /**
     * Get camp data by camp UUID.
     */
    @Nullable
    public CampData getCamp(UUID campId) {
        return camps.get(campId);
    }

    /**
     * Get camp data by trader UUID.
     */
    @Nullable
    public CampData getCampByTrader(UUID traderUUID) {
        for (CampData camp : camps.values()) {
            if (traderUUID.equals(camp.getTraderUUID())) {
                return camp;
            }
        }
        return null;
    }

    /**
     * Get camp data by maid UUID.
     */
    @Nullable
    public CampData getCampByMaid(UUID maidUUID) {
        for (CampData camp : camps.values()) {
            if (maidUUID.equals(camp.getMaidUUID())) {
                return camp;
            }
        }
        return null;
    }

    /**
     * Find camps near a position.
     *
     * @param center The center position
     * @param radius The search radius
     * @return List of camps within radius
     */
    public List<CampData> findCampsNear(BlockPos center, double radius) {
        List<CampData> nearby = new ArrayList<>();
        double radiusSq = radius * radius;

        for (CampData camp : camps.values()) {
            if (
                camp.getCenter() != null &&
                camp.getCenter().distSqr(center) <= radiusSq
            ) {
                nearby.add(camp);
            }
        }
        return nearby;
    }

    /**
     * Find the nearest alive camp to a position.
     *
     * @param pos    The position to search from
     * @param radius Maximum search radius
     * @return The nearest alive camp, or null
     */
    @Nullable
    public CampData findNearestAliveCamp(BlockPos pos, double radius) {
        CampData nearest = null;
        double nearestDistSq = radius * radius;

        for (CampData camp : camps.values()) {
            if (!camp.isAlive() || camp.getCenter() == null) continue;

            double distSq = camp.getCenter().distSqr(pos);
            if (distSq < nearestDistSq) {
                nearestDistSq = distSq;
                nearest = camp;
            }
        }
        return nearest;
    }

    /**
     * Remove a camp from the registry.
     */
    @Nullable
    public CampData removeCamp(UUID campId) {
        CampData removed = camps.remove(campId);
        if (removed != null) {
            setDirty();
        }
        return removed;
    }

    /**
     * Get all registered camps.
     */
    public Collection<CampData> getAllCamps() {
        return Collections.unmodifiableCollection(camps.values());
    }

    /**
     * Get all alive camps.
     */
    public List<CampData> getAliveCamps() {
        List<CampData> alive = new ArrayList<>();
        for (CampData camp : camps.values()) {
            if (camp.isAlive()) {
                alive.add(camp);
            }
        }
        return alive;
    }

    /**
     * Link a kidnapper to a camp.
     *
     * @param campId       The camp UUID
     * @param kidnapperUUID The kidnapper UUID
     */
    public void linkKidnapperToCamp(UUID campId, UUID kidnapperUUID) {
        CampData data = camps.get(campId);
        if (data != null) {
            data.addKidnapper(kidnapperUUID);
            setDirty();
        }
    }

    /**
     * Unlink a kidnapper from a camp.
     *
     * @param campId       The camp UUID
     * @param kidnapperUUID The kidnapper UUID
     */
    public void unlinkKidnapperFromCamp(UUID campId, UUID kidnapperUUID) {
        CampData data = camps.get(campId);
        if (data != null) {
            data.removeKidnapper(kidnapperUUID);
            setDirty();
        }
    }

    /**
     * Check if a kidnapper is linked to a camp.
     *
     * @param campId       The camp UUID
     * @param kidnapperUUID The kidnapper UUID
     * @return true if the kidnapper is linked to this camp
     */
    public boolean isKidnapperLinked(UUID campId, UUID kidnapperUUID) {
        CampData data = camps.get(campId);
        return data != null && data.hasKidnapper(kidnapperUUID);
    }

    /**
     * Find the camp a kidnapper is linked to.
     *
     * @param kidnapperUUID The kidnapper UUID
     * @return The camp data, or null if not linked
     */
    @Nullable
    public CampData findCampByKidnapper(UUID kidnapperUUID) {
        for (CampData camp : camps.values()) {
            if (camp.hasKidnapper(kidnapperUUID)) {
                return camp;
            }
        }
        return null;
    }

    /**
     * Mark a prisoner as processed (to avoid re-processing).
     *
     * @param prisonerId The prisoner's UUID
     */
    public void markPrisonerProcessed(UUID prisonerId) {
        processedPrisoners.add(prisonerId);
        setDirty();
    }

    /**
     * Check if a prisoner has been processed.
     *
     * @param prisonerId The prisoner's UUID
     * @return true if already processed
     */
    public boolean isPrisonerProcessed(UUID prisonerId) {
        return processedPrisoners.contains(prisonerId);
    }

    /**
     * Remove a prisoner from processed set.
     *
     * @param prisonerId The prisoner's UUID
     */
    public void unmarkPrisonerProcessed(UUID prisonerId) {
        if (processedPrisoners.remove(prisonerId)) {
            setDirty();
        }
    }

    /**
     * Get the set of processed prisoners for a camp (unmodifiable).
     *
     * @return Unmodifiable set of processed prisoner UUIDs
     */
    public Set<UUID> getProcessedPrisoners() {
        return Collections.unmodifiableSet(processedPrisoners);
    }

    // ==================== PERSISTENCE ====================

    @Override
    public @NotNull CompoundTag save(@NotNull CompoundTag tag) {
        // Save camps
        ListTag campList = new ListTag();
        for (CampData camp : camps.values()) {
            campList.add(camp.save());
        }
        tag.put("camps", campList);

        // Save processed prisoners
        ListTag processedList = new ListTag();
        for (UUID uuid : processedPrisoners) {
            CompoundTag uuidTag = new CompoundTag();
            uuidTag.putUUID("uuid", uuid);
            processedList.add(uuidTag);
        }
        tag.put("processedPrisoners", processedList);

        return tag;
    }

    public static CampOwnership load(CompoundTag tag) {
        CampOwnership registry = new CampOwnership();

        // Load camps
        if (tag.contains("camps")) {
            ListTag campList = tag.getList("camps", Tag.TAG_COMPOUND);
            for (int i = 0; i < campList.size(); i++) {
                CampData camp = CampData.load(campList.getCompound(i));
                registry.camps.put(camp.getCampId(), camp);
            }
        }

        // Load processed prisoners
        if (tag.contains("processedPrisoners")) {
            ListTag processedList = tag.getList(
                "processedPrisoners",
                Tag.TAG_COMPOUND
            );
            for (int i = 0; i < processedList.size(); i++) {
                CompoundTag uuidTag = processedList.getCompound(i);
                if (uuidTag.contains("uuid")) {
                    registry.processedPrisoners.add(uuidTag.getUUID("uuid"));
                }
            }
        }

        return registry;
    }
}