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

import com.mojang.blaze3d.pipeline.RenderTarget;
import com.mojang.blaze3d.pipeline.TextureTarget;
import com.mojang.blaze3d.shaders.Uniform;
import com.mojang.blaze3d.systems.RenderSystem;
import com.mojang.blaze3d.vertex.BufferBuilder;
import com.mojang.blaze3d.vertex.BufferUploader;
import com.mojang.blaze3d.vertex.DefaultVertexFormat;
import com.mojang.blaze3d.vertex.Tesselator;
import com.mojang.blaze3d.vertex.VertexFormat;
import com.vinlanx.explosionoverhaul.client.ConcussionAudioEffect;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.ShaderInstance;
import net.minecraft.util.Mth;
import net.neoforged.api.distmarker.Dist;
import net.neoforged.api.distmarker.OnlyIn;

@OnlyIn(value=Dist.CLIENT)
public class Blur {
    private static final int FADE_IN_TICKS = 40;
    private static final int FADE_OUT_TICKS = 100;
    private static Phase phase = Phase.IDLE;
    private static int holdTicks = 0;
    private static int ticksInPhase = 0;
    private static ShaderInstance shader;
    private static RenderTarget blurTarget;
    private static int lastWidth;
    private static int lastHeight;
    private static float currentIntensity;
    private static float targetIntensity;
    private static float currentDesaturation;
    public static boolean APPLY_TO_HUD;
    public static boolean APPLY_TO_HAND;

    public static boolean isActive() {
        return phase != Phase.IDLE;
    }

    public static float getCurrentIntensity() {
        return currentIntensity;
    }

    public static void setShader(ShaderInstance instance) {
        shader = instance;
    }

    public static void setDesaturation(float v) {
        currentDesaturation = Mth.m_14036_((float)v, (float)0.0f, (float)1.0f);
    }

    public static void start(int seconds) {
        Blur.start(seconds, 1.0f);
    }

    public static void start(int seconds, float intensity) {
        int newHoldTicks = Mth.m_14045_((int)seconds, (int)1, (int)100) * 20;
        float newIntensity = Mth.m_14036_((float)intensity, (float)0.0f, (float)1.0f);
        if (phase != Phase.IDLE) {
            targetIntensity = Mth.m_14036_((float)(targetIntensity + newIntensity), (float)0.0f, (float)1.0f);
            holdTicks = Math.min(2000, holdTicks + newHoldTicks);
            if (phase == Phase.FADE_OUT) {
                phase = Phase.HOLD;
                ticksInPhase = 0;
            }
        } else {
            holdTicks = newHoldTicks;
            ticksInPhase = 0;
            targetIntensity = newIntensity;
            phase = Phase.FADE_IN;
            currentIntensity = 0.0f;
        }
    }

    public static void stop() {
        phase = Phase.IDLE;
        ticksInPhase = 0;
        holdTicks = 0;
        currentIntensity = 0.0f;
        targetIntensity = 0.0f;
    }

    public static void onClientTick() {
        float intensity;
        Minecraft mc = Minecraft.getInstance();
        if (mc.m_91104_() || phase == Phase.IDLE) {
            return;
        }
        ++ticksInPhase;
        switch (phase) {
            case FADE_IN: {
                float t = Math.min(1.0f, (float)ticksInPhase / 40.0f);
                intensity = Blur.easeOutCubic(t) * targetIntensity;
                if (ticksInPhase < 40) break;
                phase = Phase.HOLD;
                ticksInPhase = 0;
                break;
            }
            case HOLD: {
                intensity = targetIntensity;
                if (ticksInPhase < holdTicks) break;
                phase = Phase.FADE_OUT;
                ticksInPhase = 0;
                break;
            }
            case FADE_OUT: {
                float t = Math.min(1.0f, (float)ticksInPhase / 100.0f);
                intensity = targetIntensity * (1.0f - Blur.easeInCubic(t));
                if (ticksInPhase < 100) break;
                currentIntensity = 0.0f;
                Blur.stop();
                return;
            }
            default: {
                intensity = 0.0f;
            }
        }
        currentIntensity = intensity;
        if (mc.player != null) {
            ConcussionAudioEffect.updateHeartbeat(mc.player, currentIntensity);
        }
    }

    public static void render(RenderStage stage) {
        if (phase == Phase.IDLE || shader == null) {
            return;
        }
        if (!Blur.shouldRenderStage(stage)) {
            return;
        }
        Minecraft mc = Minecraft.getInstance();
        if (mc == null) {
            return;
        }
        RenderTarget mainTarget = mc.m_91385_();
        if (mainTarget == null) {
            return;
        }
        Blur.ensureTarget(mainTarget.f_83915_, mainTarget.f_83916_);
        if (blurTarget == null) {
            return;
        }
        RenderSystem.disableDepthTest();
        RenderSystem.depthMask((boolean)false);
        RenderSystem.disableBlend();
        RenderSystem.setShaderColor((float)1.0f, (float)1.0f, (float)1.0f, (float)1.0f);
        blurTarget.m_83947_(true);
        RenderSystem.viewport((int)0, (int)0, (int)Blur.blurTarget.f_83915_, (int)Blur.blurTarget.f_83916_);
        Blur.renderFullscreen(mainTarget.m_83975_(), currentIntensity, mainTarget.f_83915_, mainTarget.f_83916_);
        mainTarget.m_83947_(true);
        RenderSystem.viewport((int)0, (int)0, (int)mainTarget.f_83915_, (int)mainTarget.f_83916_);
        Blur.renderFullscreen(blurTarget.m_83975_(), 0.0f, mainTarget.f_83915_, mainTarget.f_83916_);
        RenderSystem.enableBlend();
        RenderSystem.defaultBlendFunc();
        RenderSystem.depthMask((boolean)true);
        RenderSystem.enableDepthTest();
    }

    private static boolean shouldRenderStage(RenderStage stage) {
        if (APPLY_TO_HUD) {
            return stage == RenderStage.HUD;
        }
        if (APPLY_TO_HAND && Blur.isFirstPerson()) {
            return stage == RenderStage.HAND;
        }
        return stage == RenderStage.WORLD;
    }

    private static boolean isFirstPerson() {
        Minecraft mc = Minecraft.getInstance();
        if (mc == null) {
            return false;
        }
        return mc.options.m_92176_().m_90612_();
    }

    private static void ensureTarget(int width, int height) {
        if (blurTarget == null || width != lastWidth || height != lastHeight) {
            if (blurTarget != null) {
                blurTarget.m_83930_();
            }
            blurTarget = new TextureTarget(width, height, false, Minecraft.f_91002_);
            lastWidth = width;
            lastHeight = height;
        }
    }

    private static void renderFullscreen(int textureId, float intensity, int width, int height) {
        Uniform desatUniform;
        Uniform vignetteUniform;
        Uniform heartbeatUniform;
        Uniform outSizeUniform;
        Uniform inSizeUniform;
        RenderSystem.setShader(() -> shader);
        RenderSystem.setShaderTexture((int)0, (int)textureId);
        shader.m_173350_("DiffuseSampler", (Object)textureId);
        float clamped = Mth.m_14036_((float)intensity, (float)0.0f, (float)1.0f);
        Uniform intensityUniform = shader.m_173348_("Intensity");
        if (intensityUniform != null) {
            intensityUniform.m_5985_(clamped);
        }
        if ((inSizeUniform = shader.m_173348_("InSize")) != null) {
            inSizeUniform.m_7971_((float)width, (float)height);
        }
        if ((outSizeUniform = shader.m_173348_("OutSize")) != null) {
            outSizeUniform.m_7971_((float)width, (float)height);
        }
        if ((heartbeatUniform = shader.m_173348_("Heartbeat")) != null) {
            heartbeatUniform.m_5985_(ConcussionAudioEffect.getCurrentHeartbeatVisual());
        }
        if ((vignetteUniform = shader.m_173348_("Vignette")) != null) {
            vignetteUniform.m_5985_(1.0E-5f);
        }
        if ((desatUniform = shader.m_173348_("Desaturation")) != null) {
            desatUniform.m_5985_(clamped);
        }
        BufferBuilder builder = Tesselator.m_85913_().m_85915_();
        builder.m_166779_(VertexFormat.Mode.QUADS, DefaultVertexFormat.f_85817_);
        builder.m_5483_(-1.0, -1.0, 0.0).m_7421_(0.0f, 1.0f).m_5752_();
        builder.m_5483_(1.0, -1.0, 0.0).m_7421_(1.0f, 1.0f).m_5752_();
        builder.m_5483_(1.0, 1.0, 0.0).m_7421_(1.0f, 0.0f).m_5752_();
        builder.m_5483_(-1.0, 1.0, 0.0).m_7421_(0.0f, 0.0f).m_5752_();
        BufferUploader.m_231202_((BufferBuilder.RenderedBuffer)builder.m_231175_());
    }

    private static float easeOutCubic(float t) {
        float inv = 1.0f - t;
        return 1.0f - inv * inv * inv;
    }

    private static float easeInCubic(float t) {
        return t * t * t;
    }

    static {
        lastWidth = -1;
        lastHeight = -1;
        currentIntensity = 0.0f;
        targetIntensity = 1.0f;
        currentDesaturation = 0.0f;
        APPLY_TO_HUD = false;
        APPLY_TO_HAND = true;
    }

    private static enum Phase {
        IDLE,
        FADE_IN,
        HOLD,
        FADE_OUT;

    }

    public static enum RenderStage {
        WORLD,
        HAND,
        HUD;

    }
}