/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.commons.compress.archivers.ar;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.LinkOption;
import java.nio.file.Path;

import org.apache.commons.compress.archivers.ArchiveOutputStream;

/**
 * Implements the "ar" archive format as an output stream.
 *
 * @NotThreadSafe
 */
public class ArArchiveOutputStream extends ArchiveOutputStream<ArArchiveEntry> {

    private static final char PAD = '\n';

    private static final char SPACE = ' ';

    /** Fail if a long file name is required in the archive. */
    public static final int LONGFILE_ERROR = 0;

    /** BSD ar extensions are used to store long file names in the archive. */
    public static final int LONGFILE_BSD = 1;

    private long entryOffset;
    private int headerPlus;
    private ArArchiveEntry prevEntry;
    private boolean prevEntryOpen;
    private int longFileMode = LONGFILE_ERROR;

    /**
     * Constructs a new instance with the given backing OutputStream.
     *
     * @param out the underlying output stream to be assigned to the field {@code this.out} for later use, or {@code null} if this instance is to be created
     *            without an underlying stream.
     */
    public ArArchiveOutputStream(final OutputStream out) {
        super(out);
    }

    private String checkLength(final String value, final int max, final String name) throws IOException {
        if (value.length() > max) {
            throw new IOException(name + " too long");
        }
        return value;
    }

    /**
     * Calls finish if necessary, and then closes the OutputStream
     */
    @Override
    public void close() throws IOException {
        try {
            if (!isFinished()) {
                finish();
            }
        } finally {
            prevEntry = null;
            super.close();
        }
    }

    @Override
    public void closeArchiveEntry() throws IOException {
        checkFinished();
        if (prevEntry == null || !prevEntryOpen) {
            throw new IOException("No current entry to close");
        }
        if ((headerPlus + entryOffset) % 2 != 0) {
            out.write(PAD); // Pad byte
        }
        prevEntryOpen = false;
    }

    @Override
    public ArArchiveEntry createArchiveEntry(final File inputFile, final String entryName) throws IOException {
        checkFinished();
        return new ArArchiveEntry(inputFile, entryName);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.21
     */
    @Override
    public ArArchiveEntry createArchiveEntry(final Path inputPath, final String entryName, final LinkOption... options) throws IOException {
        checkFinished();
        return new ArArchiveEntry(inputPath, entryName, options);
    }

    @Override
    public void finish() throws IOException {
        if (prevEntryOpen) {
            throw new IOException("This archive contains unclosed entries.");
        }
        checkFinished();
        super.finish();
    }

    private int pad(final int offset, final int newOffset, final char fill) throws IOException {
        final int diff = newOffset - offset;
        if (diff > 0) {
            for (int i = 0; i < diff; i++) {
                write(fill);
            }
        }
        return newOffset;
    }

    @Override
    public void putArchiveEntry(final ArArchiveEntry entry) throws IOException {
        checkFinished();
        if (prevEntry == null) {
            writeArchiveHeader();
        } else {
            if (prevEntry.getLength() != entryOffset) {
                throw new IOException("Length does not match entry (" + prevEntry.getLength() + " != " + entryOffset);
            }
            if (prevEntryOpen) {
                closeArchiveEntry();
            }
        }
        prevEntry = entry;
        headerPlus = writeEntryHeader(entry);
        entryOffset = 0;
        prevEntryOpen = true;
    }

    /**
     * Sets the long file mode. This can be LONGFILE_ERROR(0) or LONGFILE_BSD(1). This specifies the treatment of long file names (names &gt;= 16). Default is
     * LONGFILE_ERROR.
     *
     * @param longFileMode the mode to use
     * @since 1.3
     */
    public void setLongFileMode(final int longFileMode) {
        this.longFileMode = longFileMode;
    }

    @Override
    public void write(final byte[] b, final int off, final int len) throws IOException {
        out.write(b, off, len);
        count(len);
        entryOffset += len;
    }

    private int write(final String data) throws IOException {
        return writeUsAscii(data).length;
    }

    private byte[] writeArchiveHeader() throws IOException {
        return writeUsAscii(ArArchiveEntry.HEADER);
    }

    private int writeEntryHeader(final ArArchiveEntry entry) throws IOException {
        int offset = 0;
        boolean appendName = false;
        final String eName = entry.getName();
        final int nLength = eName.length();
        if (LONGFILE_ERROR == longFileMode && nLength > 16) {
            throw new IOException("File name too long, > 16 chars: " + eName);
        }
        if (LONGFILE_BSD == longFileMode && (nLength > 16 || eName.indexOf(SPACE) > -1)) {
            appendName = true;
            final String fileNameLen = ArArchiveInputStream.BSD_LONGNAME_PREFIX + nLength;
            if (fileNameLen.length() > 16) {
                throw new IOException("File length too long, > 16 chars: " + eName);
            }
            offset += write(fileNameLen);
        } else {
            offset += write(eName);
        }
        offset = pad(offset, 16, SPACE);
        // Last modified
        offset += write(checkLength(String.valueOf(entry.getLastModified()), 12, "Last modified"));
        offset = pad(offset, 28, SPACE);
        // User ID
        offset += write(checkLength(String.valueOf(entry.getUserId()), 6, "User ID"));
        offset = pad(offset, 34, SPACE);
        // Group ID
        offset += write(checkLength(String.valueOf(entry.getGroupId()), 6, "Group ID"));
        offset = pad(offset, 40, SPACE);
        // Mode
        offset += write(checkLength(String.valueOf(Integer.toString(entry.getMode(), 8)), 8, "File mode"));
        offset = pad(offset, 48, SPACE);
        // Size
        // On overflow, the file size is incremented by the length of the name.
        offset += write(checkLength(String.valueOf(entry.getLength() + (appendName ? nLength : 0)), 10, "Size"));
        offset = pad(offset, 58, SPACE);
        offset += write(ArArchiveEntry.TRAILER);
        // Name
        if (appendName) {
            offset += write(eName);
        }
        return offset;
    }

}
