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

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.schema.SchemaConvertable;
import com.hypixel.hytale.codec.codecs.StringIntegerCodec;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.SchemaContext;
import java.io.IOException;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.objects.ObjectIterator;
import java.util.Iterator;
import org.bson.BsonDocument;
import it.unimi.dsi.fastutil.ints.Int2ObjectMaps;
import com.hypixel.hytale.codec.exception.CodecException;
import java.util.Map;
import com.hypixel.hytale.codec.ExtraInfo;
import javax.annotation.Nonnull;
import org.bson.BsonValue;
import java.util.function.Supplier;
import com.hypixel.hytale.codec.WrappedCodec;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import com.hypixel.hytale.codec.Codec;

public class Int2ObjectMapCodec<T> implements Codec<Int2ObjectMap<T>>, WrappedCodec<T>
{
    private final Codec<T> valueCodec;
    private final Supplier<Int2ObjectMap<T>> supplier;
    private final boolean unmodifiable;
    
    public Int2ObjectMapCodec(final Codec<T> valueCodec, final Supplier<Int2ObjectMap<T>> supplier, final boolean unmodifiable) {
        this.valueCodec = valueCodec;
        this.supplier = supplier;
        this.unmodifiable = unmodifiable;
    }
    
    public Int2ObjectMapCodec(final Codec<T> valueCodec, final Supplier<Int2ObjectMap<T>> supplier) {
        this(valueCodec, supplier, true);
    }
    
    @Override
    public Codec<T> getChildCodec() {
        return this.valueCodec;
    }
    
    @Override
    public Int2ObjectMap<T> decode(@Nonnull final BsonValue bsonValue, @Nonnull final ExtraInfo extraInfo) {
        final BsonDocument bsonDocument = bsonValue.asDocument();
        Int2ObjectMap<T> map = this.supplier.get();
        for (final Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            final String key = entry.getKey();
            final BsonValue value = entry.getValue();
            extraInfo.pushKey(key);
            try {
                final int decodedKey = Integer.parseInt(key);
                map.put(decodedKey, this.valueCodec.decode(value, extraInfo));
            }
            catch (final Exception e) {
                throw new CodecException("Failed to decode", value, extraInfo, e);
            }
            finally {
                extraInfo.popKey();
            }
        }
        if (this.unmodifiable) {
            map = Int2ObjectMaps.unmodifiable((Int2ObjectMap<? extends T>)map);
        }
        return map;
    }
    
    @Nonnull
    @Override
    public BsonValue encode(@Nonnull final Int2ObjectMap<T> map, final ExtraInfo extraInfo) {
        final BsonDocument bsonDocument = new BsonDocument();
        for (final Int2ObjectMap.Entry<T> entry : map.int2ObjectEntrySet()) {
            bsonDocument.put(Integer.toString(entry.getIntKey()), this.valueCodec.encode(entry.getValue(), extraInfo));
        }
        return bsonDocument;
    }
    
    @Override
    public Int2ObjectMap<T> decodeJson(@Nonnull final RawJsonReader reader, @Nonnull final ExtraInfo extraInfo) throws IOException {
        reader.expect('{');
        reader.consumeWhiteSpace();
        Int2ObjectMap<T> map = this.supplier.get();
        if (reader.tryConsume('}')) {
            if (this.unmodifiable) {
                map = Int2ObjectMaps.unmodifiable((Int2ObjectMap<? extends T>)map);
            }
            return map;
        }
        while (true) {
            reader.expect('\"');
            final int decodedKey = reader.readIntValue();
            reader.expect('\"');
            reader.consumeWhiteSpace();
            reader.expect(':');
            reader.consumeWhiteSpace();
            extraInfo.pushIntKey(decodedKey, reader);
            try {
                map.put(decodedKey, this.valueCodec.decodeJson(reader, extraInfo));
            }
            catch (final Exception e) {
                throw new CodecException("Failed to decode", reader, extraInfo, e);
            }
            finally {
                extraInfo.popKey();
            }
            reader.consumeWhiteSpace();
            if (reader.tryConsumeOrExpect('}', ',')) {
                break;
            }
            reader.consumeWhiteSpace();
        }
        if (this.unmodifiable) {
            map = Int2ObjectMaps.unmodifiable((Int2ObjectMap<? extends T>)map);
        }
        return map;
    }
    
    @Nonnull
    @Override
    public Schema toSchema(@Nonnull final SchemaContext context) {
        final ObjectSchema s = new ObjectSchema();
        final StringSchema name = StringIntegerCodec.INSTANCE.toSchema(context);
        s.setPropertyNames(name);
        s.setAdditionalProperties(context.refDefinition(this.valueCodec));
        return s;
    }
}