import static org.graalvm.compiler.core.common.cfg.AbstractControlFlowGraph.strictlyDominates;

import java.util.List;

import org.graalvm.compiler.core.common.cfg.BlockMap;

import org.graalvm.compiler.graph.NodeMap;

import org.graalvm.compiler.nodes.FixedWithNextNode;

import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;

import org.graalvm.compiler.nodes.cfg.Block;

import org.graalvm.compiler.phases.schedule.SchedulePhase;

import org.graalvm.compiler.phases.schedule.SchedulePhase.SchedulingStrategy;

import org.graalvm.util.EconomicMap;

    private final boolean verifyFingerprints;

    private static boolean anyUsagesNeedReplacement(ConstantNode node) {

        return node.usages().filter(n -> !isReplacementNode(n)).isNotEmpty();

    }

    private static boolean anyUsagesNeedReplacement(LoadMethodCountersNode node) {

        return node.usages().filter(n -> !(n instanceof ResolveMethodAndLoadCountersNode)).isNotEmpty();

    }

    /**

     * Replace {@link ConstantNode} containing a {@link HotSpotResolvedJavaType} with indirection.

     *

     * @param graph

     * @param node {@link ConstantNode} containing a {@link HotSpotResolvedJavaType} that needs

     *            resolution.

     */

    private void handleHotSpotMetaspaceConstant(StructuredGraph graph, ConstantNode node) {

            if (verifyFingerprints && checkForBadFingerprint(type)) {

            replaceWithInitialization(graph, node);

            if (anyUsagesNeedReplacement(node)) {

                replaceWithResolution(graph, node);

    /**

     * Find the lowest dominating {@link FixedWithNextNode} before given node.

     *

     * @param graph

     * @param node

     * @return the last {@link FixedWithNextNode} that is scheduled before node.

     */

    private static FixedWithNextNode findFixedWithNextBefore(StructuredGraph graph, Node node) {

        ScheduleResult schedule = graph.getLastSchedule();

        NodeMap<Block> nodeToBlock = schedule.getNodeToBlockMap();

        BlockMap<List<Node>> blockToNodes = schedule.getBlockToNodesMap();

        Block block = nodeToBlock.get(node);

        FixedWithNextNode result = null;

        for (Node n : blockToNodes.get(block)) {

            if (n instanceof FixedWithNextNode) {

                result = (FixedWithNextNode) n;

            }

            if (n.equals(node)) {

                break;

            }

        }

        assert result != null;

        return result;

    }

    /**

     * Try to find dominating {@link InitializeKlassNode} that can be reused.

     *

     * @param graph

     * @param node {@link ConstantNode} containing a {@link HotSpotResolvedJavaType} that needs

     *            resolution.

     */

    private static void replaceWithInitialization(StructuredGraph graph, ConstantNode node) {

        ScheduleResult schedule = graph.getLastSchedule();

        NodeMap<Block> nodeToBlock = schedule.getNodeToBlockMap();

        BlockMap<List<Node>> blockToNodes = schedule.getBlockToNodesMap();

        EconomicMap<Block, Node> blockToInit = EconomicMap.create();

        for (Node n : node.usages().filter(InitializeKlassNode.class)) {

            blockToInit.put(nodeToBlock.get(n), n);

        }

        for (Node use : node.usages().filter(n -> !isReplacementNode(n)).snapshot()) {

            boolean replaced = false;

            Block b = nodeToBlock.get(use);

            InitializeKlassNode i = (InitializeKlassNode) blockToInit.get(b);

            if (i != null) {

                // There is an initialization in the same block as the use, look if the use is

                // scheduled after it.

                for (Node n : blockToNodes.get(b)) {

                    if (n.equals(use)) {

                        // Usage is before initialization, can't use it

                        break;

                    }

                    if (n.equals(i)) {

                        use.replaceFirstInput(node, i);

                        replaced = true;

                        break;

                    }

                }

            }

            if (!replaced) {

                // Look for dominating blocks that have initializations

                for (Block d : blockToInit.getKeys()) {

                    if (strictlyDominates(d, b)) {

                        use.replaceFirstInput(node, blockToInit.get(d));

                        break;

                    }

                }

            }

        }

    }

    /**

     * Replace the uses of a constant with either {@link LoadConstantIndirectlyNode} or

     * {@link ResolveConstantNode}.

     *

     * @param graph

     * @param node {@link ConstantNode} containing a {@link HotSpotResolvedJavaType} that needs

     *            resolution.

     */

    private static void replaceWithResolution(StructuredGraph graph, ConstantNode node) {

        HotSpotMetaspaceConstant metaspaceConstant = (HotSpotMetaspaceConstant) node.asConstant();

        HotSpotResolvedJavaType type = (HotSpotResolvedJavaType) metaspaceConstant.asResolvedJavaType();

        ResolvedJavaType topMethodHolder = graph.method().getDeclaringClass();

        ValueNode replacement;

        if (type.isArray() && type.getComponentType().isPrimitive()) {

            // Special case for primitive arrays. The AOT runtime pre-resolves them, so we may

            // omit the resolution call.

            replacement = graph.addOrUnique(new LoadConstantIndirectlyNode(node));

        } else if (type.equals(topMethodHolder) || (type.isAssignableFrom(topMethodHolder) && !type.isInterface())) {

            // If it's a supertype of or the same class that declares the top method, we are

            // guaranteed to have it resolved already. If it's an interface, we just test for

            // equality.

            replacement = graph.addOrUnique(new LoadConstantIndirectlyNode(node));

        } else {

            FixedWithNextNode fixedReplacement;

            if (builtIns.contains(type.mirror())) {

                // Special case of klass constants that come from {@link BoxingSnippets}.

                fixedReplacement = graph.add(new ResolveConstantNode(node, HotSpotConstantLoadAction.INITIALIZE));

            } else {

                fixedReplacement = graph.add(new ResolveConstantNode(node));

            }

            graph.addAfterFixed(findFixedWithNextBefore(graph, node), fixedReplacement);

            replacement = fixedReplacement;

        }

        node.replaceAtUsages(replacement, n -> !isReplacementNode(n));

    }

    /**

     * Replace an object constant with an indirect load {@link ResolveConstantNode}. Currently we

     * support only strings.

     *

     * @param graph

     * @param node {@link ConstantNode} containing a {@link HotSpotObjectConstant} that needs

     *            resolution.

     */

            FixedWithNextNode replacement = graph.add(new ResolveConstantNode(node));

            graph.addAfterFixed(findFixedWithNextBefore(graph, node), replacement);

    /**

     * Replace {@link LoadMethodCountersNode} with indirect load

     * {@link ResolveMethodAndLoadCountersNode}, expose a klass constant of the holder.

     *

     * @param graph

     * @param node

     * @param context

     */

        FixedWithNextNode replacement = graph.add(new ResolveMethodAndLoadCountersNode(node.getMethod(), klassHint));

        graph.addAfterFixed(findFixedWithNextBefore(graph, node), replacement);

    /**

     * Replace {@link LoadMethodCountersNode} with {@link ResolveMethodAndLoadCountersNode}, expose

     * klass constants.

     *

     * @param graph

     * @param context

     */

    private static void replaceLoadMethodCounters(StructuredGraph graph, PhaseContext context) {

        new SchedulePhase(SchedulingStrategy.LATEST_OUT_OF_LOOPS, true).apply(graph, false);

        for (LoadMethodCountersNode node : getLoadMethodCountersNodes(graph)) {

            if (anyUsagesNeedReplacement(node)) {

                handleLoadMethodCounters(graph, node, context);

            }

        }

    }

    /**

     * Replace object and klass constants with resolution nodes or reuse preceding initializations.

     *

     * @param graph

     */

    private void replaceKlassesAndObjects(StructuredGraph graph) {

        new SchedulePhase(SchedulingStrategy.LATEST_OUT_OF_LOOPS, true).apply(graph, false);

        for (ConstantNode node : getConstantNodes(graph)) {

            Constant constant = node.asConstant();

            if (constant instanceof HotSpotMetaspaceConstant && anyUsagesNeedReplacement(node)) {

                handleHotSpotMetaspaceConstant(graph, node);

            } else if (constant instanceof HotSpotObjectConstant && anyUsagesNeedReplacement(node)) {

                handleHotSpotObjectConstant(graph, node);

            }

        }

    }

        replaceLoadMethodCounters(graph, context);

        replaceKlassesAndObjects(graph);

    public ReplaceConstantNodesPhase() {

        this(true);

    }

    public ReplaceConstantNodesPhase(boolean verifyFingerprints) {

        this.verifyFingerprints = verifyFingerprints;

    }