package defpackage;

import net.minecraft.util.Mth;

public final class mx {
   private static final aso[] ROLES = aso.values();
   private static final oc[] RADIUS_ROLES = oc.values();
   private static final int ROLE_COUNT = ROLES.length;
   private static final int CORNER_COUNT = 4;
   public static final int CORNER_TOP_LEFT = 0;
   public static final int CORNER_BOTTOM_LEFT = 1;
   public static final int CORNER_BOTTOM_RIGHT = 2;
   public static final int CORNER_TOP_RIGHT = 3;
   private static final float CORNER_UNIT = 0.70710677F;
   private static final float[] CORNER_DIR_X;
   private static final float[] CORNER_DIR_Y;
   private static final asn[] TIERS = asn.values();
   private static final float DEG_TO_RAD = (float) (Math.PI / 180.0);
   private static final float MIN_AXIS_PROJECTION = 1.0E-4F;
   private static final float HALF = 0.5F;
   private static final float ALPHA_SCALE = 255.0F;
   private static final int ALPHA_SHIFT = 24;
   private static final int RED_SHIFT = 16;
   private static final int GREEN_SHIFT = 8;
   private static final int CHANNEL_MASK = 255;
   private static final float MIN_TINT = -1.0F;
   private static final float MAX_TINT = 1.0F;
   private static final float MIN_UNIT = 0.0F;
   private static final float MAX_UNIT = 1.0F;
   private static final float MILLIS_PER_SECOND = 1000.0F;
   private static final float LUMA_RED = 0.2126F;
   private static final float LUMA_GREEN = 0.7152F;
   private static final float LUMA_BLUE = 0.0722F;
   private final float[] fillAlpha = new float[ROLE_COUNT];
   private final float[] borderAlpha = new float[ROLE_COUNT];
   private final float[] radiusScale = new float[ROLE_COUNT];
   private final float[] neonIntensity = new float[ROLE_COUNT];
   private final float[] neonRadius = new float[ROLE_COUNT];
   private final int[] glassTier = new int[ROLE_COUNT];
   private final int[] rimColor = new int[ROLE_COUNT * (4)];
   private final float[] cornerWeight = new float[4];
   private final float[] roleRadius = new float[oc.COUNT];
   private final arq[] roleRadiusShape = new arq[oc.COUNT];
   private final arq[] roleRadiusTop = new arq[oc.COUNT];
   private final arq[] roleRadiusBottom = new arq[oc.COUNT];
   private final arq[] roleRadiusLeft = new arq[oc.COUNT];
   private final arq[] roleRadiusRight = new arq[oc.COUNT];
   private float glassProgress;
   private float tint;
   private float frost;
   private float refraction;
   private float bevelDepth;
   private float bevelWidth;
   private float rimGain;
   private float sweepPhase;
   private float sweepLength;
   private float sweepIntensity;
   private float glassContrast;
   private float glassTextLuma;
   private float glassSpecular;
   private float glassLightX;
   private float glassLightY;
   private float glassDispersion;
   private float glassDepth;
   private float borderThickness;
   private float dividerAlpha;
   private float squircleExponent;
   private float shadowSoftness;
   private float shadowAlpha;
   private float hoverLift;
   private float animationSpeed;
   private float glowExponent;
   private float activeGlowIntensity;
   private float activeGlowRadius;
   private float textGlowRadius;
   private float textGlowIntensity;
   private int textGlowColor;
   private float radiusPanel;
   private float radiusPanelLarge;
   private float radiusInner;
   private float radiusChip;
   private int accentStart;
   private int accentEnd;

   private mx() {
      this.resolve(mv.DARK, 0.0F, 0.0F, 0.0F, 0.0F);
   }

   public static mx current() {
      return CURRENT;
   }

   public static void resolveCurrent(mv var0, float var1, float var2, float var3, float var4) {
      CURRENT.resolve(var0, var1, var2, var3, var4);
   }

   public void resolve(mv var1, float var2, float var3, float var4, float var5) {
      no var6 = null;
      nm var7 = null;
      np var8 = null;
      ng var9 = null;
      float var10 = 0.0F;
      float var11 = 0.0F;
      int var12 = 0;
      float var13 = 0.0F;
      float var14 = 0.0F;
      int var15 = 0;
      aso var16 = null;
      float var17 = 0.0F;
      int var18 = 0;
      int var19 = 0;
      float var20 = 0.0F;
      float var21 = 0.0F;
      float var23 = 0.0F;
      int var22 = -1580829466;

      while (true) {
         switch (var22) {
            case -1994705706:
               var16 = ROLES[var15];
               this.fillAlpha[var15] = pg.innerFillAlpha(var16, this.tint) * var8.fillAlphaScale();
               this.borderAlpha[var15] = pg.innerBorderAlpha(var16) * var8.borderAlphaScale();
               this.radiusScale[var15] = var6.radiusScale(var16);
               this.glassTier[var15] = var8.tier(var16).ordinal();
               var17 = var7.neonIntensity(var16);
               this.neonIntensity[var15] = var17;
               this.neonRadius[var15] = var7.neonRadius();
               var18 = var15 * (4);
               var19 = 0;
               var22 = 31457442;
               break;
            case -1742540227:
               var23 = 1.0F;
               var22 = 347784758;
               break;
            case -1580829466:
            default:
               var6 = var1.getGeometry();
               var7 = var1.getEffects();
               var8 = var1.getGlass();
               var9 = var1.getAccent();
               this.glassProgress = var2;
               this.tint = Mth.clamp(var8.tint() + var5, -1.0F, 1.0F);
               this.frost = Mth.clamp(var8.frost() + var3, 0.0F, 1.0F);
               this.refraction = Mth.clamp(var8.refraction() + var4, 0.0F, 1.0F);
               this.bevelDepth = var8.bevelDepth();
               this.bevelWidth = var8.bevelWidth();
               this.rimGain = var8.rimGain();
               this.sweepLength = var7.sweepLength();
               this.sweepIntensity = var7.sweepIntensity();
               this.sweepPhase = resolveSweepPhase(var7.sweepSpeed());
               this.glassContrast = var8.contrast();
               this.glassSpecular = var8.specular();
               this.glassDispersion = var8.dispersion();
               this.glassDepth = var8.depth();
               this.glassTextLuma = relativeLuma(var1.getBaseWhite());
               var10 = var8.lightAngle() * (float) (Math.PI / 180.0);
               this.glassLightX = Mth.cos(var10);
               this.glassLightY = Mth.sin(var10);
               this.borderThickness = var6.borderThickness();
               this.dividerAlpha = var6.dividerAlpha();
               this.squircleExponent = var6.squircleExponent();
               this.shadowSoftness = var7.shadowSoftness();
               this.shadowAlpha = var7.shadowAlpha();
               this.hoverLift = var7.hoverLift();
               this.animationSpeed = var7.animationSpeed();
               this.glowExponent = var7.glowExponent();
               this.activeGlowIntensity = var7.activeGlowIntensity();
               this.activeGlowRadius = var7.activeGlowRadius();
               this.textGlowRadius = var7.textGlowRadius();
               this.textGlowIntensity = var7.textGlowIntensity();
               this.textGlowColor = var7.textGlowColor().getRGB();
               var11 = var6.radiusScale();
               this.radiusPanel = 4.0F * var11;
               this.radiusPanelLarge = 8.0F * var11;
               this.radiusInner = 3.0F * var11;
               this.radiusChip = 3.0F * var11;
               this.accentStart = var9.start().getRGB();
               this.accentEnd = var9.end().getRGB();
               this.resolveRoleRadii(var6);
               this.resolveCornerWeights(var7.gradientBorderAngle());
               var12 = (var7.gradientBorder()) ? 1 : 0;
               var13 = var7.rimTopAlpha();
               var14 = var7.rimBottomAlpha();
               var15 = 0;
               var22 = -332056769;
               break;
            case -1265742678:
               return;
            case -953685501:
               var15++;
               var22 = -332056769;
               break;
            case -332056769:
               if (var15 < ROLE_COUNT) {
                  var22 = -1994705706;
               } else {
                  var22 = -1265742678;
               }
               break;
            case -258395720:
               this.rimColor[var18 + var19] = 0;
               var22 = 530273434;
               break;
            case 31457442:
               if (var19 < (-523250946 ^ 523250950) + ((-523250946 & 523250950) << 1)) {
                  var22 = 745159428;
               } else {
                  var22 = -953685501;
               }
               break;
            case 241152193:
               if (var12 != 0) {
                  var22 = 1573085003;
               } else {
                  var22 = -1742540227;
               }
               break;
            case 347784758:
               var20 = var23;
               var21 = (var14 + (var13 - var14) * var20) * var17;
               this.rimColor[var18 + var19] = rampArgb(var9, 1.0F - var20, var21);
               var22 = 530273434;
               break;
            case 530273434:
               var19++;
               var22 = 31457442;
               break;
            case 745159428:
               if (var17 <= 0.0F) {
                  var22 = -258395720;
               } else {
                  var22 = 241152193;
               }
               break;
            case 1573085003:
               var23 = this.cornerWeight[var19];
               var22 = 347784758;
         }
      }
   }

   private void resolveRoleRadii(no var1) {
      int var2 = 0;
      oc var3 = null;
      float var4 = 0.0F;
      int var5 = -1661983131;

      while (true) {
         switch (var5) {
            case -1661983131:
            default:
               var2 = 0;
               var5 = -76286593;
               break;
            case -693083683:
               var2++;
               var5 = -76286593;
               break;
            case -502168517:
               this.roleRadius[var2] = var4;
               this.roleRadiusShape[var2] = arq.all(var4);
               this.roleRadiusTop[var2] = arq.top(var4, var4);
               this.roleRadiusBottom[var2] = arq.bottom(var4, var4);
               this.roleRadiusLeft[var2] = arq.left(var4, var4);
               this.roleRadiusRight[var2] = arq.right(var4, var4);
               var5 = -693083683;
               break;
            case -494820741:
               return;
            case -283072174:
               if (this.roleRadius[var2] == var4) {
                  var5 = 230761485;
               } else {
                  var5 = -502168517;
               }
               break;
            case -76286593:
               if (var2 < RADIUS_ROLES.length) {
                  var5 = 166696305;
               } else {
                  var5 = -494820741;
               }
               break;
            case 166696305:
               var3 = RADIUS_ROLES[var2];
               var4 = var3.base() * var1.radiusScale(var3.surface());
               if (this.roleRadiusShape[var2] != null) {
                  var5 = -283072174;
               } else {
                  var5 = -502168517;
               }
               break;
            case 230761485:
               var5 = -693083683;
         }
      }
   }

   public float roleRadius(oc var1) {
      return this.roleRadius[var1.ordinal()];
   }

   public arq roleRadiusShape(oc var1) {
      return this.roleRadiusShape[var1.ordinal()];
   }

   public arq roleRadiusTop(oc var1) {
      return this.roleRadiusTop[var1.ordinal()];
   }

   public arq roleRadiusBottom(oc var1) {
      return this.roleRadiusBottom[var1.ordinal()];
   }

   public arq roleRadiusLeft(oc var1) {
      return this.roleRadiusLeft[var1.ordinal()];
   }

   public arq roleRadiusRight(oc var1) {
      return this.roleRadiusRight[var1.ordinal()];
   }

   private void resolveCornerWeights(float var1) {
      float var2 = 0.0F;
      float var3 = 0.0F;
      float var4 = 0.0F;
      float var5 = 0.0F;
      int var6 = 0;
      float var7 = 0.0F;
      int var8 = -936070382;

      while (true) {
         switch (var8) {
            case -1894942322:
               var6 = 0;
               var8 = 1409217621;
               break;
            case -1482343491:
               var7 = CORNER_DIR_X[var6] * var3 + CORNER_DIR_Y[var6] * var4;
               this.cornerWeight[var6] = Mth.clamp(0.5F + 0.5F * var7 / var5, 0.0F, 1.0F);
               var6++;
               var8 = 1409217621;
               break;
            case -936070382:
            default:
               var2 = var1 * (float) (Math.PI / 180.0);
               var3 = Mth.cos(var2);
               var4 = -Mth.sin(var2);
               var5 = 1.0E-4F;
               var6 = 0;
               var8 = -788439278;
               break;
            case -788439278:
               if (var6 < (782137444 ^ -782137440) + ((782137444 & -782137440) << 1)) {
                  var8 = 379374836;
               } else {
                  var8 = -1894942322;
               }
               break;
            case -786894036:
               var5 = var7;
               var8 = 1602337690;
               break;
            case 379374836:
               var7 = Math.abs(CORNER_DIR_X[var6] * var3 + CORNER_DIR_Y[var6] * var4);
               if (var7 > var5) {
                  var8 = -786894036;
               } else {
                  var8 = 1602337690;
               }
               break;
            case 1409217621:
               if (var6 < (1148775283 | -1148775279) + (1148775283 & -1148775279)) {
                  var8 = -1482343491;
               } else {
                  var8 = 2034689272;
               }
               break;
            case 1602337690:
               var6++;
               var8 = -788439278;
               break;
            case 2034689272:
               return;
         }
      }
   }

   private static int rampArgb(ng var0, float var1, float var2) {
      float var3 = 0.0F;
      asu var4 = null;
      asu var5 = null;
      float var6 = 0.0F;
      int var7 = 0;
      int var8 = 0;
      int var9 = 0;
      int var10 = 0;
      int var11 = -1245509076;

      while (true) {
         switch (var11) {
            case -1245509076:
            default:
               var3 = Mth.clamp(var1, 0.0F, 1.0F);
               if (var3 <= 0.5F) {
                  var11 = 1268182302;
               } else {
                  var11 = 1825750681;
               }
               break;
            case -1013291479:
               var7 = Math.round(var4.getRed() + (var5.getRed() - var4.getRed()) * var6);
               var8 = Math.round(var4.getGreen() + (var5.getGreen() - var4.getGreen()) * var6);
               var9 = Math.round(var4.getBlue() + (var5.getBlue() - var4.getBlue()) * var6);
               var10 = Math.round(Mth.clamp(var2, 0.0F, 1.0F) * 255.0F);
               return (var10 & (-1486829325 ^ 1486829580) + ((-1486829325 & 1486829580) << 1))
                     << (-1341134911 ^ 1341134935) + ((-1341134911 & 1341134935) << 1)
                  | (var7 & (-1123012199 ^ 1123012454) + ((-1123012199 & 1123012454) << 1)) << (642931539 ^ -642931523) + ((642931539 & -642931523) << 1)
                  | (var8 & (306229354 | -306229099) + (306229354 & -306229099)) << (-590997761 | 590997769) + (-590997761 & 590997769)
                  | var9 & 255;
            case 1268182302:
               var4 = var0.start();
               var5 = var0.middle();
               var6 = var3 / 0.5F;
               var11 = -1013291479;
               break;
            case 1825750681:
               var4 = var0.middle();
               var5 = var0.end();
               var6 = (var3 - 0.5F) / 0.5F;
               var11 = -1013291479;
         }
      }
   }

   public float fillAlpha(aso var1) {
      return this.fillAlpha[var1.ordinal()];
   }

   public float borderAlpha(aso var1) {
      return this.borderAlpha[var1.ordinal()];
   }

   public float radiusScale(aso var1) {
      return this.radiusScale[var1.ordinal()];
   }

   public float neonIntensity(aso var1) {
      return this.neonIntensity[var1.ordinal()];
   }

   public float neonRadius(aso var1) {
      return this.neonRadius[var1.ordinal()];
   }

   public asn glassTier(aso var1) {
      return TIERS[this.glassTier[var1.ordinal()]];
   }

   public int rimColor(aso var1, int var2) {
      return this.rimColor[var1.ordinal() * ((-1878953022 ^ 1878953026) + ((-1878953022 & 1878953026) << 1)) + var2];
   }

   public float glassProgress() {
      return this.glassProgress;
   }

   public float tint() {
      return this.tint;
   }

   public float frost() {
      return this.frost;
   }

   public float refraction() {
      return this.refraction;
   }

   public float bevelDepth() {
      return this.bevelDepth;
   }

   public float bevelWidth() {
      return this.bevelWidth;
   }

   public float rimGain() {
      return this.rimGain;
   }

   public float sweepPhase() {
      return this.sweepPhase;
   }

   public float sweepLength() {
      return this.sweepLength;
   }

   public float sweepIntensity() {
      return this.sweepIntensity;
   }

   private static float resolveSweepPhase(float var0) {
      long var1 = (-3778971742591565956L | 3778971742591565956L) + (-3778971742591565956L & 3778971742591565956L);
      int var3 = 1264598327;

      while (true) {
         switch (var3) {
            case -1935112324:
               return 0.0F;
            case -1562792042:
               return (float)(System.currentTimeMillis() % var1) / (float)var1;
            case -389856060:
               var1 = (long)(1000.0F / var0);
               if (var1 <= (3006073490259808539L | -3006073490259808539L) + (3006073490259808539L & -3006073490259808539L)) {
                  var3 = 1222861189;
               } else {
                  var3 = -1562792042;
               }
               break;
            case 1222861189:
               return 0.0F;
            case 1264598327:
            default:
               if (var0 <= 0.0F) {
                  var3 = -1935112324;
               } else {
                  var3 = -389856060;
               }
         }
      }
   }

   public float glassContrast() {
      return this.glassContrast;
   }

   public float glassTextLuma() {
      return this.glassTextLuma;
   }

   public float glassSpecular() {
      return this.glassSpecular;
   }

   public float glassLightX() {
      return this.glassLightX;
   }

   public float glassLightY() {
      return this.glassLightY;
   }

   public float glassDispersion() {
      return this.glassDispersion;
   }

   public float glassDepth() {
      return this.glassDepth;
   }

   private static float relativeLuma(asu var0) {
      return (0.2126F * var0.getRed() + 0.7152F * var0.getGreen() + 0.0722F * var0.getBlue()) / 255.0F;
   }

   public float borderThickness() {
      return this.borderThickness;
   }

   public float dividerAlpha() {
      return this.dividerAlpha;
   }

   public float squircleExponent() {
      return this.squircleExponent;
   }

   public float shadowSoftness() {
      return this.shadowSoftness;
   }

   public float shadowAlpha() {
      return this.shadowAlpha;
   }

   public float hoverLift() {
      return this.hoverLift;
   }

   public float animationSpeed() {
      return this.animationSpeed;
   }

   public float glowExponent() {
      return this.glowExponent;
   }

   public float activeGlowIntensity() {
      return this.activeGlowIntensity;
   }

   public float activeGlowRadius() {
      return this.activeGlowRadius;
   }

   public float textGlowRadius() {
      return this.textGlowRadius;
   }

   public float textGlowIntensity() {
      return this.textGlowIntensity;
   }

   public int textGlowColor() {
      return this.textGlowColor;
   }

   public float radiusPanel() {
      return this.radiusPanel;
   }

   public float radiusPanelLarge() {
      return this.radiusPanelLarge;
   }

   public float radiusInner() {
      return this.radiusInner;
   }

   public float radiusChip() {
      return this.radiusChip;
   }

   public int accentStart() {
      return this.accentStart;
   }

   public int accentEnd() {
      return this.accentEnd;
   }

   static {
      float[] var10000 = new float[4];
      var10000[0] = -0.70710677F;
      var10000[1] = -0.70710677F;
      var10000[2] = 0.70710677F;
      var10000[3] = 0.70710677F;
      CORNER_DIR_X = var10000;
      var10000 = new float[4];
      var10000[0] = -0.70710677F;
      var10000[1] = 0.70710677F;
      var10000[2] = 0.70710677F;
      var10000[3] = -0.70710677F;
      CORNER_DIR_Y = var10000;
   }

   private static final mx CURRENT = new mx();
}