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

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

import com.hypixel.hytale.codec.schema.SchemaConvertable;
import com.hypixel.hytale.codec.schema.config.StringSchema;
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 java.util.Iterator;
import org.bson.BsonDocument;
import java.util.Collections;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.ExtraInfo;
import javax.annotation.Nonnull;
import org.bson.BsonValue;
import java.util.function.Function;
import java.util.function.Supplier;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.Codec;
import java.util.Map;

@Deprecated
public class ObjectMapCodec<K, V, M extends Map<K, V>> implements Codec<Map<K, V>>, WrappedCodec<V>
{
    private final Codec<V> codec;
    private final Supplier<M> supplier;
    private final Function<K, String> keyToString;
    private final Function<String, K> stringToKey;
    private final boolean unmodifiable;
    
    public ObjectMapCodec(final Codec<V> codec, final Supplier<M> supplier, final Function<K, String> keyToString, final Function<String, K> stringToKey) {
        this(codec, supplier, keyToString, stringToKey, true);
    }
    
    public ObjectMapCodec(final Codec<V> codec, final Supplier<M> supplier, final Function<K, String> keyToString, final Function<String, K> stringToKey, final boolean unmodifiable) {
        this.codec = codec;
        this.supplier = supplier;
        this.keyToString = keyToString;
        this.stringToKey = stringToKey;
        this.unmodifiable = unmodifiable;
    }
    
    @Override
    public Codec<V> getChildCodec() {
        return this.codec;
    }
    
    @Override
    public Map<K, V> decode(@Nonnull final BsonValue bsonValue, @Nonnull final ExtraInfo extraInfo) {
        final BsonDocument bsonDocument = bsonValue.asDocument();
        Map<K, V> map = this.supplier.get();
        for (final Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            final String key = entry.getKey();
            final BsonValue value = entry.getValue();
            final K decodedKey = this.stringToKey.apply(key);
            extraInfo.pushKey(key);
            try {
                map.put(decodedKey, this.codec.decode(value, extraInfo));
            }
            catch (final Exception e) {
                throw new CodecException("Failed to decode", value, extraInfo, e);
            }
            finally {
                extraInfo.popKey();
            }
        }
        if (this.unmodifiable) {
            map = Collections.unmodifiableMap((Map<? extends K, ? extends V>)map);
        }
        return map;
    }
    
    @Nonnull
    @Override
    public BsonValue encode(@Nonnull final Map<K, V> map, final ExtraInfo extraInfo) {
        final BsonDocument bsonDocument = new BsonDocument();
        for (final Map.Entry<K, V> entry : map.entrySet()) {
            final BsonValue value = this.codec.encode(entry.getValue(), extraInfo);
            if (value != null && !value.isNull() && (!value.isDocument() || !value.asDocument().isEmpty()) && (!value.isArray() || !value.asArray().isEmpty())) {
                bsonDocument.put(this.keyToString.apply(entry.getKey()), value);
            }
        }
        return bsonDocument;
    }
    
    @Override
    public Map<K, V> decodeJson(@Nonnull final RawJsonReader reader, @Nonnull final ExtraInfo extraInfo) throws IOException {
        reader.expect('{');
        reader.consumeWhiteSpace();
        if (reader.tryConsume('}')) {
            return this.unmodifiable ? Collections.emptyMap() : ((M)this.supplier.get());
        }
        Map<K, V> map = this.supplier.get();
        while (true) {
            final String key = reader.readString();
            final K decodedKey = this.stringToKey.apply(key);
            reader.consumeWhiteSpace();
            reader.expect(':');
            reader.consumeWhiteSpace();
            extraInfo.pushKey(key, reader);
            try {
                map.put(decodedKey, this.codec.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 = Collections.unmodifiableMap((Map<? extends K, ? extends V>)map);
        }
        return map;
    }
    
    @Nonnull
    @Override
    public Schema toSchema(@Nonnull final SchemaContext context) {
        final ObjectSchema s = new ObjectSchema();
        s.setPropertyNames(new StringSchema());
        s.setAdditionalProperties(context.refDefinition(this.codec));
        return s;
    }
}