/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.lang.constant;

import java.util.ArrayList;

import java.util.List;

import java.util.Set;

import static java.util.Objects.requireNonNull;

/**

 * Helper methods for the implementation of {@code java.lang.constant}.

 */

class ConstantUtils {

    /** an empty constant descriptor */

    public static final ConstantDesc[] EMPTY_CONSTANTDESC = new ConstantDesc[0];

    static final Constable[] EMPTY_CONSTABLE = new Constable[0];

    static final int MAX_ARRAY_TYPE_DESC_DIMENSIONS = 255;

    private static final Set<String> pointyNames = Set.of("<init>", "<clinit>");

    /**

     * Validates the correctness of a binary class name. In particular checks for the presence of

     * invalid characters in the name.

     *

     * @param name the class name

     * @return the class name passed if valid

     * @throws IllegalArgumentException if the class name is invalid

     */

    static String validateBinaryClassName(String name) {

        for (int i=0; i<name.length(); i++) {

            char ch = name.charAt(i);

            if (ch == ';' || ch == '[' || ch == '/')

                throw new IllegalArgumentException("Invalid class name: " + name);

        }

        return name;

    }

    /**

     * Validates a member name

     *

     * @param name the name of the member

     * @return the name passed if valid

     * @throws IllegalArgumentException if the member name is invalid

     */

        requireNonNull(name);

        if (name.length() == 0)

            throw new IllegalArgumentException("zero-length member name");

        for (int i=0; i<name.length(); i++) {

            char ch = name.charAt(i);

            if (ch == '.' || ch == ';' || ch == '[' || ch == '/')

                throw new IllegalArgumentException("Invalid member name: " + name);

                if (!pointyNames.contains(name))

                    throw new IllegalArgumentException("Invalid member name: " + name);

            }

        }

        return name;

    }

    static void validateClassOrInterface(ClassDesc classDesc) {

        if (!classDesc.isClassOrInterface())

            throw new IllegalArgumentException("not a class or interface type: " + classDesc);

    }

    static int arrayDepth(String descriptorString) {

        int depth = 0;

        while (descriptorString.charAt(depth) == '[')

            depth++;

        return depth;

    }

    static String binaryToInternal(String name) {

        return name.replace('.', '/');

    }

    static String internalToBinary(String name) {

        return name.replace('/', '.');

    }

    static String dropLastChar(String s) {

        return s.substring(0, s.length() - 1);

    }

    static String dropFirstAndLastChar(String s) {

        return s.substring(1, s.length() - 1);

    }

    /**

     * Parses a method descriptor string, and return a list of field descriptor

     * strings, return type first, then parameter types

     *

     * @param descriptor the descriptor string

     * @return the list of types

     * @throws IllegalArgumentException if the descriptor string is not valid

     */

    static List<String> parseMethodDescriptor(String descriptor) {

        int cur = 0, end = descriptor.length();

        ArrayList<String> ptypes = new ArrayList<>();

        if (cur >= end || descriptor.charAt(cur) != '(')

            throw new IllegalArgumentException("Bad method descriptor: " + descriptor);

        ++cur;  // skip '('

        while (cur < end && descriptor.charAt(cur) != ')') {

                throw new IllegalArgumentException("Bad method descriptor: " + descriptor);

            ptypes.add(descriptor.substring(cur, cur + len));

            cur += len;

        }

        if (cur >= end)

            throw new IllegalArgumentException("Bad method descriptor: " + descriptor);

        ++cur;  // skip ')'

        if (rLen == 0 || cur + rLen != end)

            throw new IllegalArgumentException("Bad method descriptor: " + descriptor);

        ptypes.add(0, descriptor.substring(cur, cur + rLen));

        return ptypes;

    }

    /**

     * Validates that the characters at [start, end) within the provided string

     * describe a valid field type descriptor.

     * @param start the starting index into the string

     * @param end the ending index within the string

     * @return the length of the descriptor, or 0 if it is not a descriptor

     * @throws IllegalArgumentException if the descriptor string is not valid

     */

        }

    }

}