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

class="kw">import com.hypixel.hytale.assetstore.AssetExtraInfo;
class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.assetstore.AssetStore;
class="kw">import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
class="kw">import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
class="kw">import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
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.EnumCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.protocol.BenchRequirement;
class="kw">import com.hypixel.hytale.protocol.BenchType;
class="kw">import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.HashSet;
class="kw">import java.util.Set;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class CraftingRecipe class="kw">implements JsonAssetWithMap<String, DefaultAssetMap<String, CraftingRecipe>> {
   class="kw">public class="kw">static class="kw">final String FIELDCRAFT_REQUIREMENT = "Fieldcraft";
   class="kw">public class="kw">static class="kw">final AssetBuilderCodec<String, CraftingRecipe> CODEC = AssetBuilderCodec.builder(
         CraftingRecipe.class,
         CraftingRecipe::new,
         Codec.STRING,
         (var0, var1) -> var0.id = var1,
         var0 -> var0.id,
         (var0, var1) -> var0.data = var1,
         var0 -> var0.data
      )
      .append(
         new KeyedCodec<>("Input", new ArrayCodec<>(MaterialQuantity.CODEC, MaterialQuantity[]::new)), (var0, var1) -> var0.input = var1, var0 -> var0.input
      )
      .addValidator(Validators.nonNull())
      .addValidator(Validators.nonEmptyArray())
      .add()
      .append(
         new KeyedCodec<>("Output", new ArrayCodec<>(MaterialQuantity.CODEC, MaterialQuantity[]::new)),
         (var0, var1) -> var0.outputs = var1,
         var0 -> var0.outputs
      )
      .add()
      .append(new KeyedCodec<>("PrimaryOutput", MaterialQuantity.CODEC), (var0, var1) -> var0.primaryOutput = var1, var0 -> var0.primaryOutput)
      .add()
      .append(new KeyedCodec<>("OutputQuantity", Codec.INTEGER), (var0, var1) -> var0.primaryOutputQuantity = var1, var0 -> var0.primaryOutputQuantity)
      .add()
      .append(
         new KeyedCodec<>(
            "BenchRequirement",
            new ArrayCodec<>(
               BuilderCodec.builder(BenchRequirement.class, BenchRequirement::new)
                  .append(new KeyedCodec<>("Type", new EnumCodec<>(BenchType.class)), (var0, var1) -> var0.type = var1, var0 -> var0.type)
                  .addValidator(Validators.nonNull())
                  .add()
                  .<String>append(new KeyedCodec<>("Id", Codec.STRING), (var0, var1) -> var0.id = var1, var0 -> var0.id)
                  .addValidator(Validators.nonNull())
                  .add()
                  .append(new KeyedCodec<>("Categories", Codec.STRING_ARRAY), (var0, var1) -> var0.categories = var1, var0 -> var0.categories)
                  .add()
                  .appendInherited(
                     new KeyedCodec<>("RequiredTierLevel", Codec.INTEGER),
                     (var0, var1) -> var0.requiredTierLevel = var1,
                     var0 -> var0.requiredTierLevel,
                     (var0, var1) -> var0.requiredTierLevel = var1.requiredTierLevel
                  )
                  .add()
                  .append(
                     new KeyedCodec<>("RequiredAugmentTags", Codec.STRING_ARRAY),
                     (var0, var1) -> var0.requiredAugmentTags = var1,
                     var0 -> var0.requiredAugmentTags
                  )
                  .add()
                  .build(),
               BenchRequirement[]::new
            )
         ),
         (var0, var1) -> var0.benchRequirement = var1,
         var0 -> var0.benchRequirement
      )
      .add()
      .<Double>append(new KeyedCodec<>("TimeSeconds", Codec.DOUBLE), (var0, var1) -> var0.timeSeconds = var1.floatValue(), var0 -> (double)var0.timeSeconds)
      .addValidator(Validators.min(0.0))
      .add()
      .append(new KeyedCodec<>("KnowledgeRequired", Codec.BOOLEAN), (var0, var1) -> var0.knowledgeRequired = var1, var0 -> var0.knowledgeRequired)
      .add()
      .<Integer>append(
         new KeyedCodec<>("RequiredMemoriesLevel", Codec.INTEGER), (var0, var1) -> var0.requiredMemoriesLevel = var1, var0 -> var0.requiredMemoriesLevel
      )
      .documentation("The level of Memories starts from 1, meaning a recipe with a RequiredMemoriesLevel set at 1 will always be available to players.")
      .addValidator(Validators.greaterThanOrEqual(1))
      .add()
      .validator((var0, var1) -> {
         BenchRequirement[] var2 = var0.getBenchRequirement();
         if (var2 != null) {
            for (BenchRequirement var6 : var2) {
               if (var0.isKnowledgeRequired() && var6.type != BenchType.Crafting && var6.type != BenchType.DiagramCrafting) {
                  var1.fail("KnowledgeRequired in recipe can't be set for non crafting recipes");
               }

               if (var6.type == BenchType.DiagramCrafting && var0.getOutputs() != null && var0.getOutputs().length > 1) {
                  var1.fail("DiagramCrafting in recipe can only have 1 output");
               }

               if ("Fieldcraft".equals(var6.id) && var0.getTimeSeconds() > 0.0F) {
                  var1.warn(String.format("Bench Requirement in recipe for '%s' should not have a delay (TimeSeconds) set!", "Fieldcraft"));
               }
            }
         }
      })
      .afterDecode(CraftingRecipe::processConfig)
      .build();
   class="kw">private class="kw">static class="kw">final MaterialQuantity[] EMPTY_OUTPUT = MaterialQuantity.EMPTY_ARRAY;
   class="kw">private class="kw">static AssetStore<String, CraftingRecipe, DefaultAssetMap<String, CraftingRecipe>> ASSET_STORE;
   class="kw">private AssetExtraInfo.Data data;
   class="kw">protected String id;
   class="kw">protected MaterialQuantity[] input;
   class="kw">protected MaterialQuantity[] outputs = EMPTY_OUTPUT;
   @Nullable
   class="kw">protected MaterialQuantity primaryOutput;
   class="kw">protected int primaryOutputQuantity = 1;
   class="kw">protected BenchRequirement[] benchRequirement;
   class="kw">protected float timeSeconds;
   class="kw">protected boolean knowledgeRequired;
   class="kw">protected int requiredMemoriesLevel = 1;
   class="kw">private Set<String> outputItemIds = Collections.emptySet();

   class="kw">public class="kw">static AssetStore<String, CraftingRecipe, DefaultAssetMap<String, CraftingRecipe>> getAssetStore() {
      if (ASSET_STORE == null) {
         ASSET_STORE = AssetRegistry.getAssetStore(CraftingRecipe.class);
      }

      class="kw">return ASSET_STORE;
   }

   class="kw">public class="kw">static DefaultAssetMap<String, CraftingRecipe> getAssetMap() {
      class="kw">return (DefaultAssetMap<String, CraftingRecipe>)getAssetStore().getAssetMap();
   }

   class="kw">public CraftingRecipe(
      MaterialQuantity[] var1, @Nullable MaterialQuantity var2, MaterialQuantity[] var3, int var4, BenchRequirement[] var5, float var6, boolean var7, int var8
   ) {
      this.input = var1;
      this.primaryOutput = var2;
      this.outputs = var3;
      this.primaryOutputQuantity = var4;
      this.benchRequirement = var5;
      this.timeSeconds = var6;
      this.knowledgeRequired = var7;
      this.requiredMemoriesLevel = var8;
   }

   class="kw">public CraftingRecipe(CraftingRecipe var1) {
      this.input = var1.input;
      this.primaryOutput = var1.primaryOutput;
      this.outputs = var1.outputs;
      this.primaryOutputQuantity = var1.primaryOutputQuantity;
      this.benchRequirement = var1.benchRequirement;
      this.timeSeconds = var1.timeSeconds;
      this.knowledgeRequired = var1.knowledgeRequired;
      this.requiredMemoriesLevel = var1.requiredMemoriesLevel;
   }

   class="kw">protected CraftingRecipe() {
   }

   class="kw">public class="kw">static String generateIdFromItemRecipe(Item var0, int var1) {
      class="kw">return var0.id + "_Recipe_Generated_" + var1;
   }

   @Nonnull
   class="kw">public com.hypixel.hytale.protocol.CraftingRecipe toPacket(String var1) {
      com.hypixel.hytale.protocol.CraftingRecipe var2 = new com.hypixel.hytale.protocol.CraftingRecipe();
      var2.id = var1;
      if (this.input != null && this.input.length > 0) {
         var2.inputs = ArrayUtil.copyAndMutate(this.input, MaterialQuantity::toPacket, com.hypixel.hytale.protocol.MaterialQuantity[]::new);
      }

      var2.primaryOutput = this.primaryOutput != null ? this.primaryOutput.toPacket() : null;
      if (this.outputs != null && this.outputs.length > 0) {
         var2.outputs = ArrayUtil.copyAndMutate(this.outputs, MaterialQuantity::toPacket, com.hypixel.hytale.protocol.MaterialQuantity[]::new);
      }

      if (this.benchRequirement != null && this.benchRequirement.length > 0) {
         var2.benchRequirement = this.benchRequirement;
      }

      var2.knowledgeRequired = this.knowledgeRequired;
      var2.timeSeconds = this.timeSeconds;
      var2.requiredMemoriesLevel = this.requiredMemoriesLevel;
      class="kw">return var2;
   }

   class="kw">private void processConfig() {
      if ((this.outputs == null || this.outputs.length == 0) && this.primaryOutput != null) {
         this.outputs = new MaterialQuantity[]{this.primaryOutput};
      }

      this.applyOutputExclusions();
   }

   void applyOutputExclusions() {
      Set var1 = new HashSet<>();
      if (this.outputs != null) {
         for (MaterialQuantity var5 : this.outputs) {
            if (var5 != null && var5.getItemId() != null) {
               var1.add(var5.getItemId());
            }
         }
      }

      if (this.primaryOutput != null && this.primaryOutput.getItemId() != null) {
         var1.add(this.primaryOutput.getItemId());
      }

      this.outputItemIds = var1.isEmpty() ? Collections.emptySet() : Set.copyOf(var1);
      if (this.input != null && !this.outputItemIds.isEmpty()) {
         for (MaterialQuantity var9 : this.input) {
            if (var9 != null && var9.getItemId() == null) {
               var9.withExcludedItemIds(this.outputItemIds);
            }
         }
      }
   }

   class="kw">public MaterialQuantity[] getInput() {
      class="kw">return this.input;
   }

   class="kw">public MaterialQuantity[] getOutputs() {
      class="kw">return this.outputs;
   }

   class="kw">public BenchRequirement[] getBenchRequirement() {
      class="kw">return this.benchRequirement;
   }

   class="kw">public float getTimeSeconds() {
      class="kw">return this.timeSeconds;
   }

   class="kw">public boolean isKnowledgeRequired() {
      class="kw">return this.knowledgeRequired;
   }

   class="kw">public int getRequiredMemoriesLevel() {
      class="kw">return this.requiredMemoriesLevel;
   }

   @Nullable
   class="kw">public MaterialQuantity getPrimaryOutput() {
      class="kw">return this.primaryOutput;
   }

   class="kw">public boolean isRestrictedByBenchTierLevel(String var1, int var2) {
      if (this.benchRequirement == null) {
         class="kw">return false;
      }

      for (BenchRequirement var6 : this.benchRequirement) {
         if (var1.equals(var6.id) && var2 < var6.requiredTierLevel) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "CraftingRecipe{input="
         + Arrays.toString(this.input)
         + ", extraOutputs="
         + Arrays.toString(this.outputs)
         + ", primaryOutput="
         + this.primaryOutput
         + ", outputQuantity="
         + this.primaryOutputQuantity
         + ", benchRequirement="
         + Arrays.toString(this.benchRequirement)
         + ", timeSeconds="
         + this.timeSeconds
         + ", knowledgeRequired="
         + this.knowledgeRequired
         + ", requiredMemoriesLevel="
         + this.requiredMemoriesLevel
         + "}";
   }

   class="kw">public String getId() {
      class="kw">return this.id;
   }
}