/*

 * 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 gc.g1.humongousObjects.objectGraphTest;

import gc.testlibrary.Helpers;

import jdk.test.lib.Asserts;

import sun.hotspot.WhiteBox;

import java.util.Arrays;

import java.util.List;

import java.util.function.Consumer;

/**

 * Provides methods to initiate GC of requested type and

 * checks for states of humongous and non-humongous soft/weak externally

 * referenced objects after GCs

 */

public enum GC {

    CMC {

        @Override

        public Runnable get() {

            return () -> {

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.g1StartConcMarkCycle();

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

            };

        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {

            return getCheckerImpl(false, false, true, false);

        }

        @Override

        public List<String> shouldContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_CMC);

        }

        @Override

        public List<String> shouldNotContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_YOUNG_GC, GCTokens.WB_INITIATED_MIXED_GC,

                    GCTokens.FULL_GC, GCTokens.YOUNG_GC);

        }

    },

    CMC_NO_SURV_ROOTS {

        @Override

        public Runnable get() {

            return () -> {

                WHITE_BOX.youngGC();

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.youngGC();

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.g1StartConcMarkCycle();

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

            };

        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {

            return getCheckerImpl(true, false, true, false);

        }

        @Override

        public List<String> shouldContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_CMC);

        }

        @Override

        public List<String> shouldNotContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_MIXED_GC,

                    GCTokens.FULL_GC, GCTokens.YOUNG_GC);

        }

    },

    YOUNG_GC {

        @Override

        public Runnable get() {

            return WHITE_BOX::youngGC;

        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {

            return getCheckerImpl(false, false, true, false);

        }

        @Override

        public List<String> shouldContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_YOUNG_GC);

        }

        @Override

        public List<String> shouldNotContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_MIXED_GC, GCTokens.FULL_GC, GCTokens.WB_INITIATED_CMC,

                    GCTokens.CMC, GCTokens.YOUNG_GC);

        }

    },

    FULL_GC {

        @Override

        public Runnable get() {

            return System::gc;

        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {

            return getCheckerImpl(true, false, true, false);

        }

        @Override

        public List<String> shouldContain() {

            return Arrays.asList(GCTokens.FULL_GC);

        }

        @Override

        public List<String> shouldNotContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_YOUNG_GC, GCTokens.WB_INITIATED_MIXED_GC,

                    GCTokens.WB_INITIATED_CMC, GCTokens.CMC, GCTokens.YOUNG_GC);

        }

    },

    MIXED_GC {

        @Override

        public Runnable get() {

            return () -> {

                WHITE_BOX.youngGC();

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.youngGC();

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.g1StartConcMarkCycle();

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.youngGC();

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                // Provoking Mixed GC

                WHITE_BOX.youngGC();// second evacuation pause will be mixed

                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

            };

        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {

            return getCheckerImpl(true, false, true, false);

        }

        @Override

        public List<String> shouldContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_CMC);

        }

        @Override

        public List<String> shouldNotContain() {

            return Arrays.asList(GCTokens.YOUNG_GC);

        }

    },

    FULL_GC_MEMORY_PRESSURE {

        @Override

        public Runnable get() {

            return WHITE_BOX::fullGC;

        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {

            return getCheckerImpl(true, true, true, true);

        }

        @Override

        public List<String> shouldContain() {

            return Arrays.asList(GCTokens.FULL_GC_MEMORY_PRESSURE);

        }

        @Override

        public List<String> shouldNotContain() {

            return Arrays.asList(GCTokens.WB_INITIATED_YOUNG_GC, GCTokens.WB_INITIATED_MIXED_GC,

                    GCTokens.WB_INITIATED_CMC, GCTokens.CMC, GCTokens.YOUNG_GC, GCTokens.FULL_GC);

        }

    };

    protected String getErrorMessage(ReferenceInfo<Object[]> ref, boolean expectedNull, String gcType) {

        return String.format("Externally effectively %s referenced %shumongous object was%s deleted after %s",

                (ref.softlyReachable ? "soft" : "weak"), (ref.effectiveHumongous ? "" : "non-"),

                (expectedNull ? " not" : ""), gcType);

    }

    protected Consumer<ReferenceInfo<Object[]>> getCaseCheck(boolean expectedNull) {

        return expectedNull

                ? r -> Asserts.assertNull(r.reference.get(), getErrorMessage(r, true, name()))

                : r -> Asserts.assertNotNull(r.reference.get(), getErrorMessage(r, false, name()));

    }

    protected Consumer<ReferenceInfo<Object[]>> getCheckerImpl(boolean weakH, boolean softH,

                                                               boolean weakS, boolean softS) {

        return new Checker(getCaseCheck(weakH), getCaseCheck(softH), getCaseCheck(weakS), getCaseCheck(softS));

    }

    protected String getGcLogName(String prefix) {

        return prefix + "_" + name() + ".gc.log";

    }

    private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();

    /**

     * @return method to initiate GC

     */

    public abstract Runnable get();

    /**

     * @return checker for objects' states after GC

     */

    public abstract Consumer<ReferenceInfo<Object[]>> getChecker();

    /**

     * @return list of tokens that should be contained in gc log after gc of specified type

     */

    public abstract List<String> shouldContain();

    /**

     * @return list of tokens that should not be contained in gc log after gc of specified type

     */

    public abstract List<String> shouldNotContain();

    /**

     * Checks object' state after gc

     * Contains 4 Consumers which are called depending on humongous/non-humongous and

     * external weak/soft referenced objects

     */

    private static class Checker implements Consumer<ReferenceInfo<Object[]>> {

        // 4 consumers with checks for (humongous /simple objects)*(weak/soft referenced)

        final Consumer<ReferenceInfo<Object[]>> weakHumongousCheck;

        final Consumer<ReferenceInfo<Object[]>> softHumongousCheck;

        final Consumer<ReferenceInfo<Object[]>> weakSimpleCheck;

        final Consumer<ReferenceInfo<Object[]>> softSimpleCheck;

        public Checker(Consumer<ReferenceInfo<Object[]>> weakHumongousCheck,

                       Consumer<ReferenceInfo<Object[]>> softHumongousCheck,

                       Consumer<ReferenceInfo<Object[]>> weakSimpleCheck,

                       Consumer<ReferenceInfo<Object[]>> softSimpleCheck) {

            this.weakHumongousCheck = weakHumongousCheck;

            this.softHumongousCheck = softHumongousCheck;

            this.weakSimpleCheck = weakSimpleCheck;

            this.softSimpleCheck = softSimpleCheck;

        }

        public void accept(ReferenceInfo<Object[]> ref) {

            System.out.println("reference.get() returned " + ref.reference.get());

            if (ref.effectiveHumongous && ref.softlyReachable) {

                System.out.println("soft and humongous");

                softHumongousCheck.accept(ref);

            }

            if (ref.effectiveHumongous && !ref.softlyReachable) {

                System.out.println("weak and humongous");

                weakHumongousCheck.accept(ref);

            }

            if (!ref.effectiveHumongous && ref.softlyReachable) {

                System.out.println("soft and non-humongous");

                softSimpleCheck.accept(ref);

            }

            if (!ref.effectiveHumongous && !ref.softlyReachable) {

                System.out.println("weak and non-humongous");

                weakSimpleCheck.accept(ref);

            }

        }

    }

}