/*
 * 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.logging.log4j.core.pattern;

import org.apache.logging.log4j.util.PerformanceSensitive;

Modifies the output of a pattern converter for a specified minimum and maximum width and alignment.
/**
 * Modifies the output of a pattern converter for a specified minimum and maximum width and alignment.
 */
@PerformanceSensitive("allocation")
public final class FormattingInfo {
    
Array of spaces.
/**
     * Array of spaces.
     */
    private static final char[] SPACES = new char[] { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };

    
Array of zeros.
/**
     * Array of zeros.
     */
    private static final char[] ZEROS = new char[] { '0', '0', '0', '0', '0', '0', '0', '0' };

    
Default instance.
/**
     * Default instance.
     */
    private static final FormattingInfo DEFAULT = new FormattingInfo(false, 0, Integer.MAX_VALUE, true);

    
Minimum length.
/**
     * Minimum length.
     */
    private final int minLength;

    
Maximum length.
/**
     * Maximum length.
     */
    private final int maxLength;

    
Alignment.
/**
     * Alignment.
     */
    private final boolean leftAlign;

    
Left vs. right-hand side truncation.
/**
     * Left vs. right-hand side truncation.
     */
    private final boolean leftTruncate;

    
Use zero-padding instead whitespace padding
/**
     * Use zero-padding instead whitespace padding
     */
    private final boolean zeroPad;

    
Creates new instance.
Params:
leftAlign – 
           left align if true.
minLength – 
           minimum length.
maxLength – 
           maximum length.
leftTruncate – 
           truncates to the left if true/**
     * Creates new instance.
     *
     * @param leftAlign
     *            left align if true.
     * @param minLength
     *            minimum length.
     * @param maxLength
     *            maximum length.
     * @param leftTruncate
     *            truncates to the left if true
     */
    public FormattingInfo(final boolean leftAlign, final int minLength, final int maxLength, final boolean leftTruncate) {
        this(leftAlign, minLength, maxLength, leftTruncate, false);
    }

    
Creates new instance.
Params:
leftAlign – 
           left align if true.
minLength – 
           minimum length.
maxLength – 
           maximum length.
leftTruncate – 
           truncates to the left if true
zeroPad – 
           use zero-padding instead of whitespace-padding/**
     * Creates new instance.
     *
     * @param leftAlign
     *            left align if true.
     * @param minLength
     *            minimum length.
     * @param maxLength
     *            maximum length.
     * @param leftTruncate
     *            truncates to the left if true
     * @param zeroPad
     *            use zero-padding instead of whitespace-padding
     */
    public FormattingInfo(final boolean leftAlign, final int minLength, final int maxLength, final boolean leftTruncate, final boolean zeroPad) {
        this.leftAlign = leftAlign;
        this.minLength = minLength;
        this.maxLength = maxLength;
        this.leftTruncate = leftTruncate;
        this.zeroPad = zeroPad;
    }

    
Gets default instance.
Returns:
default instance./**
     * Gets default instance.
     *
     * @return default instance.
     */
    public static FormattingInfo getDefault() {
        return DEFAULT;
    }

    
Determine if left aligned.
Returns:
true if left aligned./**
     * Determine if left aligned.
     *
     * @return true if left aligned.
     */
    public boolean isLeftAligned() {
        return leftAlign;
    }

    
Determine if left truncated.
Returns:
true if left truncated./**
     * Determine if left truncated.
     *
     * @return true if left truncated.
     */
    public boolean isLeftTruncate() {
		return leftTruncate;
	}

    
Determine if zero-padded.
Returns:
true if zero-padded./**
     * Determine if zero-padded.
     *
     * @return true if zero-padded.
     */
    public boolean isZeroPad() {
        return zeroPad;
    }

    
Get minimum length.
Returns:
minimum length./**
     * Get minimum length.
     *
     * @return minimum length.
     */
    public int getMinLength() {
        return minLength;
    }

    
Get maximum length.
Returns:
maximum length./**
     * Get maximum length.
     *
     * @return maximum length.
     */
    public int getMaxLength() {
        return maxLength;
    }

    
Adjust the content of the buffer based on the specified lengths and alignment.
Params:
fieldStart – 
           start of field in buffer.
buffer – 
           buffer to be modified./**
     * Adjust the content of the buffer based on the specified lengths and alignment.
     *
     * @param fieldStart
     *            start of field in buffer.
     * @param buffer
     *            buffer to be modified.
     */
    public void format(final int fieldStart, final StringBuilder buffer) {
        final int rawLength = buffer.length() - fieldStart;

        if (rawLength > maxLength) {
			if (leftTruncate) {
				buffer.delete(fieldStart, buffer.length() - maxLength);
			} else {
				buffer.delete(fieldStart + maxLength, fieldStart + buffer.length());
			}
        } else if (rawLength < minLength) {
            if (leftAlign) {
                final int fieldEnd = buffer.length();
                buffer.setLength(fieldStart + minLength);

                for (int i = fieldEnd; i < buffer.length(); i++) {
                    buffer.setCharAt(i, ' ');
                }
            } else {
                int padLength = minLength - rawLength;

                final char[] paddingArray= zeroPad ? ZEROS : SPACES;

                for (; padLength > paddingArray.length; padLength -= paddingArray.length) {
                    buffer.insert(fieldStart, paddingArray);
                }

                buffer.insert(fieldStart, paddingArray, 0, padLength);
            }
        }
    }

    
Returns a String suitable for debugging.
Returns:
a String suitable for debugging./**
     * Returns a String suitable for debugging.
     *
     * @return a String suitable for debugging.
     */
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append(super.toString());
        sb.append("[leftAlign=");
        sb.append(leftAlign);
        sb.append(", maxLength=");
        sb.append(maxLength);
        sb.append(", minLength=");
        sb.append(minLength);
        sb.append(", leftTruncate=");
        sb.append(leftTruncate);
        sb.append(", zeroPad=");
        sb.append(zeroPad);
        sb.append(']');
        return sb.toString();
    }

}