/*
 * Decompiled with CFR 0.152.
 */
package com.vinlanx.explosionoverhaul;

import com.vinlanx.explosionoverhaul.Config;
import com.vinlanx.explosionoverhaul.CraterDeformer;
import com.vinlanx.explosionoverhaul.ExplosionOverhaul;
import java.lang.invoke.LambdaMetafactory;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Function;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Position;
import net.minecraft.core.SectionPos;
import net.minecraft.core.Vec3i;
import net.minecraft.core.particles.ParticleOptions;
import net.minecraft.core.particles.ParticleTypes;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.tags.BlockTags;
import net.minecraft.util.RandomSource;
import net.minecraft.world.entity.item.FallingBlockEntity;
import net.minecraft.world.level.BlockGetter;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.LevelChunk;
import net.minecraft.world.level.levelgen.Heightmap;
import net.minecraft.world.phys.Vec3;

public class AsyncCraterManager {
    private static ExecutorService executor;
    private static final ConcurrentLinkedQueue<Job> activeJobs;
    private static final AtomicLong globalEpoch;
    private static final ConcurrentHashMap<ResourceKey<Level>, AtomicLong> dimensionEpochs;

    private static AtomicLong getDimensionEpoch(ResourceKey<Level> dimension) {
        return dimensionEpochs.computeIfAbsent(dimension, d -> new AtomicLong(0L));
    }

    private static long incrementDimensionEpoch(ResourceKey<Level> dimension) {
        return AsyncCraterManager.getDimensionEpoch(dimension).incrementAndGet();
    }

    public static synchronized void ensureExecutor() {
        if (executor != null && !executor.isShutdown()) {
            return;
        }
        int configured = (Integer)Config.COMMON.craterMaxThreads.get();
        int threads = configured == 0 ? Runtime.getRuntime().availableProcessors() : Math.max(1, configured);
        threads = Math.min(threads, 32);
        executor = Executors.newFixedThreadPool(threads, r -> {
            Thread t = new Thread(r, "EO-AsyncCrater");
            t.setDaemon(true);
            return t;
        });
    }

    public static void submit(ServerLevel level, Vec3 pos, float power) {
        if (!((Boolean)Config.COMMON.enableCraterDestruction.get()).booleanValue()) {
            return;
        }
        AsyncCraterManager.ensureExecutor();
        ResourceKey dim = level.m_46472_();
        Job job = new Job(level, pos, power, globalEpoch.get(), AsyncCraterManager.getDimensionEpoch((ResourceKey<Level>)dim).get());
        ((CompletableFuture)CompletableFuture.runAsync(job::compute, executor).thenRun(() -> {
            if (!job.isCancelled()) {
                activeJobs.add(job);
            }
        })).exceptionally(throwable -> {
            ExplosionOverhaul.LOGGER.warn("AsyncCraterManager: failed to compute crater job: {}", (Object)throwable.toString());
            return null;
        });
    }

    public static void onServerTick(MinecraftServer server) {
        Job job;
        if (activeJobs.isEmpty()) {
            return;
        }
        int size = activeJobs.size();
        for (int i = 0; i < size && (job = activeJobs.poll()) != null; ++i) {
            if (job.isCancelled()) continue;
            job.applyBatch();
            if (job.isDone()) continue;
            activeJobs.add(job);
        }
    }

    public static void onLevelUnload(ServerLevel level) {
        if (level == null) {
            return;
        }
        ResourceKey dim = level.m_46472_();
        AsyncCraterManager.incrementDimensionEpoch((ResourceKey<Level>)dim);
        activeJobs.removeIf(job -> job.isForDimension((ResourceKey<Level>)dim));
    }

    public static synchronized void shutdown() {
        globalEpoch.incrementAndGet();
        dimensionEpochs.clear();
        activeJobs.clear();
        if (executor != null) {
            executor.shutdownNow();
            try {
                executor.awaitTermination(1L, TimeUnit.SECONDS);
            }
            catch (InterruptedException interruptedException) {
                // empty catch block
            }
            executor = null;
        }
    }

    static {
        activeJobs = new ConcurrentLinkedQueue();
        globalEpoch = new AtomicLong(0L);
        dimensionEpochs = new ConcurrentHashMap();
    }

    private static class Job {
        private final Vec3 explosionPos;
        private final float power;
        private final ResourceKey<Level> dimensionKey;
        private final long submitGlobalEpoch;
        private final long submitDimensionEpoch;
        private volatile List<Candidate> candidates;
        private volatile boolean computed;
        private final ServerLevel levelRef;
        private int appliedIndex;
        private final List<Candidate> ordered;
        private final RandomSource random;
        private float[] rayEnergy;
        private boolean[] rayDepleted;
        private int rayCount;
        private Set<BlockPos> destroyedPositions = new HashSet<BlockPos>();

        Job(ServerLevel level, Vec3 pos, float power, long submitGlobalEpoch, long submitDimensionEpoch) {
            this.levelRef = level;
            this.dimensionKey = level.m_46472_();
            this.submitGlobalEpoch = submitGlobalEpoch;
            this.submitDimensionEpoch = submitDimensionEpoch;
            this.explosionPos = pos;
            this.power = power;
            this.candidates = new ArrayList<Candidate>();
            this.ordered = new ArrayList<Candidate>();
            this.random = RandomSource.m_216327_();
        }

        /*
         * WARNING - Removed try catching itself - possible behaviour change.
         */
        void compute() {
            try {
                double multiplier = (Double)Config.COMMON.craterSizeMultiplier.get();
                double baseRadius = CraterDeformer.calculateRadius(this.power);
                double finalRadius = baseRadius * multiplier;
                if (finalRadius <= 0.0) {
                    this.computed = true;
                    return;
                }
                boolean large = this.power >= 40.0f;
                double coreRatio = (Double)Config.COMMON.craterCoreRatio.get();
                double coreRadius = large ? finalRadius * coreRatio : 0.0;
                int searchRadius = (int)Math.ceil(finalRadius);
                BlockPos centerPos = BlockPos.m_274446_((Position)this.explosionPos);
                RandomSource rnd = RandomSource.m_216327_();
                if (large) {
                    HashSet<BlockPos> corePositions = new HashSet<BlockPos>();
                    for (int x = -searchRadius; x <= searchRadius; ++x) {
                        for (int y = -searchRadius; y <= searchRadius; ++y) {
                            for (int z = -searchRadius; z <= searchRadius; ++z) {
                                double noise;
                                BlockPos p = centerPos.m_7918_(x, y, z);
                                double dist = Math.sqrt(p.m_123331_((Vec3i)centerPos));
                                if (!(dist <= coreRadius * (noise = 1.0 - rnd.m_188500_() * 0.3)) || !corePositions.add(p)) continue;
                                this.candidates.add(new Candidate(p, -1, 0, true));
                            }
                        }
                    }
                }
                int numberOfRays = (int)Math.max(200.0, Math.min(large ? 25000.0 : 75000.0, finalRadius * (double)(large ? 75 : 150)));
                double goldenRatio = (1.0 + Math.sqrt(5.0)) / 2.0;
                double angleIncrement = Math.PI * 2 * goldenRatio;
                double stepIncrement = 0.4;
                double startStep = large ? coreRadius * 0.8 : 0.0;
                this.rayCount = numberOfRays;
                for (int i = 0; i < numberOfRays; ++i) {
                    double t = (double)i / (double)numberOfRays;
                    double inclination = Math.acos(1.0 - 2.0 * t);
                    double azimuth = angleIncrement * (double)i;
                    Vec3 dir = new Vec3(Math.cos(azimuth) * Math.sin(inclination), Math.sin(azimuth) * Math.sin(inclination), Math.cos(inclination)).m_82541_();
                    int stepIndex = 0;
                    BlockPos lastPos = null;
                    for (double step = startStep; step < finalRadius; step += stepIncrement) {
                        BlockPos p = BlockPos.m_274446_((Position)this.explosionPos.m_82549_(dir.m_82490_(step)));
                        if (p.equals(lastPos)) continue;
                        lastPos = p;
                        this.candidates.add(new Candidate(p, i, stepIndex, false));
                        ++stepIndex;
                    }
                }
                ArrayList<Candidate> coreBlocks = new ArrayList<Candidate>();
                ArrayList<Candidate> rayBlocks = new ArrayList<Candidate>();
                for (Candidate c : this.candidates) {
                    if (c.core) {
                        coreBlocks.add(c);
                        continue;
                    }
                    rayBlocks.add(c);
                }
                rayBlocks.sort((a, b) -> {
                    int cmp = Integer.compare(a.rayId, b.rayId);
                    if (cmp != 0) {
                        return cmp;
                    }
                    return Integer.compare(a.stepIndex, b.stepIndex);
                });
                this.ordered.addAll(coreBlocks);
                this.ordered.addAll(rayBlocks);
            }
            finally {
                this.computed = true;
            }
        }

        boolean isCancelled() {
            long currentDimEpoch;
            if (this.submitGlobalEpoch != globalEpoch.get()) {
                return true;
            }
            AtomicLong dimEpoch = dimensionEpochs.get(this.dimensionKey);
            long l = currentDimEpoch = dimEpoch == null ? 0L : dimEpoch.get();
            if (this.submitDimensionEpoch != currentDimEpoch) {
                return true;
            }
            return this.levelRef.m_7654_() == null;
        }

        boolean isForDimension(ResourceKey<Level> dim) {
            return this.dimensionKey.equals(dim);
        }

        boolean isDone() {
            return this.computed && this.appliedIndex >= this.ordered.size();
        }

        /*
         * Unable to fully structure code
         */
        void applyBatch() {
            block37: {
                block38: {
                    if (!this.computed) {
                        return;
                    }
                    if (this.isCancelled()) {
                        this.appliedIndex = this.ordered.size();
                        return;
                    }
                    budget = Math.max(100, (Integer)Config.COMMON.craterApplyBlocksPerTick.get());
                    maxFallingPerTick = Math.max(0, (Integer)Config.COMMON.craterMaxFallingBlocksPerTick.get());
                    spawnedFalling = 0;
                    if (this.rayEnergy == null) {
                        multiplier = (Double)Config.COMMON.craterSizeMultiplier.get();
                        large = this.power >= 40.0f;
                        base = (float)((double)(this.power * (large != false ? 4.0f : 7.5f)) * multiplier);
                        this.rayEnergy = new float[Math.max(1, this.rayCount)];
                        this.rayDepleted = new boolean[Math.max(1, this.rayCount)];
                        rnd = this.levelRef.m_213780_();
                        for (i = 0; i < this.rayEnergy.length; ++i) {
                            this.rayEnergy[i] = base * (0.75f + rnd.m_188501_() * 0.5f);
                        }
                    }
                    end = Math.min(this.appliedIndex + budget, this.ordered.size());
                    direct = (Boolean)Config.COMMON.enableDirectChunkWrites.get();
                    if (direct) break block38;
                    while (this.appliedIndex < end) {
                        block39: {
                            block41: {
                                block40: {
                                    c = this.ordered.get(this.appliedIndex);
                                    pos = c.pos;
                                    if (!this.levelRef.m_46749_(pos) || this.levelRef.m_151570_(pos) || !c.core && this.rayDepleted[rayId = Math.max(0, c.rayId)] || this.destroyedPositions.contains(pos) || (state = this.levelRef.m_8055_(pos)).m_60795_()) break block39;
                                    if (!((Boolean)Config.COMMON.enableCraterDestruction.get()).booleanValue()) {
                                        this.appliedIndex = this.ordered.size();
                                        break block37;
                                    }
                                    resistance = state.m_60800_((BlockGetter)this.levelRef, pos);
                                    if (resistance < 0.0f) break block39;
                                    if (!ExplosionOverhaul.isBlockStateBlacklisted(state) && !state.m_60734_().m_204297_().m_203656_(BlockTags.f_13070_) && !state.m_60713_(Blocks.f_50722_)) break block40;
                                    if (!c.core) {
                                        rayId = Math.max(0, c.rayId);
                                        this.rayDepleted[rayId] = true;
                                    }
                                    break block39;
                                }
                                if (!(resistance > Job.calculateMaxResistance(this.power))) break block41;
                                if (!c.core) {
                                    rayId = Math.max(0, c.rayId);
                                    this.rayDepleted[rayId] = true;
                                }
                                break block39;
                            }
                            if (c.core) ** GOTO lbl-1000
                            v0 = rayId = Math.max(0, c.rayId);
                            this.rayEnergy[v0] = this.rayEnergy[v0] - (resistance + 0.3f);
                            if (this.rayEnergy[rayId] <= 0.0f) {
                                this.rayDepleted[rayId] = true;
                            } else lbl-1000:
                            // 2 sources

                            {
                                v1 = allowFalling = this.power <= 20.0f && (Boolean)Config.COMMON.enableFallingBlocks.get() != false && spawnedFalling < maxFallingPerTick;
                                if (allowFalling) {
                                    inner = c.core != false || c.stepIndex <= 5;
                                    v2 = chance = inner != false ? 0.35 : 0.15;
                                    if (this.random.m_188500_() < chance) {
                                        falling = FallingBlockEntity.m_201971_((Level)this.levelRef, (BlockPos)pos, (BlockState)state);
                                        falling.m_6034_((double)pos.m_123341_() + 0.5, (double)pos.m_123342_() + 0.5, (double)pos.m_123343_() + 0.5);
                                        motionDir = Vec3.m_82512_((Vec3i)pos).m_82546_(this.explosionPos).m_82541_();
                                        powerMul = 0.4 + this.random.m_188500_() * 0.6;
                                        falling.m_20334_(motionDir.f_82479_ * powerMul + (this.random.m_188500_() - 0.5) * 0.3, motionDir.f_82480_ * powerMul + 0.4 + this.random.m_188500_() * 0.3, motionDir.f_82481_ * powerMul + (this.random.m_188500_() - 0.5) * 0.3);
                                        ++spawnedFalling;
                                    }
                                }
                                this.levelRef.m_7731_(pos, Blocks.f_50016_.m_49966_(), 2);
                                this.destroyedPositions.add(pos);
                            }
                        }
                        ++this.appliedIndex;
                    }
                    break block37;
                }
                maxChunks = Math.max(1, (Integer)Config.COMMON.craterChunksPerTick.get());
                byChunk = new LinkedHashMap<LevelChunk, List>();
                i = this.appliedIndex;
                while (i < end && byChunk.size() < maxChunks) {
                    c = this.ordered.get(i);
                    pos = c.pos;
                    if (!this.levelRef.m_46749_(pos) || this.levelRef.m_151570_(pos)) {
                        ++i;
                        continue;
                    }
                    chunk = this.levelRef.m_46745_(pos);
                    byChunk.computeIfAbsent(chunk, (Function<LevelChunk, List>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)Ljava/lang/Object;, lambda$applyBatch$1(net.minecraft.world.level.chunk.LevelChunk ), (Lnet/minecraft/world/level/chunk/LevelChunk;)Ljava/util/List;)()).add(c);
                    ++i;
                }
                for (Map.Entry<K, V> e : byChunk.entrySet()) {
                    chunk = (LevelChunk)e.getKey();
                    list = (List)e.getValue();
                    list.sort((Comparator)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;Ljava/lang/Object;)I, lambda$applyBatch$2(com.vinlanx.explosionoverhaul.AsyncCraterManager$Job$Candidate com.vinlanx.explosionoverhaul.AsyncCraterManager$Job$Candidate ), (Lcom/vinlanx/explosionoverhaul/AsyncCraterManager$Job$Candidate;Lcom/vinlanx/explosionoverhaul/AsyncCraterManager$Job$Candidate;)I)());
                    modifiedSections = new HashSet<SectionPos>();
                    toRelight = new ArrayList<BlockPos>();
                    relightBudget = Math.min(256, list.size());
                    for (Candidate c : list) {
                        if (!c.core && this.rayDepleted[rayId = Math.max(0, c.rayId)]) {
                            ++this.appliedIndex;
                            continue;
                        }
                        pos = c.pos;
                        if (this.destroyedPositions.contains(pos)) {
                            ++this.appliedIndex;
                            continue;
                        }
                        if (!((Boolean)Config.COMMON.enableCraterDestruction.get()).booleanValue()) {
                            this.appliedIndex = this.ordered.size();
                            break;
                        }
                        state = this.levelRef.m_8055_(pos);
                        if (state.m_60795_()) {
                            ++this.appliedIndex;
                            continue;
                        }
                        resistance = state.m_60800_((BlockGetter)this.levelRef, pos);
                        if (resistance < 0.0f) {
                            ++this.appliedIndex;
                            continue;
                        }
                        if (ExplosionOverhaul.isBlockStateBlacklisted(state) || state.m_60734_().m_204297_().m_203656_(BlockTags.f_13070_) || state.m_60713_(Blocks.f_50722_)) {
                            if (!c.core) {
                                rayId = Math.max(0, c.rayId);
                                this.rayDepleted[rayId] = true;
                            }
                            ++this.appliedIndex;
                            continue;
                        }
                        if (resistance > Job.calculateMaxResistance(this.power)) {
                            if (!c.core) {
                                rayId = Math.max(0, c.rayId);
                                this.rayDepleted[rayId] = true;
                            }
                            ++this.appliedIndex;
                            continue;
                        }
                        if (!c.core) {
                            v3 = rayId = Math.max(0, c.rayId);
                            this.rayEnergy[v3] = this.rayEnergy[v3] - (resistance + 0.3f);
                            if (this.rayEnergy[rayId] <= 0.0f) {
                                this.rayDepleted[rayId] = true;
                                ++this.appliedIndex;
                                continue;
                            }
                        }
                        if (state.m_155947_()) {
                            this.levelRef.m_46961_(pos, true);
                            ++this.appliedIndex;
                            continue;
                        }
                        secIdx = chunk.m_151564_(pos.m_123342_());
                        if (secIdx < 0 || secIdx >= chunk.m_7103_().length) {
                            ++this.appliedIndex;
                            continue;
                        }
                        section = chunk.m_7103_()[secIdx];
                        old = section.m_62982_(lx = pos.m_123341_() & 15, ly = pos.m_123342_() & 15, lz = pos.m_123343_() & 15);
                        if (old.m_60795_()) {
                            ++this.appliedIndex;
                            continue;
                        }
                        section.m_62986_(lx, ly, lz, Blocks.f_50016_.m_49966_());
                        this.destroyedPositions.add(pos);
                        for (Map.Entry m : chunk.m_6890_()) {
                            type = (Heightmap.Types)m.getKey();
                            if (type != Heightmap.Types.MOTION_BLOCKING && type != Heightmap.Types.MOTION_BLOCKING_NO_LEAVES && type != Heightmap.Types.OCEAN_FLOOR && type != Heightmap.Types.WORLD_SURFACE) continue;
                            ((Heightmap)m.getValue()).m_64249_(lx, pos.m_123342_(), lz, Blocks.f_50016_.m_49966_());
                        }
                        this.levelRef.m_7260_(pos, old, Blocks.f_50016_.m_49966_(), 2);
                        modifiedSections.add(SectionPos.m_123199_((BlockPos)pos));
                        if (toRelight.size() < relightBudget) {
                            toRelight.add(pos.m_7949_());
                        }
                        v4 = allowFalling = this.power <= 20.0f && (Boolean)Config.COMMON.enableFallingBlocks.get() != false && spawnedFalling < maxFallingPerTick;
                        if (allowFalling) {
                            inner = c.core != false || c.stepIndex <= 5;
                            v5 = chance = inner != false ? 0.35 : 0.15;
                            if (this.random.m_188500_() < chance) {
                                falling = FallingBlockEntity.m_201971_((Level)this.levelRef, (BlockPos)pos, (BlockState)old);
                                falling.m_6034_((double)pos.m_123341_() + 0.5, (double)pos.m_123342_() + 0.5, (double)pos.m_123343_() + 0.5);
                                motionDir = Vec3.m_82512_((Vec3i)pos).m_82546_(this.explosionPos).m_82541_();
                                powerMul = 0.4 + this.random.m_188500_() * 0.6;
                                falling.m_20334_(motionDir.f_82479_ * powerMul + (this.random.m_188500_() - 0.5) * 0.3, motionDir.f_82480_ * powerMul + 0.4 + this.random.m_188500_() * 0.3, motionDir.f_82481_ * powerMul + (this.random.m_188500_() - 0.5) * 0.3);
                                ++spawnedFalling;
                            }
                        }
                        ++this.appliedIndex;
                    }
                    chunk.m_8092_(true);
                    light = this.levelRef.m_7726_().m_7827_();
                    for (SectionPos sp : modifiedSections) {
                        sec = chunk.m_7103_()[chunk.m_151564_(sp.m_123206_() << 4)];
                        empty = sec.m_188008_();
                        light.m_6191_(sp, empty);
                    }
                    for (BlockPos rp : toRelight) {
                        light.m_7174_(rp);
                        light.m_7174_(rp.m_7494_());
                    }
                    light.m_9353_((ChunkAccess)chunk, true);
                }
            }
            if (this.isDone()) {
                this.levelRef.m_8767_((ParticleOptions)ParticleTypes.f_123812_, this.explosionPos.f_82479_, this.explosionPos.f_82480_, this.explosionPos.f_82481_, 1, 0.0, 0.0, 0.0, 0.0);
            }
        }

        private static float calculateMaxResistance(float power) {
            float maxRes = power <= 4.0f ? 10.0f : (power <= 10.0f ? 10.0f + (power - 4.0f) * 10.0f / 6.0f : (power <= 25.0f ? 20.0f + (power - 10.0f) * 10.0f / 15.0f : (power <= 40.0f ? 30.0f + (power - 25.0f) * 10.0f / 15.0f : (power <= 70.0f ? 40.0f + (power - 40.0f) * 10.0f / 30.0f : Float.MAX_VALUE))));
            return maxRes;
        }

        private static /* synthetic */ int lambda$applyBatch$2(Candidate a, Candidate b) {
            if (a.core && !b.core) {
                return -1;
            }
            if (!a.core && b.core) {
                return 1;
            }
            if (a.core && b.core) {
                return 0;
            }
            int cmp = Integer.compare(a.rayId, b.rayId);
            if (cmp != 0) {
                return cmp;
            }
            return Integer.compare(a.stepIndex, b.stepIndex);
        }

        private static /* synthetic */ List lambda$applyBatch$1(LevelChunk k) {
            return new ArrayList();
        }

        private static class Candidate {
            final BlockPos pos;
            final int rayId;
            final int stepIndex;
            final boolean core;

            Candidate(BlockPos pos, int rayId, int stepIndex, boolean core) {
                this.pos = pos;
                this.rayId = rayId;
                this.stepIndex = stepIndex;
                this.core = core;
            }
        }
    }
}