// 
// Decompiled by Procyon v0.6.0
// 

package com.hypixel.hytale.server.worldgen.loader.container;

import com.hypixel.hytale.procedurallib.json.NoiseMaskConditionJsonLoader;
import javax.annotation.Nullable;
import com.google.gson.JsonArray;
import com.hypixel.hytale.procedurallib.property.NoiseProperty;
import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
import com.hypixel.hytale.procedurallib.condition.ICoordinateCondition;
import com.hypixel.hytale.procedurallib.supplier.IDoubleCoordinateSupplier;
import com.hypixel.hytale.procedurallib.condition.DefaultCoordinateCondition;
import com.hypixel.hytale.procedurallib.supplier.IDoubleRange;
import com.hypixel.hytale.procedurallib.supplier.DoubleRange;
import com.hypixel.hytale.procedurallib.supplier.DoubleRangeNoiseSupplier;
import com.hypixel.hytale.procedurallib.json.NoisePropertyJsonLoader;
import com.hypixel.hytale.server.worldgen.util.ConstantNoiseProperty;
import com.hypixel.hytale.procedurallib.json.DoubleRangeJsonLoader;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.google.gson.JsonElement;
import java.nio.file.Path;
import javax.annotation.Nonnull;
import com.hypixel.hytale.procedurallib.json.SeedString;
import com.hypixel.hytale.server.worldgen.container.WaterContainer;
import com.hypixel.hytale.server.worldgen.SeedStringResource;
import com.hypixel.hytale.procedurallib.json.JsonLoader;

public class WaterContainerJsonLoader extends JsonLoader<SeedStringResource, WaterContainer>
{
    public WaterContainerJsonLoader(@Nonnull final SeedString<SeedStringResource> seed, final Path dataFolder, final JsonElement json) {
        super(seed.append(".WaterContainer"), dataFolder, json);
    }
    
    @Nonnull
    @Override
    public WaterContainer load() {
        if (this.has("Block")) {
            final String blockTypeKey;
            final String blockString = blockTypeKey = this.get("Block").getAsString();
            final int index = BlockType.getAssetMap().getIndex(blockTypeKey);
            if (index == Integer.MIN_VALUE) {
                throw new Error(String.format("Could not find Fluid for fluid: %s", blockTypeKey.toString()));
            }
            final IDoubleRange array = new DoubleRangeJsonLoader(this.seed, this.dataFolder, this.get("Height"), 0.0).load();
            NoiseProperty heightmapNoise = ConstantNoiseProperty.DEFAULT_ZERO;
            if (this.has("Heightmap")) {
                heightmapNoise = new NoisePropertyJsonLoader(this.seed, this.dataFolder, this.get("Heightmap")).load();
            }
            final DoubleRangeNoiseSupplier height = new DoubleRangeNoiseSupplier(array, heightmapNoise);
            return new WaterContainer(new WaterContainer.Entry[] { new WaterContainer.Entry(index, 0, new DoubleRangeNoiseSupplier(DoubleRange.ZERO, ConstantNoiseProperty.DEFAULT_ZERO), height, DefaultCoordinateCondition.DEFAULT_TRUE) });
        }
        else {
            if (!this.has("Fluid")) {
                return new WaterContainer(this.loadEntries());
            }
            final String fluidString = this.get("Fluid").getAsString();
            final int index2 = Fluid.getAssetMap().getIndex(fluidString);
            if (index2 == Integer.MIN_VALUE) {
                throw new Error(String.format("Could not find Fluid for fluid: %s", fluidString));
            }
            final IDoubleRange array2 = new DoubleRangeJsonLoader(this.seed, this.dataFolder, this.get("Height"), 0.0).load();
            NoiseProperty heightmapNoise2 = ConstantNoiseProperty.DEFAULT_ZERO;
            if (this.has("Heightmap")) {
                heightmapNoise2 = new NoisePropertyJsonLoader(this.seed, this.dataFolder, this.get("Heightmap")).load();
            }
            final DoubleRangeNoiseSupplier height2 = new DoubleRangeNoiseSupplier(array2, heightmapNoise2);
            return new WaterContainer(new WaterContainer.Entry[] { new WaterContainer.Entry(0, index2, new DoubleRangeNoiseSupplier(DoubleRange.ZERO, ConstantNoiseProperty.DEFAULT_ZERO), height2, DefaultCoordinateCondition.DEFAULT_TRUE) });
        }
    }
    
    @Nonnull
    private WaterContainer.Entry[] loadEntries() {
        if (!this.has("Entries")) {
            return WaterContainer.Entry.EMPTY_ARRAY;
        }
        final JsonArray arr = this.get("Entries").getAsJsonArray();
        if (arr.isEmpty()) {
            return WaterContainer.Entry.EMPTY_ARRAY;
        }
        final WaterContainer.Entry[] entries = new WaterContainer.Entry[arr.size()];
        for (int i = 0; i < arr.size(); ++i) {
            try {
                entries[i] = new WaterContainerEntryJsonLoader((SeedString<SeedStringResource>)this.seed.append(String.format("-%s", i)), this.dataFolder, arr.get(i)).load();
            }
            catch (final Throwable e) {
                throw new Error(String.format("Failed to load TintContainerEntry #%s", i), e);
            }
        }
        return entries;
    }
    
    private static class WaterContainerEntryJsonLoader extends JsonLoader<SeedStringResource, WaterContainer.Entry>
    {
        public WaterContainerEntryJsonLoader(@Nonnull final SeedString<SeedStringResource> seed, final Path dataFolder, final JsonElement json) {
            super(seed.append(".Entry"), dataFolder, json);
        }
        
        @Nonnull
        @Override
        public WaterContainer.Entry load() {
            try {
                if (this.has("Fluid")) {
                    final String fluidString = this.get("Fluid").getAsString();
                    final int index = Fluid.getAssetMap().getIndex(fluidString);
                    if (index == Integer.MIN_VALUE) {
                        throw new Error(String.format("Could not find Fluid for fluid: %s", fluidString));
                    }
                    return new WaterContainer.Entry(0, index, this.loadMin(), this.loadMax(), this.loadNoiseMask());
                }
                else {
                    if (!this.has("Block")) {
                        throw new IllegalArgumentException("Could not find fluid information. Keyword: Fluid");
                    }
                    final String blockTypeKey;
                    final String blockString = blockTypeKey = this.get("Block").getAsString();
                    final int index2 = BlockType.getAssetMap().getIndex(blockTypeKey);
                    if (index2 == Integer.MIN_VALUE) {
                        throw new Error(String.format("Could not find Fluid for fluid: %s", blockTypeKey.toString()));
                    }
                    return new WaterContainer.Entry(index2, 0, this.loadMin(), this.loadMax(), this.loadNoiseMask());
                }
            }
            catch (final Error e) {
                throw new Error("Failed to load water container.", e);
            }
        }
        
        @Nonnull
        private IDoubleCoordinateSupplier loadMin() {
            final IDoubleRange array = new DoubleRangeJsonLoader(this.seed, this.dataFolder, this.get("Min"), 0.0).load();
            final NoiseProperty minNoise = this.loadNoise("MinNoise");
            return new DoubleRangeNoiseSupplier(array, minNoise);
        }
        
        @Nonnull
        private IDoubleCoordinateSupplier loadMax() {
            if (!this.has("Max")) {
                throw new IllegalArgumentException("Could not find maximum of water container entry.");
            }
            final IDoubleRange array = new DoubleRangeJsonLoader(this.seed, this.dataFolder, this.get("Max"), 0.0).load();
            final NoiseProperty maxNoise = this.loadNoise("MaxNoise");
            return new DoubleRangeNoiseSupplier(array, maxNoise);
        }
        
        @Nullable
        private NoiseProperty loadNoise(final String key) {
            NoiseProperty maxNoise = ConstantNoiseProperty.DEFAULT_ZERO;
            if (this.has(key)) {
                maxNoise = new NoisePropertyJsonLoader(this.seed, this.dataFolder, this.get(key)).load();
            }
            return maxNoise;
        }
        
        @Nonnull
        private ICoordinateCondition loadNoiseMask() {
            ICoordinateCondition mask = DefaultCoordinateCondition.DEFAULT_TRUE;
            if (this.has("NoiseMask")) {
                mask = new NoiseMaskConditionJsonLoader(this.seed, this.dataFolder, this.get("NoiseMask")).load();
            }
            return mask;
        }
    }
    
    public interface Constants
    {
        public static final String KEY_ENTRIES = "Entries";
        public static final String KEY_ENTRY_BLOCK = "Block";
        public static final String ERROR_ENTRY_NO_BLOCK = "Could not find block information. Keyword: Block";
        public static final String ERROR_ENTRY_FLUID_BLOCK = "Could not find BlockType for block: %s";
        public static final String KEY_ENTRY_FLUID = "Fluid";
        public static final String ERROR_ENTRY_NO_FLUID = "Could not find fluid information. Keyword: Fluid";
        public static final String ERROR_ENTRY_FLUID_TYPE = "Could not find Fluid for fluid: %s";
        public static final String KEY_ENTRY_MIN = "Min";
        public static final String KEY_ENTRY_MIN_NOISE = "MinNoise";
        public static final String KEY_ENTRY_MAX = "Max";
        public static final String KEY_ENTRY_MAX_NOISE = "MaxNoise";
        public static final String KEY_ENTRY_NOISE_MASK = "NoiseMask";
        public static final String ERROR_ENTRY_NO_MAX = "Could not find maximum of water container entry.";
    }
}