/*
 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
 * 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.
 *
 * 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 util;

import java.lang.reflect.AccessibleObject;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.function.BiFunction;
import java.util.function.Function;

import static util.MemberFactory.Kind.CONSTRUCTOR;
import static util.MemberFactory.Kind.FIELD;
import static util.MemberFactory.Kind.METHOD;

/**
 * Enumeration of:
 * <p>
 * {private, package, protected, public} x {instance, static} x {field, method}
 * <p>
 * and:
 * <p>
 * {private, package, protected, public} x {constructor},
 * <p>
 * with each element acting as a factory of AccessibleObject(s)
 * declared by given declaringClass(es).
 */
public enum MemberFactory implements Function<Class<?>, AccessibleObject> {
    // instance fields
    PRIVATE_INSTANCE_FIELD(FIELD, "privateInstance"),
    PACKAGE_INSTANCE_FIELD(FIELD, "packageInstance"),
    PROTECTED_INSTANCE_FIELD(FIELD, "protectedInstance"),
    PUBLIC_INSTANCE_FIELD(FIELD, "publicInstance"),
    // instance methods
    PRIVATE_INSTANCE_METHOD(METHOD, "privateInstance"),
    PACKAGE_INSTANCE_METHOD(METHOD, "packageInstance"),
    PROTECTED_INSTANCE_METHOD(METHOD, "protectedInstance"),
    PUBLIC_INSTANCE_METHOD(METHOD, "publicInstance"),
    // static fields
    PRIVATE_STATIC_FIELD(FIELD, "privateStatic"),
    PACKAGE_STATIC_FIELD(FIELD, "packageStatic"),
    PROTECTED_STATIC_FIELD(FIELD, "protectedStatic"),
    PUBLIC_STATIC_FIELD(FIELD, "publicStatic"),
    // static methods
    PRIVATE_STATIC_METHOD(METHOD, "privateStatic"),
    PACKAGE_STATIC_METHOD(METHOD, "packageStatic"),
    PROTECTED_STATIC_METHOD(METHOD, "protectedStatic"),
    PUBLIC_STATIC_METHOD(METHOD, "publicStatic"),
    // constructors
    PRIVATE_CONSTRUCTOR(CONSTRUCTOR, null, Void.class, Void.class, Void.class),
    PACKAGE_CONSTRUCTOR(CONSTRUCTOR, null, Void.class, Void.class),
    PROTECTED_CONSTRUCTOR(CONSTRUCTOR, null, Void.class),
    PUBLIC_CONSTRUCTOR(CONSTRUCTOR, null),;

    final Kind kind;
    final String name;
    final Class<?>[] parameterTypes;

    MemberFactory(Kind kind, String name, Class<?>... parameterTypes) {
        this.kind = kind;
        this.name = name;
        this.parameterTypes = parameterTypes;
    }

    @Override
    public AccessibleObject apply(Class<?> declaringClass) {
        return kind.apply(declaringClass, this);
    }

    public static EnumSet<MemberFactory> asSet(MemberFactory... members) {
        return members.length == 0 ? EnumSet.noneOf(MemberFactory.class)
                                   : EnumSet.copyOf(Arrays.asList(members));
    }

    /**
     * @param members the set of MemberFactory(s) to convert to set of
     *                MemberFactory.Group(s).
     * @return a set of groups that cover all elements of the members set if
     * such set of groups exists or null if it doesn't.
     */
    public static EnumSet<Group> membersToGroupsOrNull(EnumSet<MemberFactory> members) {
        EnumSet<MemberFactory> mSet = members.clone();
        EnumSet<Group> gSet = EnumSet.allOf(Group.class);
        Iterator<Group> gIter = gSet.iterator();
        while (gIter.hasNext()) {
            Group g = gIter.next();
            if (mSet.containsAll(g.members)) {
                mSet.removeAll(g.members);
            } else {
                gIter.remove();
            }
        }
        return mSet.isEmpty() ? gSet : null;
    }

    /**
     * @param groups the set of MemberFactory.Group(s) to convert to set of
     *               MemberFactory(s).
     * @return a set of members as a union of members of all groups.
     */
    public static EnumSet<MemberFactory> groupsToMembers(EnumSet<Group> groups) {
        EnumSet<MemberFactory> mSet = EnumSet.noneOf(MemberFactory.class);
        for (Group g : groups) {
            mSet.addAll(g.members);
        }
        return mSet;
    }

    enum Kind implements BiFunction<Class<?>, MemberFactory, AccessibleObject> {
        FIELD {
            @Override
            public AccessibleObject apply(Class<?> declaringClass, MemberFactory factory) {
                assert factory.kind == this;
                try {
                    return declaringClass.getDeclaredField(factory.name);
                } catch (NoSuchFieldException e) {
                    // a fault in test - fail fast
                    throw new RuntimeException(e.getMessage());
                }
            }
        },
        METHOD {
            @Override
            public AccessibleObject apply(Class<?> declaringClass, MemberFactory factory) {
                assert factory.kind == this;
                try {
                    return declaringClass.getDeclaredMethod(factory.name, factory.parameterTypes);
                } catch (NoSuchMethodException e) {
                    // a fault in test - fail fast
                    throw new RuntimeException(e.getMessage());
                }
            }
        },
        CONSTRUCTOR {
            @Override
            public AccessibleObject apply(Class<?> declaringClass, MemberFactory factory) {
                assert factory.kind == this;
                try {
                    return declaringClass.getDeclaredConstructor(factory.parameterTypes);
                } catch (NoSuchMethodException e) {
                    // a fault in test - fail fast
                    throw new RuntimeException(e.getMessage());
                }
            }
        }
    }

    /**
     * We define groups of MemberFactory(s) for members that commonly
     * exhibit same access restrictions in various cases in order to allow
     * specifying groups instead of individual members in the test cases,
     * making them less verbose.
     */
    public enum Group {
        // all members
        ALL(MemberFactory.values()),
        // all private members
        PRIVATE_MEMBERS(PRIVATE_INSTANCE_FIELD, PRIVATE_INSTANCE_METHOD,
                        PRIVATE_STATIC_FIELD, PRIVATE_STATIC_METHOD,
                        PRIVATE_CONSTRUCTOR),
        // all package members
        PACKAGE_MEMBERS(PACKAGE_INSTANCE_FIELD, PACKAGE_INSTANCE_METHOD,
                        PACKAGE_STATIC_FIELD, PACKAGE_STATIC_METHOD,
                        PACKAGE_CONSTRUCTOR),
        // all protected members
        PROTECTED_MEMBERS(PROTECTED_INSTANCE_FIELD, PROTECTED_INSTANCE_METHOD,
                          PROTECTED_STATIC_FIELD, PROTECTED_STATIC_METHOD,
                          PROTECTED_CONSTRUCTOR),
        // all public members
        PUBLIC_MEMBERS(PUBLIC_INSTANCE_FIELD, PUBLIC_INSTANCE_METHOD,
                       PUBLIC_STATIC_FIELD, PUBLIC_STATIC_METHOD,
                       PUBLIC_CONSTRUCTOR),
        // instance field and method pairs
        PRIVATE_INSTANCE_F_M(PRIVATE_INSTANCE_FIELD, PRIVATE_INSTANCE_METHOD),
        PACKAGE_INSTANCE_F_M(PACKAGE_INSTANCE_FIELD, PACKAGE_INSTANCE_METHOD),
        PROTECTED_INSTANCE_F_M(PROTECTED_INSTANCE_FIELD, PROTECTED_INSTANCE_METHOD),
        PUBLIC_INSTANCE_F_M(PUBLIC_INSTANCE_FIELD, PUBLIC_INSTANCE_METHOD),
        // static field and method pairs
        PRIVATE_STATIC_F_M(PRIVATE_STATIC_FIELD, PRIVATE_STATIC_METHOD),
        PACKAGE_STATIC_F_M(PACKAGE_STATIC_FIELD, PACKAGE_STATIC_METHOD),
        PROTECTED_STATIC_F_M(PROTECTED_STATIC_FIELD, PROTECTED_STATIC_METHOD),
        PUBLIC_STATIC_F_M(PUBLIC_STATIC_FIELD, PUBLIC_STATIC_METHOD),
        // constructor singles
        PRIVATE_C(PRIVATE_CONSTRUCTOR),
        PACKAGE_C(PACKAGE_CONSTRUCTOR),
        PROTECTED_C(PROTECTED_CONSTRUCTOR),
        PUBLIC_C(PUBLIC_CONSTRUCTOR);

        final EnumSet<MemberFactory> members;

        Group(MemberFactory... members) {
            this.members = EnumSet.copyOf(Arrays.asList(members));
        }

        public static EnumSet<Group> asSet(Group... groups) {
            return groups.length == 0 ? EnumSet.noneOf(Group.class)
                                      : EnumSet.copyOf(Arrays.asList(groups));
        }
    }
}