/*
 * Decompiled with CFR 0.152.
 */
package net.minecraft.client.model;

import com.mojang.blaze3d.vertex.PoseStack;
import java.util.Set;
import java.util.function.Function;
import net.minecraft.client.model.AnimationUtils;
import net.minecraft.client.model.ArmedModel;
import net.minecraft.client.model.BabyModelTransform;
import net.minecraft.client.model.EntityModel;
import net.minecraft.client.model.HeadedModel;
import net.minecraft.client.model.SpearAnimations;
import net.minecraft.client.model.geom.ModelPart;
import net.minecraft.client.model.geom.PartPose;
import net.minecraft.client.model.geom.builders.CubeDeformation;
import net.minecraft.client.model.geom.builders.CubeListBuilder;
import net.minecraft.client.model.geom.builders.MeshDefinition;
import net.minecraft.client.model.geom.builders.MeshTransformer;
import net.minecraft.client.model.geom.builders.PartDefinition;
import net.minecraft.client.renderer.entity.ArmorModelSet;
import net.minecraft.client.renderer.entity.state.ArmedEntityRenderState;
import net.minecraft.client.renderer.entity.state.HumanoidRenderState;
import net.minecraft.client.renderer.rendertype.RenderType;
import net.minecraft.client.renderer.rendertype.RenderTypes;
import net.minecraft.resources.Identifier;
import net.minecraft.util.Ease;
import net.minecraft.util.Mth;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.entity.HumanoidArm;
import net.minecraft.world.item.ItemStack;

public class HumanoidModel<T extends HumanoidRenderState>
extends EntityModel<T>
implements ArmedModel<T>,
HeadedModel {
    public static final MeshTransformer BABY_TRANSFORMER = new BabyModelTransform(true, 16.0f, 0.0f, 2.0f, 2.0f, 24.0f, Set.of("head"));
    public static final float OVERLAY_SCALE = 0.25f;
    public static final float HAT_OVERLAY_SCALE = 0.5f;
    public static final float LEGGINGS_OVERLAY_SCALE = -0.1f;
    private static final float DUCK_WALK_ROTATION = 0.005f;
    private static final float SPYGLASS_ARM_ROT_Y = 0.2617994f;
    private static final float SPYGLASS_ARM_ROT_X = 1.9198622f;
    private static final float SPYGLASS_ARM_CROUCH_ROT_X = 0.2617994f;
    private static final float HIGHEST_SHIELD_BLOCKING_ANGLE = -1.3962634f;
    private static final float LOWEST_SHIELD_BLOCKING_ANGLE = 0.43633232f;
    private static final float HORIZONTAL_SHIELD_MOVEMENT_LIMIT = 0.5235988f;
    public static final float TOOT_HORN_XROT_BASE = 1.4835298f;
    public static final float TOOT_HORN_YROT_BASE = 0.5235988f;
    public final ModelPart head;
    public final ModelPart hat;
    public final ModelPart body;
    public final ModelPart rightArm;
    public final ModelPart leftArm;
    public final ModelPart rightLeg;
    public final ModelPart leftLeg;

    public HumanoidModel(ModelPart root) {
        this(root, RenderTypes::entityCutoutNoCull);
    }

    public HumanoidModel(ModelPart root, Function<Identifier, RenderType> renderType) {
        super(root, renderType);
        this.head = root.getChild("head");
        this.hat = this.head.getChild("hat");
        this.body = root.getChild("body");
        this.rightArm = root.getChild("right_arm");
        this.leftArm = root.getChild("left_arm");
        this.rightLeg = root.getChild("right_leg");
        this.leftLeg = root.getChild("left_leg");
    }

    public static MeshDefinition createMesh(CubeDeformation g, float yOffset) {
        MeshDefinition mesh = new MeshDefinition();
        PartDefinition root = mesh.getRoot();
        PartDefinition head = root.addOrReplaceChild("head", CubeListBuilder.create().texOffs(0, 0).addBox(-4.0f, -8.0f, -4.0f, 8.0f, 8.0f, 8.0f, g), PartPose.offset(0.0f, 0.0f + yOffset, 0.0f));
        head.addOrReplaceChild("hat", CubeListBuilder.create().texOffs(32, 0).addBox(-4.0f, -8.0f, -4.0f, 8.0f, 8.0f, 8.0f, g.extend(0.5f)), PartPose.ZERO);
        root.addOrReplaceChild("body", CubeListBuilder.create().texOffs(16, 16).addBox(-4.0f, 0.0f, -2.0f, 8.0f, 12.0f, 4.0f, g), PartPose.offset(0.0f, 0.0f + yOffset, 0.0f));
        root.addOrReplaceChild("right_arm", CubeListBuilder.create().texOffs(40, 16).addBox(-3.0f, -2.0f, -2.0f, 4.0f, 12.0f, 4.0f, g), PartPose.offset(-5.0f, 2.0f + yOffset, 0.0f));
        root.addOrReplaceChild("left_arm", CubeListBuilder.create().texOffs(40, 16).mirror().addBox(-1.0f, -2.0f, -2.0f, 4.0f, 12.0f, 4.0f, g), PartPose.offset(5.0f, 2.0f + yOffset, 0.0f));
        root.addOrReplaceChild("right_leg", CubeListBuilder.create().texOffs(0, 16).addBox(-2.0f, 0.0f, -2.0f, 4.0f, 12.0f, 4.0f, g), PartPose.offset(-1.9f, 12.0f + yOffset, 0.0f));
        root.addOrReplaceChild("left_leg", CubeListBuilder.create().texOffs(0, 16).mirror().addBox(-2.0f, 0.0f, -2.0f, 4.0f, 12.0f, 4.0f, g), PartPose.offset(1.9f, 12.0f + yOffset, 0.0f));
        return mesh;
    }

    public static ArmorModelSet<MeshDefinition> createArmorMeshSet(CubeDeformation innerDeformation, CubeDeformation outerDeformation) {
        return HumanoidModel.createArmorMeshSet(HumanoidModel::createBaseArmorMesh, innerDeformation, outerDeformation);
    }

    protected static ArmorModelSet<MeshDefinition> createArmorMeshSet(Function<CubeDeformation, MeshDefinition> baseFactory, CubeDeformation innerDeformation, CubeDeformation outerDeformation) {
        MeshDefinition head = baseFactory.apply(outerDeformation);
        head.getRoot().retainPartsAndChildren(Set.of("head"));
        MeshDefinition chest = baseFactory.apply(outerDeformation);
        chest.getRoot().retainExactParts(Set.of("body", "left_arm", "right_arm"));
        MeshDefinition legs = baseFactory.apply(innerDeformation);
        legs.getRoot().retainExactParts(Set.of("left_leg", "right_leg", "body"));
        MeshDefinition feet = baseFactory.apply(outerDeformation);
        feet.getRoot().retainExactParts(Set.of("left_leg", "right_leg"));
        return new ArmorModelSet<MeshDefinition>(head, chest, legs, feet);
    }

    private static MeshDefinition createBaseArmorMesh(CubeDeformation g) {
        MeshDefinition mesh = HumanoidModel.createMesh(g, 0.0f);
        PartDefinition root = mesh.getRoot();
        root.addOrReplaceChild("right_leg", CubeListBuilder.create().texOffs(0, 16).addBox(-2.0f, 0.0f, -2.0f, 4.0f, 12.0f, 4.0f, g.extend(-0.1f)), PartPose.offset(-1.9f, 12.0f, 0.0f));
        root.addOrReplaceChild("left_leg", CubeListBuilder.create().texOffs(0, 16).mirror().addBox(-2.0f, 0.0f, -2.0f, 4.0f, 12.0f, 4.0f, g.extend(-0.1f)), PartPose.offset(1.9f, 12.0f, 0.0f));
        return mesh;
    }

    @Override
    public void setupAnim(T state) {
        boolean rightHanded;
        super.setupAnim(state);
        ArmPose leftArmPose = ((HumanoidRenderState)state).leftArmPose;
        ArmPose rightArmPose = ((HumanoidRenderState)state).rightArmPose;
        float swimAmount = ((HumanoidRenderState)state).swimAmount;
        boolean fallFlying = ((HumanoidRenderState)state).isFallFlying;
        this.head.xRot = ((HumanoidRenderState)state).xRot * ((float)Math.PI / 180);
        this.head.yRot = ((HumanoidRenderState)state).yRot * ((float)Math.PI / 180);
        if (fallFlying) {
            this.head.xRot = -0.7853982f;
        } else if (swimAmount > 0.0f) {
            this.head.xRot = Mth.rotLerpRad(swimAmount, this.head.xRot, -0.7853982f);
        }
        float animationPos = ((HumanoidRenderState)state).walkAnimationPos;
        float animationSpeed = ((HumanoidRenderState)state).walkAnimationSpeed;
        this.rightArm.xRot = Mth.cos(animationPos * 0.6662f + (float)Math.PI) * 2.0f * animationSpeed * 0.5f / ((HumanoidRenderState)state).speedValue;
        this.leftArm.xRot = Mth.cos(animationPos * 0.6662f) * 2.0f * animationSpeed * 0.5f / ((HumanoidRenderState)state).speedValue;
        this.rightLeg.xRot = Mth.cos(animationPos * 0.6662f) * 1.4f * animationSpeed / ((HumanoidRenderState)state).speedValue;
        this.leftLeg.xRot = Mth.cos(animationPos * 0.6662f + (float)Math.PI) * 1.4f * animationSpeed / ((HumanoidRenderState)state).speedValue;
        this.rightLeg.yRot = 0.005f;
        this.leftLeg.yRot = -0.005f;
        this.rightLeg.zRot = 0.005f;
        this.leftLeg.zRot = -0.005f;
        if (((HumanoidRenderState)state).isPassenger) {
            this.rightArm.xRot += -0.62831855f;
            this.leftArm.xRot += -0.62831855f;
            this.rightLeg.xRot = -1.4137167f;
            this.rightLeg.yRot = 0.31415927f;
            this.rightLeg.zRot = 0.07853982f;
            this.leftLeg.xRot = -1.4137167f;
            this.leftLeg.yRot = -0.31415927f;
            this.leftLeg.zRot = -0.07853982f;
        }
        boolean bl = rightHanded = ((HumanoidRenderState)state).mainArm == HumanoidArm.RIGHT;
        if (((HumanoidRenderState)state).isUsingItem) {
            boolean mainHandUsed;
            boolean bl2 = mainHandUsed = ((HumanoidRenderState)state).useItemHand == InteractionHand.MAIN_HAND;
            if (mainHandUsed == rightHanded) {
                this.poseRightArm(state);
                this.poseLeftArm(state);
            } else {
                this.poseLeftArm(state);
                this.poseRightArm(state);
            }
        } else {
            boolean twoHandedOffhand;
            boolean bl3 = twoHandedOffhand = rightHanded ? leftArmPose.isTwoHanded() : rightArmPose.isTwoHanded();
            if (rightHanded != twoHandedOffhand) {
                this.poseLeftArm(state);
                this.poseRightArm(state);
            } else {
                this.poseRightArm(state);
                this.poseLeftArm(state);
            }
        }
        this.setupAttackAnimation(state);
        if (((HumanoidRenderState)state).isCrouching) {
            this.body.xRot = 0.5f;
            this.rightArm.xRot += 0.4f;
            this.leftArm.xRot += 0.4f;
            this.rightLeg.z += 4.0f;
            this.leftLeg.z += 4.0f;
            this.head.y += 4.2f;
            this.body.y += 3.2f;
            this.leftArm.y += 3.2f;
            this.rightArm.y += 3.2f;
        }
        if (rightArmPose != ArmPose.SPYGLASS) {
            AnimationUtils.bobModelPart(this.rightArm, ((HumanoidRenderState)state).ageInTicks, 1.0f);
        }
        if (leftArmPose != ArmPose.SPYGLASS) {
            AnimationUtils.bobModelPart(this.leftArm, ((HumanoidRenderState)state).ageInTicks, -1.0f);
        }
        if (swimAmount > 0.0f) {
            float leftArmSwimAmount;
            float swimPos = animationPos % 26.0f;
            HumanoidArm attackArm = ((HumanoidRenderState)state).attackArm;
            float rightArmSwimAmount = ((HumanoidRenderState)state).rightArmPose == ArmPose.SPEAR || attackArm == HumanoidArm.RIGHT && ((HumanoidRenderState)state).attackTime > 0.0f ? 0.0f : swimAmount;
            float f = leftArmSwimAmount = ((HumanoidRenderState)state).leftArmPose == ArmPose.SPEAR || attackArm == HumanoidArm.LEFT && ((HumanoidRenderState)state).attackTime > 0.0f ? 0.0f : swimAmount;
            if (!((HumanoidRenderState)state).isUsingItem) {
                if (swimPos < 14.0f) {
                    this.leftArm.xRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.xRot, 0.0f);
                    this.rightArm.xRot = Mth.lerp(rightArmSwimAmount, this.rightArm.xRot, 0.0f);
                    this.leftArm.yRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.yRot, (float)Math.PI);
                    this.rightArm.yRot = Mth.lerp(rightArmSwimAmount, this.rightArm.yRot, (float)Math.PI);
                    this.leftArm.zRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.zRot, (float)Math.PI + 1.8707964f * this.quadraticArmUpdate(swimPos) / this.quadraticArmUpdate(14.0f));
                    this.rightArm.zRot = Mth.lerp(rightArmSwimAmount, this.rightArm.zRot, (float)Math.PI - 1.8707964f * this.quadraticArmUpdate(swimPos) / this.quadraticArmUpdate(14.0f));
                } else if (swimPos >= 14.0f && swimPos < 22.0f) {
                    internalSwimPos = (swimPos - 14.0f) / 8.0f;
                    this.leftArm.xRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.xRot, 1.5707964f * internalSwimPos);
                    this.rightArm.xRot = Mth.lerp(rightArmSwimAmount, this.rightArm.xRot, 1.5707964f * internalSwimPos);
                    this.leftArm.yRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.yRot, (float)Math.PI);
                    this.rightArm.yRot = Mth.lerp(rightArmSwimAmount, this.rightArm.yRot, (float)Math.PI);
                    this.leftArm.zRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.zRot, 5.012389f - 1.8707964f * internalSwimPos);
                    this.rightArm.zRot = Mth.lerp(rightArmSwimAmount, this.rightArm.zRot, 1.2707963f + 1.8707964f * internalSwimPos);
                } else if (swimPos >= 22.0f && swimPos < 26.0f) {
                    internalSwimPos = (swimPos - 22.0f) / 4.0f;
                    this.leftArm.xRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.xRot, 1.5707964f - 1.5707964f * internalSwimPos);
                    this.rightArm.xRot = Mth.lerp(rightArmSwimAmount, this.rightArm.xRot, 1.5707964f - 1.5707964f * internalSwimPos);
                    this.leftArm.yRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.yRot, (float)Math.PI);
                    this.rightArm.yRot = Mth.lerp(rightArmSwimAmount, this.rightArm.yRot, (float)Math.PI);
                    this.leftArm.zRot = Mth.rotLerpRad(leftArmSwimAmount, this.leftArm.zRot, (float)Math.PI);
                    this.rightArm.zRot = Mth.lerp(rightArmSwimAmount, this.rightArm.zRot, (float)Math.PI);
                }
            }
            float amplitude = 0.3f;
            float slowdown = 0.33333334f;
            this.leftLeg.xRot = Mth.lerp(swimAmount, this.leftLeg.xRot, 0.3f * Mth.cos(animationPos * 0.33333334f + (float)Math.PI));
            this.rightLeg.xRot = Mth.lerp(swimAmount, this.rightLeg.xRot, 0.3f * Mth.cos(animationPos * 0.33333334f));
        }
    }

    private void poseRightArm(T state) {
        switch (((HumanoidRenderState)state).rightArmPose.ordinal()) {
            case 0: {
                this.rightArm.yRot = 0.0f;
                break;
            }
            case 2: {
                this.poseBlockingArm(this.rightArm, true);
                break;
            }
            case 1: {
                this.rightArm.xRot = this.rightArm.xRot * 0.5f - 0.31415927f;
                this.rightArm.yRot = 0.0f;
                break;
            }
            case 4: {
                this.rightArm.xRot = this.rightArm.xRot * 0.5f - (float)Math.PI;
                this.rightArm.yRot = 0.0f;
                break;
            }
            case 10: {
                SpearAnimations.thirdPersonHandUse(this.rightArm, this.head, true, ((ArmedEntityRenderState)state).getUseItemStackForArm(HumanoidArm.RIGHT), state);
                break;
            }
            case 3: {
                this.rightArm.yRot = -0.1f + this.head.yRot;
                this.leftArm.yRot = 0.1f + this.head.yRot + 0.4f;
                this.rightArm.xRot = -1.5707964f + this.head.xRot;
                this.leftArm.xRot = -1.5707964f + this.head.xRot;
                break;
            }
            case 5: {
                AnimationUtils.animateCrossbowCharge(this.rightArm, this.leftArm, ((HumanoidRenderState)state).maxCrossbowChargeDuration, ((HumanoidRenderState)state).ticksUsingItem, true);
                break;
            }
            case 6: {
                AnimationUtils.animateCrossbowHold(this.rightArm, this.leftArm, this.head, true);
                break;
            }
            case 9: {
                this.rightArm.xRot = this.rightArm.xRot * 0.5f - 0.62831855f;
                this.rightArm.yRot = 0.0f;
                break;
            }
            case 7: {
                this.rightArm.xRot = Mth.clamp(this.head.xRot - 1.9198622f - (((HumanoidRenderState)state).isCrouching ? 0.2617994f : 0.0f), -2.4f, 3.3f);
                this.rightArm.yRot = this.head.yRot - 0.2617994f;
                break;
            }
            case 8: {
                this.rightArm.xRot = Mth.clamp(this.head.xRot, -1.2f, 1.2f) - 1.4835298f;
                this.rightArm.yRot = this.head.yRot - 0.5235988f;
            }
        }
    }

    private void poseLeftArm(T state) {
        switch (((HumanoidRenderState)state).leftArmPose.ordinal()) {
            case 0: {
                this.leftArm.yRot = 0.0f;
                break;
            }
            case 2: {
                this.poseBlockingArm(this.leftArm, false);
                break;
            }
            case 1: {
                this.leftArm.xRot = this.leftArm.xRot * 0.5f - 0.31415927f;
                this.leftArm.yRot = 0.0f;
                break;
            }
            case 4: {
                this.leftArm.xRot = this.leftArm.xRot * 0.5f - (float)Math.PI;
                this.leftArm.yRot = 0.0f;
                break;
            }
            case 10: {
                SpearAnimations.thirdPersonHandUse(this.leftArm, this.head, false, ((ArmedEntityRenderState)state).getUseItemStackForArm(HumanoidArm.LEFT), state);
                break;
            }
            case 3: {
                this.rightArm.yRot = -0.1f + this.head.yRot - 0.4f;
                this.leftArm.yRot = 0.1f + this.head.yRot;
                this.rightArm.xRot = -1.5707964f + this.head.xRot;
                this.leftArm.xRot = -1.5707964f + this.head.xRot;
                break;
            }
            case 5: {
                AnimationUtils.animateCrossbowCharge(this.rightArm, this.leftArm, ((HumanoidRenderState)state).maxCrossbowChargeDuration, ((HumanoidRenderState)state).ticksUsingItem, false);
                break;
            }
            case 6: {
                AnimationUtils.animateCrossbowHold(this.rightArm, this.leftArm, this.head, false);
                break;
            }
            case 9: {
                this.leftArm.xRot = this.leftArm.xRot * 0.5f - 0.62831855f;
                this.leftArm.yRot = 0.0f;
                break;
            }
            case 7: {
                this.leftArm.xRot = Mth.clamp(this.head.xRot - 1.9198622f - (((HumanoidRenderState)state).isCrouching ? 0.2617994f : 0.0f), -2.4f, 3.3f);
                this.leftArm.yRot = this.head.yRot + 0.2617994f;
                break;
            }
            case 8: {
                this.leftArm.xRot = Mth.clamp(this.head.xRot, -1.2f, 1.2f) - 1.4835298f;
                this.leftArm.yRot = this.head.yRot + 0.5235988f;
            }
        }
    }

    private void poseBlockingArm(ModelPart arm, boolean right) {
        arm.xRot = arm.xRot * 0.5f - 0.9424779f + Mth.clamp(this.head.xRot, -1.3962634f, 0.43633232f);
        arm.yRot = (right ? -30.0f : 30.0f) * ((float)Math.PI / 180) + Mth.clamp(this.head.yRot, -0.5235988f, 0.5235988f);
    }

    protected void setupAttackAnimation(T state) {
        float attackTime = ((HumanoidRenderState)state).attackTime;
        if (attackTime <= 0.0f) {
            return;
        }
        this.body.yRot = Mth.sin(Mth.sqrt(attackTime) * ((float)Math.PI * 2)) * 0.2f;
        if (((HumanoidRenderState)state).attackArm == HumanoidArm.LEFT) {
            this.body.yRot *= -1.0f;
        }
        float ageScale = ((HumanoidRenderState)state).ageScale;
        this.rightArm.z = Mth.sin(this.body.yRot) * 5.0f * ageScale;
        this.rightArm.x = -Mth.cos(this.body.yRot) * 5.0f * ageScale;
        this.leftArm.z = -Mth.sin(this.body.yRot) * 5.0f * ageScale;
        this.leftArm.x = Mth.cos(this.body.yRot) * 5.0f * ageScale;
        this.rightArm.yRot += this.body.yRot;
        this.leftArm.yRot += this.body.yRot;
        this.leftArm.xRot += this.body.yRot;
        switch (((HumanoidRenderState)state).swingAnimationType) {
            case WHACK: {
                float swing = Ease.outQuart(attackTime);
                float aa = Mth.sin(swing * (float)Math.PI);
                float bb = Mth.sin(attackTime * (float)Math.PI) * -(this.head.xRot - 0.7f) * 0.75f;
                ModelPart attackArm = this.getArm(((HumanoidRenderState)state).attackArm);
                attackArm.xRot -= aa * 1.2f + bb;
                attackArm.yRot += this.body.yRot * 2.0f;
                attackArm.zRot += Mth.sin(attackTime * (float)Math.PI) * -0.4f;
                break;
            }
            case NONE: {
                break;
            }
            case STAB: {
                SpearAnimations.thirdPersonAttackHand(this, state);
            }
        }
    }

    private float quadraticArmUpdate(float x) {
        return -65.0f * x + x * x;
    }

    public void setAllVisible(boolean visible) {
        this.head.visible = visible;
        this.hat.visible = visible;
        this.body.visible = visible;
        this.rightArm.visible = visible;
        this.leftArm.visible = visible;
        this.rightLeg.visible = visible;
        this.leftLeg.visible = visible;
    }

    @Override
    public void translateToHand(HumanoidRenderState state, HumanoidArm arm, PoseStack poseStack) {
        this.root.translateAndRotate(poseStack);
        this.getArm(arm).translateAndRotate(poseStack);
    }

    protected ModelPart getArm(HumanoidArm arm) {
        if (arm == HumanoidArm.LEFT) {
            return this.leftArm;
        }
        return this.rightArm;
    }

    @Override
    public ModelPart getHead() {
        return this.head;
    }

    public static enum ArmPose {
        EMPTY(false),
        ITEM(false),
        BLOCK(false),
        BOW_AND_ARROW(true),
        THROW_TRIDENT(false),
        CROSSBOW_CHARGE(true),
        CROSSBOW_HOLD(true),
        SPYGLASS(false),
        TOOT_HORN(false),
        BRUSH(false),
        SPEAR(false){

            @Override
            public <S extends ArmedEntityRenderState> void animateUseItem(S state, PoseStack poseStack, float ticksUsingItem, HumanoidArm arm, ItemStack actualItem) {
                SpearAnimations.thirdPersonUseItem(state, poseStack, ticksUsingItem, arm, actualItem);
            }
        };

        private final boolean twoHanded;

        private ArmPose(boolean twoHanded) {
            this.twoHanded = twoHanded;
        }

        public boolean isTwoHanded() {
            return this.twoHanded;
        }

        public <S extends ArmedEntityRenderState> void animateUseItem(S state, PoseStack poseStack, float ticksUsingItem, HumanoidArm arm, ItemStack actualItem) {
        }
    }
}