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

package io.netty.handler.pcap;

import io.netty.util.internal.logging.InternalLoggerFactory;
import io.netty.buffer.ByteBuf;
import java.io.IOException;
import java.io.OutputStream;
import io.netty.util.internal.logging.InternalLogger;
import java.io.Closeable;

final class PcapWriter implements Closeable
{
    private static final InternalLogger logger;
    private final PcapWriteHandler pcapWriteHandler;
    private final OutputStream outputStream;
    
    PcapWriter(final PcapWriteHandler pcapWriteHandler) throws IOException {
        this.pcapWriteHandler = pcapWriteHandler;
        this.outputStream = pcapWriteHandler.outputStream();
        if (pcapWriteHandler.writePcapGlobalHeader() && !pcapWriteHandler.sharedOutputStream()) {
            PcapHeaders.writeGlobalHeader(pcapWriteHandler.outputStream());
        }
    }
    
    void writePacket(final ByteBuf packetHeaderBuf, final ByteBuf packet) throws IOException {
        if (this.pcapWriteHandler.state() == State.CLOSED) {
            PcapWriter.logger.debug("Pcap Write attempted on closed PcapWriter");
        }
        final long timestamp = System.currentTimeMillis();
        PcapHeaders.writePacketHeader(packetHeaderBuf, (int)(timestamp / 1000L), (int)(timestamp % 1000L * 1000L), packet.readableBytes(), packet.readableBytes());
        if (this.pcapWriteHandler.sharedOutputStream()) {
            synchronized (this.outputStream) {
                packetHeaderBuf.readBytes(this.outputStream, packetHeaderBuf.readableBytes());
                packet.readBytes(this.outputStream, packet.readableBytes());
            }
        }
        else {
            packetHeaderBuf.readBytes(this.outputStream, packetHeaderBuf.readableBytes());
            packet.readBytes(this.outputStream, packet.readableBytes());
        }
    }
    
    @Override
    public String toString() {
        return "PcapWriter{outputStream=" + this.outputStream + '}';
    }
    
    @Override
    public void close() throws IOException {
        if (this.pcapWriteHandler.state() == State.CLOSED) {
            PcapWriter.logger.debug("PcapWriter is already closed");
        }
        else {
            if (this.pcapWriteHandler.sharedOutputStream()) {
                synchronized (this.outputStream) {
                    this.outputStream.flush();
                }
            }
            else {
                this.outputStream.flush();
                this.outputStream.close();
            }
            this.pcapWriteHandler.markClosed();
            PcapWriter.logger.debug("PcapWriter is now closed");
        }
    }
    
    static {
        logger = InternalLoggerFactory.getInstance(PcapWriter.class);
    }
}