/*
 * 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.zip;

import static java.nio.charset.StandardCharsets.UTF_8;

import java.util.Arrays;
import java.util.zip.CRC32;
import java.util.zip.ZipException;

/**
 * A common base class for Unicode extra information extra fields.
 *
 * @NotThreadSafe
 */
public abstract class AbstractUnicodeExtraField implements ZipExtraField {
    private long nameCRC32;
    private byte[] unicodeName;
    private byte[] data;

    /**
     * Constructs a new instance.
     */
    protected AbstractUnicodeExtraField() {
    }

    /**
     * Assemble as unicode extension from the name/comment and encoding of the original ZIP entry.
     *
     * @param text  The file name or comment.
     * @param bytes The encoded of the file name or comment in the ZIP file.
     */
    protected AbstractUnicodeExtraField(final String text, final byte[] bytes) {
        this(text, bytes, 0, bytes.length);
    }

    /**
     * Assemble as unicode extension from the name/comment and encoding of the original ZIP entry.
     *
     * @param text  The file name or comment.
     * @param bytes The encoded of the file name or comment in the ZIP file.
     * @param off   The offset of the encoded file name or comment in {@code bytes}.
     * @param len   The length of the encoded file name or comment in {@code bytes}.
     */
    protected AbstractUnicodeExtraField(final String text, final byte[] bytes, final int off, final int len) {
        final CRC32 crc32 = new CRC32();
        crc32.update(bytes, off, len);
        nameCRC32 = crc32.getValue();

        unicodeName = text.getBytes(UTF_8);
    }

    private void assembleData() {
        if (unicodeName == null) {
            return;
        }

        data = new byte[5 + unicodeName.length];
        // version 1
        data[0] = 0x01;
        System.arraycopy(ZipLong.getBytes(nameCRC32), 0, data, 1, 4);
        System.arraycopy(unicodeName, 0, data, 5, unicodeName.length);
    }

    @Override
    public byte[] getCentralDirectoryData() {
        if (data == null) {
            assembleData();
        }
        byte[] b = null;
        if (data != null) {
            b = Arrays.copyOf(data, data.length);
        }
        return b;
    }

    @Override
    public ZipShort getCentralDirectoryLength() {
        if (data == null) {
            assembleData();
        }
        return ZipShort.lengthOf(data);
    }

    @Override
    public byte[] getLocalFileDataData() {
        return getCentralDirectoryData();
    }

    @Override
    public ZipShort getLocalFileDataLength() {
        return getCentralDirectoryLength();
    }

    /**
     * Gets the CRC32 checksum of the file name or comment as encoded in the central directory of the ZIP file.
     *
     * @return The CRC32 checksum of the file name or comment as encoded in the central directory of the ZIP file.
     */
    public long getNameCRC32() {
        return nameCRC32;
    }

    /**
     * Gets The UTF-8 encoded name.
     *
     * @return The UTF-8 encoded name.
     */
    public byte[] getUnicodeName() {
        return unicodeName != null ? Arrays.copyOf(unicodeName, unicodeName.length) : null;
    }

    /**
     * Doesn't do anything special since this class always uses the same data in central directory and local file data.
     */
    @Override
    public void parseFromCentralDirectoryData(final byte[] buffer, final int offset, final int length) throws ZipException {
        parseFromLocalFileData(buffer, offset, length);
    }

    @Override
    public void parseFromLocalFileData(final byte[] buffer, final int offset, final int length) throws ZipException {

        if (length < 5) {
            throw new ZipException("UniCode path extra data must have at least 5 bytes.");
        }

        final int version = buffer[offset];

        if (version != 0x01) {
            throw new ZipException("Unsupported version [" + version + "] for UniCode path extra data.");
        }

        nameCRC32 = ZipLong.getValue(buffer, offset + 1);
        unicodeName = new byte[length - 5];
        System.arraycopy(buffer, offset + 5, unicodeName, 0, length - 5);
        data = null;
    }

    /**
     * Gets The CRC32 checksum of the file name as encoded in the central directory of the ZIP file to set.
     *
     * @param nameCRC32 The CRC32 checksum of the file name as encoded in the central directory of the ZIP file to set.
     */
    public void setNameCRC32(final long nameCRC32) {
        this.nameCRC32 = nameCRC32;
        data = null;
    }

    /**
     * Gets the UTF-8 encoded name to set.
     *
     * @param unicodeName The UTF-8 encoded name to set.
     */
    public void setUnicodeName(final byte[] unicodeName) {
        if (unicodeName != null) {
            this.unicodeName = Arrays.copyOf(unicodeName, unicodeName.length);
        } else {
            this.unicodeName = null;
        }
        data = null;
    }
}