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

package io.sentry.cache.tape;

import java.io.ByteArrayOutputStream;
import java.util.Iterator;
import org.jetbrains.annotations.Nullable;
import java.io.IOException;
import java.io.OutputStream;
import org.jetbrains.annotations.NotNull;

final class FileObjectQueue<T> extends ObjectQueue<T>
{
    private final QueueFile queueFile;
    private final DirectByteArrayOutputStream bytes;
    final Converter<T> converter;
    
    FileObjectQueue(final QueueFile queueFile, final Converter<T> converter) {
        this.bytes = new DirectByteArrayOutputStream();
        this.queueFile = queueFile;
        this.converter = converter;
    }
    
    @NotNull
    @Override
    public QueueFile file() {
        return this.queueFile;
    }
    
    @Override
    public int size() {
        return this.queueFile.size();
    }
    
    @Override
    public boolean isEmpty() {
        return this.queueFile.isEmpty();
    }
    
    @Override
    public void add(final T entry) throws IOException {
        this.bytes.reset();
        this.converter.toStream(entry, this.bytes);
        this.queueFile.add(this.bytes.getArray(), 0, this.bytes.size());
    }
    
    @Nullable
    @Override
    public T peek() throws IOException {
        final byte[] bytes = this.queueFile.peek();
        if (bytes == null) {
            return null;
        }
        return this.converter.from(bytes);
    }
    
    @Override
    public void remove() throws IOException {
        this.queueFile.remove();
    }
    
    @Override
    public void remove(final int n) throws IOException {
        this.queueFile.remove(n);
    }
    
    @Override
    public void clear() throws IOException {
        this.queueFile.clear();
    }
    
    @Override
    public void close() throws IOException {
        this.queueFile.close();
    }
    
    @Override
    public Iterator<T> iterator() {
        return new QueueFileIterator(this.queueFile.iterator());
    }
    
    @Override
    public String toString() {
        return "FileObjectQueue{queueFile=" + this.queueFile + '}';
    }
    
    private final class QueueFileIterator implements Iterator<T>
    {
        final Iterator<byte[]> iterator;
        
        QueueFileIterator(final Iterator<byte[]> iterator) {
            this.iterator = iterator;
        }
        
        @Override
        public boolean hasNext() {
            return this.iterator.hasNext();
        }
        
        @Nullable
        @Override
        public T next() {
            final byte[] data = this.iterator.next();
            try {
                return FileObjectQueue.this.converter.from(data);
            }
            catch (final IOException e) {
                throw (Error)QueueFile.getSneakyThrowable(e);
            }
        }
        
        @Override
        public void remove() {
            this.iterator.remove();
        }
    }
    
    private static final class DirectByteArrayOutputStream extends ByteArrayOutputStream
    {
        DirectByteArrayOutputStream() {
        }
        
        byte[] getArray() {
            return this.buf;
        }
    }
}