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

package io.sentry.util;

import org.jetbrains.annotations.Nullable;
import io.sentry.SentryLevel;
import java.io.Writer;
import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.ByteArrayOutputStream;
import io.sentry.JsonSerializable;
import io.sentry.ILogger;
import io.sentry.ISerializer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.HashMap;
import java.util.Map;
import org.jetbrains.annotations.NotNull;
import java.util.Calendar;
import java.nio.charset.Charset;
import org.jetbrains.annotations.ApiStatus;

@ApiStatus.Internal
public final class JsonSerializationUtils
{
    private static final Charset UTF_8;
    
    @NotNull
    public static Map<String, Object> calendarToMap(@NotNull final Calendar calendar) {
        final Map<String, Object> map = new HashMap<String, Object>();
        map.put("year", calendar.get(1));
        map.put("month", calendar.get(2));
        map.put("dayOfMonth", calendar.get(5));
        map.put("hourOfDay", calendar.get(11));
        map.put("minute", calendar.get(12));
        map.put("second", calendar.get(13));
        return map;
    }
    
    @NotNull
    public static List<Object> atomicIntegerArrayToList(@NotNull final AtomicIntegerArray array) {
        final int numberOfItems = array.length();
        final List<Object> list = new ArrayList<Object>(numberOfItems);
        for (int i = 0; i < numberOfItems; ++i) {
            list.add(array.get(i));
        }
        return list;
    }
    
    @Nullable
    public static byte[] bytesFrom(@NotNull final ISerializer serializer, @NotNull final ILogger logger, @NotNull final JsonSerializable serializable) {
        try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
             final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, JsonSerializationUtils.UTF_8))) {
            serializer.serialize(serializable, writer);
            return stream.toByteArray();
        }
        catch (final Throwable t) {
            logger.log(SentryLevel.ERROR, "Could not serialize serializable", t);
            return null;
        }
    }
    
    public static long byteSizeOf(@NotNull final ISerializer serializer, @NotNull final ILogger logger, @Nullable final JsonSerializable serializable) {
        if (serializable == null) {
            return 0L;
        }
        try {
            final ByteCountingWriter writer = new ByteCountingWriter();
            serializer.serialize(serializable, writer);
            return writer.getByteCount();
        }
        catch (final Throwable t) {
            logger.log(SentryLevel.ERROR, "Could not calculate size of serializable", t);
            return 0L;
        }
    }
    
    static {
        UTF_8 = Charset.forName("UTF-8");
    }
    
    private static final class ByteCountingWriter extends Writer
    {
        private long byteCount;
        
        private ByteCountingWriter() {
            this.byteCount = 0L;
        }
        
        @Override
        public void write(final char[] cbuf, final int off, final int len) {
            for (int i = off; i < off + len; ++i) {
                this.byteCount += utf8ByteCount(cbuf[i]);
            }
        }
        
        @Override
        public void write(final int c) {
            this.byteCount += utf8ByteCount((char)c);
        }
        
        @Override
        public void write(@NotNull final String str, final int off, final int len) {
            for (int i = off; i < off + len; ++i) {
                this.byteCount += utf8ByteCount(str.charAt(i));
            }
        }
        
        @Override
        public void flush() {
        }
        
        @Override
        public void close() {
        }
        
        public long getByteCount() {
            return this.byteCount;
        }
        
        private static int utf8ByteCount(final char c) {
            if (c <= '\u007f') {
                return 1;
            }
            if (c <= '\u07ff') {
                return 2;
            }
            if (Character.isSurrogate(c)) {
                return 2;
            }
            return 3;
        }
    }
}