class="kw">package com.hypixel.hytale.server.core.asset.type.audiocategory.config;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.schema.metadata.ui.UIDisplayMode;
class="kw">import com.hypixel.hytale.codec.validation.ValidationResults;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.protocol.AudioCategoryDuckingRule;
class="kw">import com.hypixel.hytale.protocol.FadeCurve;
class="kw">import com.hypixel.hytale.server.core.asset.type.audiostate.config.AudioStateCodecs;
class="kw">import java.util.HashSet;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class AudioCategoryDuckingRuleConfig {
   class="kw">public class="kw">static class="kw">final float MIN_DUCKING_DB = -100.0F;
   class="kw">public class="kw">static class="kw">final float MAX_DUCKING_DB = 0.0F;
   class="kw">public class="kw">static class="kw">final float MAX_PHASE_MS = 60000.0F;
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<AudioCategoryDuckingRuleConfig> CODEC = BuilderCodec.builder(
         AudioCategoryDuckingRuleConfig.class, AudioCategoryDuckingRuleConfig::new
      )
      .metadata(UIDisplayMode.COMPACT)
      .<String>append(new KeyedCodec<>("TargetCategory", Codec.STRING), (var0, var1) -> var0.targetCategoryId = var1, var0 -> var0.targetCategoryId)
      .addValidatorLate(() -> AudioCategory.VALIDATOR_CACHE.getValidator().late())
      .documentation("Id of the AudioCategory this rule ducks.")
      .add()
      .<Float>append(new KeyedCodec<>("DuckingVolumeDb", Codec.FLOAT), (var0, var1) -> var0.duckingVolumeDb = var1, var0 -> var0.duckingVolumeDb)
      .addValidator(Validators.range(-100.0F, 0.0F))
      .documentation("Authored ducking target in dB.")
      .add()
      .<Float>append(new KeyedCodec<>("AttackMs", Codec.FLOAT), (var0, var1) -> var0.attackMs = var1, var0 -> var0.attackMs)
      .addValidator(Validators.range(0.0F, 60000.0F))
      .documentation("Milliseconds to tween from 0 dB (no duck) toward DuckingVolumeDb when the rule's source first becomes active. Zero snaps immediately.")
      .add()
      .<Float>append(new KeyedCodec<>("HoldMs", Codec.FLOAT), (var0, var1) -> var0.holdMs = var1, var0 -> var0.holdMs)
      .addValidator(Validators.range(0.0F, 60000.0F))
      .documentation("Milliseconds to hold the duck at DuckingVolumeDb after the source becomes inactive.")
      .add()
      .<Float>append(new KeyedCodec<>("ReleaseMs", Codec.FLOAT), (var0, var1) -> var0.releaseMs = var1, var0 -> var0.releaseMs)
      .addValidator(Validators.range(0.0F, 60000.0F))
      .documentation("Milliseconds to tween from the held duck value back toward the next-priority value. Zero snaps immediately.")
      .add()
      .<FadeCurve>append(new KeyedCodec<>("Curve", AudioStateCodecs.FADE_CURVE), (var0, var1) -> var0.curve = var1, var0 -> var0.curve)
      .documentation("Curve applied to the Attack tween.")
      .add()
      .<FadeCurve>append(new KeyedCodec<>("ReleaseCurve", AudioStateCodecs.FADE_CURVE), (var0, var1) -> var0.releaseCurve = var1, var0 -> var0.releaseCurve)
      .documentation("Curve applied to the Release tween.")
      .add()
      .<Short>append(new KeyedCodec<>("Priority", Codec.SHORT), (var0, var1) -> var0.priority = var1, var0 -> var0.priority)
      .addValidator(Validators.range((short)0, (short)32767))
      .documentation(
         "When multiple rules are active on the same target, only entries at the highest active priority contribute to the composite. Within a priority class, the most-negative dB wins."
      )
      .add()
      .build();
   @Nonnull
   class="kw">public class="kw">static class="kw">final ArrayCodec<AudioCategoryDuckingRuleConfig> CODEC_ARRAY = new ArrayCodec<>(CODEC, AudioCategoryDuckingRuleConfig[]::new);
   @Nullable
   class="kw">protected String targetCategoryId;
   class="kw">protected float duckingVolumeDb;
   class="kw">protected float attackMs;
   class="kw">protected float holdMs;
   class="kw">protected float releaseMs;
   class="kw">protected FadeCurve curve = FadeCurve.Linear;
   class="kw">protected FadeCurve releaseCurve = FadeCurve.Linear;
   class="kw">protected short priority;
   class="kw">transient int targetAudioCategoryIndex = Integer.MIN_VALUE;

   class="kw">public AudioCategoryDuckingRuleConfig() {
   }

   class="kw">public class="kw">static void validateUniqueTargets(@Nullable AudioCategoryDuckingRuleConfig[] var0, @Nonnull String var1, @Nonnull ValidationResults var2) {
      if (var0 != null && var0.length != 0) {
         HashSet var3 = new HashSet<>();

         for (int var4 = 0; var4 < var0.length; var4++) {
            AudioCategoryDuckingRuleConfig var5 = var0[var4];
            if (var5 == null) {
               var2.fail(var1 + " DuckingRules[" + var4 + "] is null.");
            } else if (var5.targetCategoryId == null) {
               var2.fail(var1 + " DuckingRules[" + var4 + "] has no TargetCategory.");
            } else if (!var3.add(var5.targetCategoryId)) {
               var2.fail(var1 + " authors multiple DuckingRules targeting '" + var5.targetCategoryId + "'. Each source can have at most one rule per target.");
            }
         }
      }
   }

   class="kw">public class="kw">static void resolveTargets(@Nullable AudioCategoryDuckingRuleConfig[] var0) {
      if (var0 != null) {
         for (AudioCategoryDuckingRuleConfig var4 : var0) {
            if (var4 != null && var4.targetCategoryId != null) {
               var4.targetAudioCategoryIndex = AudioCategory.getAssetMap().getIndex(var4.targetCategoryId);
            }
         }
      }
   }

   @Nonnull
   class="kw">public AudioCategoryDuckingRule toPacket() {
      AudioCategoryDuckingRule var1 = new AudioCategoryDuckingRule();
      var1.targetAudioCategoryIndex = this.targetAudioCategoryIndex;
      var1.duckingVolumeDb = this.duckingVolumeDb;
      var1.attackMs = this.attackMs;
      var1.holdMs = this.holdMs;
      var1.releaseMs = this.releaseMs;
      var1.curve = this.curve;
      var1.releaseCurve = this.releaseCurve;
      var1.priority = this.priority;
      class="kw">return var1;
   }

   @Nullable
   class="kw">public class="kw">static AudioCategoryDuckingRule[] toPacketArray(@Nullable AudioCategoryDuckingRuleConfig[] var0) {
      if (var0 != null && var0.length != 0) {
         AudioCategoryDuckingRule[] var1 = new AudioCategoryDuckingRule[var0.length];

         for (int var2 = 0; var2 < var0.length; var2++) {
            var1[var2] = var0[var2] != null ? var0[var2].toPacket() : null;
         }

         class="kw">return var1;
      } else {
         class="kw">return null;
      }
   }
}