/*
 ** Authored by Timothy Gerard Endres
 ** <mailto:time@gjt.org>  <http://www.trustice.com>
 **
 ** This work has been placed into the public domain.
 ** You may use this work in any way and for any purpose you wish.
 **
 ** THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY OF ANY KIND,
 ** NOT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY. THE AUTHOR
 ** OF THIS SOFTWARE, ASSUMES _NO_ RESPONSIBILITY FOR ANY
 ** CONSEQUENCE RESULTING FROM THE USE, MODIFICATION, OR
 ** REDISTRIBUTION OF THIS SOFTWARE.
 **
 */

package org.jboss.shrinkwrap.impl.base.io.tar;

import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * The TarOutputStream writes a UNIX tar archive as an OutputStream. Methods are provided to put entries, and then write
 * their contents by writing to this stream using write().
 *
 * Kerry Menzel <kmenzel@cfl.rr.com> Contributed the code to support file sizes greater than 2GB (longs versus ints).
 *
 * @version $Revision: 1.8 $
 * @author Timothy Gerard Endres, <time@gjt.org>
 * @see TarBuffer
 * @see TarHeader
 * @see TarEntry
 */

public class TarOutputStreamImpl extends FilterOutputStream {
    protected boolean debug;
    protected long currSize;
    protected long currBytes;
    protected byte[] oneBuf;
    protected byte[] recordBuf;
    protected int assemLen;
    protected byte[] assemBuf;
    protected TarBuffer buffer;

    public TarOutputStreamImpl(OutputStream os) {
        this(os, TarBuffer.DEFAULT_BLKSIZE, TarBuffer.DEFAULT_RCDSIZE);
    }

    public TarOutputStreamImpl(OutputStream os, int blockSize) {
        this(os, blockSize, TarBuffer.DEFAULT_RCDSIZE);
    }

    public TarOutputStreamImpl(OutputStream os, int blockSize, int recordSize) {
        super(os);

        this.buffer = new TarBuffer(os, blockSize, recordSize);

        this.debug = false;
        this.assemLen = 0;
        this.assemBuf = new byte[recordSize];
        this.recordBuf = new byte[recordSize];
        this.oneBuf = new byte[1];
    }

    /**
     * Sets the debugging flag.
     *
     * @param debugF
     *            True to turn on debugging.
     */
    public void setDebug(boolean debugF) {
        this.debug = debugF;
    }

    /**
     * Sets the debugging flag in this stream's TarBuffer.
     *
     * @param debugF
     *            True to turn on debugging.
     */
    public void setBufferDebug(boolean debug) {
        this.buffer.setDebug(debug);
    }

    /**
     * Ends the TAR archive without closing the underlying OutputStream. The result is that the EOF record of nulls is
     * written.
     */

    public void finish() throws IOException {
        this.writeEOFRecord();
    }

    /**
     * Ends the TAR archive and closes the underlying OutputStream. This means that finish() is called followed by
     * calling the TarBuffer's close().
     */

    public void close() throws IOException {
        this.finish();
        this.buffer.close();
    }

    /**
     * Get the record size being used by this stream's TarBuffer.
     *
     * @return The TarBuffer record size.
     */
    public int getRecordSize() {
        return this.buffer.getRecordSize();
    }

    /**
     * Put an entry on the output stream. This writes the entry's header record and positions the output stream for
     * writing the contents of the entry. Once this method is called, the stream is ready for calls to write() to write
     * the entry's contents. Once the contents are written, closeEntry() <B>MUST</B> be called to ensure that all
     * buffered data is completely written to the output stream.
     *
     * @param entry
     *            The TarEntry to be written to the archive.
     */
    public void putNextEntry(TarEntry entry) throws IOException {
        StringBuffer name = entry.getHeader().name;

        // NOTE
        // This check is not adequate, because the maximum file length that
        // can be placed into a POSIX (ustar) header depends on the precise
        // locations of the path elements (slashes) within the file's full
        // pathname. For this reason, writeEntryHeader() can still throw an
        // InvalidHeaderException if the file's full pathname will not fit
        // in the header.

        if ((entry.isUnixTarFormat() && name.length() > TarHeader.NAMELEN)
            || (!entry.isUnixTarFormat() && name.length() > (TarHeader.NAMELEN + TarHeader.PREFIXLEN))) {
            throw new InvalidHeaderException("file name '" + name + "' is too long ( " + name.length() + " > "
                + (entry.isUnixTarFormat() ? TarHeader.NAMELEN : (TarHeader.NAMELEN + TarHeader.PREFIXLEN))
                + " bytes )");
        }

        entry.writeEntryHeader(this.recordBuf);

        this.buffer.writeRecord(this.recordBuf);

        this.currBytes = 0;

        if (entry.isDirectory()) {
            this.currSize = 0;
        } else {
            this.currSize = entry.getSize();
        }
    }

    /**
     * Close an entry. This method MUST be called for all file entries that contain data. The reason is that we must
     * buffer data written to the stream in order to satisfy the buffer's record based writes. Thus, there may be data
     * fragments still being assembled that must be written to the output stream before this entry is closed and the
     * next entry written.
     */
    public void closeEntry() throws IOException {
        if (this.assemLen > 0) {
            for (int i = this.assemLen; i < this.assemBuf.length; ++i) {
                this.assemBuf[i] = 0;
            }

            this.buffer.writeRecord(this.assemBuf);

            this.currBytes += this.assemLen;
            this.assemLen = 0;
        }

        if (this.currBytes < this.currSize) {
            throw new IOException("entry closed at '" + this.currBytes + "' before the '" + this.currSize
                + "' bytes specified in the header were written");
        }
    }

    /**
     * Writes a byte to the current tar archive entry.
     *
     * This method simply calls read( byte[], int, int ).
     *
     * @param b
     *            The byte written.
     */
    public void write(int b) throws IOException {
        this.oneBuf[0] = (byte) b;
        this.write(this.oneBuf, 0, 1);
    }

    /**
     * Writes bytes to the current tar archive entry.
     *
     * This method simply calls read( byte[], int, int ).
     *
     * @param wBuf
     *            The buffer to write to the archive.
     * @return The number of bytes read, or -1 at EOF.
     */
    public void write(byte[] wBuf) throws IOException {
        this.write(wBuf, 0, wBuf.length);
    }

    /**
     * Writes bytes to the current tar archive entry. This method is aware of the current entry and will throw an
     * exception if you attempt to write bytes past the length specified for the current entry. The method is also
     * (painfully) aware of the record buffering required by TarBuffer, and manages buffers that are not a multiple of
     * recordsize in length, including assembling records from small buffers.
     *
     * This method simply calls read( byte[], int, int ).
     *
     * @param wBuf
     *            The buffer to write to the archive.
     * @param wOffset
     *            The offset in the buffer from which to get bytes.
     * @param numToWrite
     *            The number of bytes to write.
     */
    public void write(byte[] wBuf, int wOffset, int numToWrite) throws IOException {
        if ((this.currBytes + numToWrite) > this.currSize) {
            throw new IOException("request to write '" + numToWrite + "' bytes exceeds size in header of '"
                + this.currSize + "' bytes");
        }

        //
        // We have to deal with assembly!!!
        // The programmer can be writing little 32 byte chunks for all
        // we know, and we must assemble complete records for writing.
        // REVIEW Maybe this should be in TarBuffer? Could that help to
        // eliminate some of the buffer copying.
        //
        if (this.assemLen > 0) {
            if ((this.assemLen + numToWrite) >= this.recordBuf.length) {
                int aLen = this.recordBuf.length - this.assemLen;

                System.arraycopy(this.assemBuf, 0, this.recordBuf, 0, this.assemLen);

                System.arraycopy(wBuf, wOffset, this.recordBuf, this.assemLen, aLen);

                this.buffer.writeRecord(this.recordBuf);

                this.currBytes += this.recordBuf.length;

                wOffset += aLen;
                numToWrite -= aLen;
                this.assemLen = 0;
            } else // ( (this.assemLen + numToWrite ) < this.recordBuf.length )
            {
                System.arraycopy(wBuf, wOffset, this.assemBuf, this.assemLen, numToWrite);
                wOffset += numToWrite;
                this.assemLen += numToWrite;
                numToWrite -= numToWrite;
            }
        }

        //
        // When we get here we have EITHER:
        // o An empty "assemble" buffer.
        // o No bytes to write (numToWrite == 0)
        //

        for (; numToWrite > 0;) {
            if (numToWrite < this.recordBuf.length) {
                System.arraycopy(wBuf, wOffset, this.assemBuf, this.assemLen, numToWrite);
                this.assemLen += numToWrite;
                break;
            }

            this.buffer.writeRecord(wBuf, wOffset);

            long num = this.recordBuf.length;
            this.currBytes += num;
            numToWrite -= num;
            wOffset += num;
        }
    }

    /**
     * Write an EOF (end of archive) record to the tar archive. An EOF record consists of a record of all zeros.
     */
    private void writeEOFRecord() throws IOException {
        for (int i = 0; i < this.recordBuf.length; ++i) {
            this.recordBuf[i] = 0;
        }
        this.buffer.writeRecord(this.recordBuf);
    }

}
