/*
 *  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
 *
 *      http://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.tomcat.util.buf;

import java.io.Serial;
import java.io.Serializable;

import org.apache.tomcat.util.res.StringManager;

/**
 * Base class for the *Chunk implementation to reduce duplication.
 */
public abstract class AbstractChunk implements Cloneable, Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * The string manager for this package.
     */
    protected static final StringManager sm = StringManager.getManager(AbstractChunk.class);

    /*
     * JVMs may limit the maximum array size to slightly less than Integer.MAX_VALUE. On markt's desktop the limit is
     * MAX_VALUE - 2. Comments in the JRE source code for ArrayList and other classes indicate that it may be as low as
     * MAX_VALUE - 8 on some systems.
     */
    /**
     * The maximum size of an array.
     */
    public static final int ARRAY_MAX_SIZE = Integer.MAX_VALUE - 8;

    /**
     * The cached hash code.
     */
    private int hashCode = 0;

    /**
     * Indicates whether the hash code has been computed.
     */
    protected boolean hasHashCode = false;

    /**
     * Indicates whether the chunk has been initialized.
     */
    protected boolean isSet;

    /**
     * The limit on the amount of data in the buffer.
     */
    private int limit = -1;

    /**
     * The start position of the data in the buffer.
     */
    protected int start;

    /**
     * The end position of the data in the buffer.
     */
    protected int end;

    /**
     * Constructs a new AbstractChunk.
     */
    protected AbstractChunk() {
    }


    /**
     * Maximum amount of data in this buffer. If -1 or not set, the buffer will grow to {{@link #ARRAY_MAX_SIZE}. Can be
     * smaller than the current buffer size ( which will not shrink ). When the limit is reached, the buffer will be
     * flushed (if out is set) or throw exception.
     *
     * @param limit The new limit
     */
    public void setLimit(int limit) {
        this.limit = limit;
    }


    /**
     * Returns the maximum amount of data in the buffer.
     *
     * @return the maximum amount of data in the buffer, and -1 if it has not been set
     */
    public int getLimit() {
        return limit;
    }


    /**
     * Returns the internal limit for the buffer.
     *
     * @return the internal limit
     */
    protected int getLimitInternal() {
        if (limit > 0) {
            return limit;
        } else {
            return ARRAY_MAX_SIZE;
        }
    }


    /**
     * Returns the start position of the data in the buffer.
     *
     * @return the start position of the data in the buffer
     */
    public int getStart() {
        return start;
    }


    /**
     * Set the start position of the data in the buffer.
     *
     * @param start the new start position
     */
    public void setStart(int start) {
        if (end < start) {
            end = start;
        }
        this.start = start;
    }


    /**
     * Returns the end position of the data in the buffer.
     *
     * @return the end position of the data in the buffer
     */
    public int getEnd() {
        return end;
    }


    /**
     * Set the end position of the data in the buffer.
     *
     * @param end the new end position
     */
    public void setEnd(int end) {
        this.end = end;
    }


    /**
     * @return start
     *
     * @deprecated Unused. This method will be removed in Tomcat 12.
     */
    @Deprecated
    public int getOffset() {
        return start;
    }

    /**
     * Set start.
     *
     * @param off the new start
     *
     * @deprecated Unused. This method will be removed in Tomcat 12.
     */
    @Deprecated
    public void setOffset(int off) {
        if (end < off) {
            end = off;
        }
        start = off;
    }


    /**
     * Returns the length of the data in the buffer.
     *
     * @return the length of the data in the buffer
     */
    public int getLength() {
        return end - start;
    }


    /**
     * Returns whether the buffer contains no data.
     *
     * @return {@code true} if the buffer contains no data
     */
    public boolean isNull() {
        if (end > 0) {
            return false;
        }
        return !isSet;
    }


    /**
     * Return the index of the first occurrence of the subsequence of the given String, or -1 if it is not found.
     *
     * @param src      the String to look for
     * @param srcStart the subsequence start in the String
     * @param srcLen   the subsequence length in the String
     * @param myOffset the index on which to start the search in the buffer
     *
     * @return the position of the first character of the first occurrence of the subsequence in the buffer, or -1 if
     *             not found
     */
    public int indexOf(String src, int srcStart, int srcLen, int myOffset) {
        char first = src.charAt(srcStart);

        // Look for first char
        int srcEnd = srcStart + srcLen;

        mainLoop:
        for (int i = myOffset + start; i <= (end - srcLen); i++) {
            if (getBufferElement(i) != first) {
                continue;
            }
            // found first char, now look for a match
            int myPos = i + 1;
            for (int srcPos = srcStart + 1; srcPos < srcEnd;) {
                if (getBufferElement(myPos++) != src.charAt(srcPos++)) {
                    continue mainLoop;
                }
            }
            return i - start; // found it
        }
        return -1;
    }


    /**
     * Resets the chunk to an uninitialized state.
     */
    public void recycle() {
        hasHashCode = false;
        isSet = false;
        start = 0;
        end = 0;
    }


    @Override
    public int hashCode() {
        if (hasHashCode) {
            return hashCode;
        }
        int code = hash();
        hashCode = code;
        hasHashCode = true;
        return code;
    }


    /**
     * {@inheritDoc}
     * <p>
     * Sub-classes must provide an equals implementation that is consistent with {@link AbstractChunk#hashCode()}.
     */
    @Override
    public abstract boolean equals(Object obj);


    /**
     * Returns the hash code for this buffer.
     *
     * @return the hash code for this buffer
     */
    public int hash() {
        int code = 0;
        for (int i = start; i < end; i++) {
            code = code * 37 + getBufferElement(i);
        }
        return code;
    }


    /**
     * Returns the element at the specified index in the buffer.
     *
     * @param index the element location in the buffer
     *
     * @return the element
     */
    protected abstract int getBufferElement(int index);
}
