/*

 * Copyright (c) 2011, 2014, 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 org.graalvm.compiler.printer;

import static org.graalvm.compiler.graph.Edges.Type.Inputs;

import static org.graalvm.compiler.graph.Edges.Type.Successors;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.channels.WritableByteChannel;

import java.nio.charset.Charset;

import java.util.Arrays;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;

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

import org.graalvm.compiler.debug.Debug;

import org.graalvm.compiler.debug.GraalDebugConfig.Options;

import org.graalvm.compiler.graph.CachedGraph;

import org.graalvm.compiler.graph.Edges;

import org.graalvm.compiler.graph.Graph;

import org.graalvm.compiler.graph.InputEdges;

import org.graalvm.compiler.graph.Node;

import org.graalvm.compiler.graph.NodeClass;

import org.graalvm.compiler.graph.NodeList;

import org.graalvm.compiler.graph.NodeMap;

import org.graalvm.compiler.nodes.AbstractBeginNode;

import org.graalvm.compiler.nodes.AbstractEndNode;

import org.graalvm.compiler.nodes.AbstractMergeNode;

import org.graalvm.compiler.nodes.ConstantNode;

import org.graalvm.compiler.nodes.ControlSinkNode;

import org.graalvm.compiler.nodes.ControlSplitNode;

import org.graalvm.compiler.nodes.FixedNode;

import org.graalvm.compiler.nodes.PhiNode;

import org.graalvm.compiler.nodes.ProxyNode;

import org.graalvm.compiler.nodes.StructuredGraph;

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

import org.graalvm.compiler.nodes.VirtualState;

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

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

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

import jdk.vm.ci.meta.JavaType;

import jdk.vm.ci.meta.ResolvedJavaField;

import jdk.vm.ci.meta.ResolvedJavaMethod;

import jdk.vm.ci.meta.Signature;

public class BinaryGraphPrinter implements GraphPrinter {

    private static final int CONSTANT_POOL_MAX_SIZE = 8000;

    private static final int BEGIN_GROUP = 0x00;

    private static final int BEGIN_GRAPH = 0x01;

    private static final int CLOSE_GROUP = 0x02;

    private static final int POOL_NEW = 0x00;

    private static final int POOL_STRING = 0x01;

    private static final int POOL_ENUM = 0x02;

    private static final int POOL_CLASS = 0x03;

    private static final int POOL_METHOD = 0x04;

    private static final int POOL_NULL = 0x05;

    private static final int POOL_NODE_CLASS = 0x06;

    private static final int POOL_FIELD = 0x07;

    private static final int POOL_SIGNATURE = 0x08;

    private static final int PROPERTY_POOL = 0x00;

    private static final int PROPERTY_INT = 0x01;

    private static final int PROPERTY_LONG = 0x02;

    private static final int PROPERTY_DOUBLE = 0x03;

    private static final int PROPERTY_FLOAT = 0x04;

    private static final int PROPERTY_TRUE = 0x05;

    private static final int PROPERTY_FALSE = 0x06;

    private static final int PROPERTY_ARRAY = 0x07;

    private static final int PROPERTY_SUBGRAPH = 0x08;

    private static final int KLASS = 0x00;

    private static final int ENUM_KLASS = 0x01;

    static final int CURRENT_MAJOR_VERSION = 1;

    static final int CURRENT_MINOR_VERSION = 0;

    static final byte[] MAGIC_BYTES = {'B', 'I', 'G', 'V'};

    private void writeVersion() throws IOException {

        writeBytesRaw(MAGIC_BYTES);

        writeByte(CURRENT_MAJOR_VERSION);

        writeByte(CURRENT_MINOR_VERSION);

    }

    private static final class ConstantPool extends LinkedHashMap<Object, Character> {

        private final LinkedList<Character> availableIds;

        private char nextId;

        private static final long serialVersionUID = -2676889957907285681L;

        ConstantPool() {

            super(50, 0.65f);

            availableIds = new LinkedList<>();

        }

        @Override

        protected boolean removeEldestEntry(java.util.Map.Entry<Object, Character> eldest) {

            if (size() > CONSTANT_POOL_MAX_SIZE) {

                availableIds.addFirst(eldest.getValue());

                return true;

            }

            return false;

        }

        private Character nextAvailableId() {

            if (!availableIds.isEmpty()) {

                return availableIds.removeFirst();

            }

            return nextId++;

        }

        public char add(Object obj) {

            Character id = nextAvailableId();

            put(obj, id);

            return id;

        }

    }

    private final ConstantPool constantPool;

    private final ByteBuffer buffer;

    private final WritableByteChannel channel;

    private SnippetReflectionProvider snippetReflection;

    private static final Charset utf8 = Charset.forName("UTF-8");

    public BinaryGraphPrinter(WritableByteChannel channel) throws IOException {

        constantPool = new ConstantPool();

        buffer = ByteBuffer.allocateDirect(256 * 1024);

        this.channel = channel;

        writeVersion();

    }

    @Override

    public void setSnippetReflectionProvider(SnippetReflectionProvider snippetReflection) {

        this.snippetReflection = snippetReflection;

    }

    @Override

    public SnippetReflectionProvider getSnippetReflectionProvider() {

        return snippetReflection;

    }

    @Override

        writeByte(BEGIN_GRAPH);

        writeGraph(graph, properties);

        flush();

    }

    private void writeGraph(Graph graph, Map<Object, Object> properties) throws IOException {

        ScheduleResult scheduleResult = null;

        if (graph instanceof StructuredGraph) {

            StructuredGraph structuredGraph = (StructuredGraph) graph;

            scheduleResult = structuredGraph.getLastSchedule();

            if (scheduleResult == null) {

                // Also provide a schedule when an error occurs

                if (Options.PrintGraphWithSchedule.getValue(graph.getOptions()) || Debug.contextLookup(Throwable.class) != null) {

                    try {

                        SchedulePhase schedule = new SchedulePhase(graph.getOptions());

                        schedule.apply(structuredGraph);

                        scheduleResult = structuredGraph.getLastSchedule();

                    } catch (Throwable t) {

                    }

                }

            }

        }

        ControlFlowGraph cfg = scheduleResult == null ? Debug.contextLookup(ControlFlowGraph.class) : scheduleResult.getCFG();

        BlockMap<List<Node>> blockToNodes = scheduleResult == null ? null : scheduleResult.getBlockToNodesMap();

        NodeMap<Block> nodeToBlocks = scheduleResult == null ? null : scheduleResult.getNodeToBlockMap();

        List<Block> blocks = cfg == null ? null : Arrays.asList(cfg.getBlocks());

        writeProperties(properties);

        writeNodes(graph, nodeToBlocks, cfg);

        writeBlocks(blocks, blockToNodes);

    }

    private void flush() throws IOException {

        buffer.flip();

        /*

         * Try not to let interrupted threads aborting the write. There's still a race here but an

         * interrupt that's been pending for a long time shouldn't stop this writing.

         */

        boolean interrupted = Thread.interrupted();

        try {

            channel.write(buffer);

        } finally {

            if (interrupted) {

                Thread.currentThread().interrupt();

            }

        }

        buffer.compact();

    }

    private void ensureAvailable(int i) throws IOException {

        assert buffer.capacity() >= i : "Can not make " + i + " bytes available, buffer is too small";

        while (buffer.remaining() < i) {

            flush();

        }

    }

    private void writeByte(int b) throws IOException {

        ensureAvailable(1);

        buffer.put((byte) b);

    }

    private void writeInt(int b) throws IOException {

        ensureAvailable(4);

        buffer.putInt(b);

    }

    private void writeLong(long b) throws IOException {

        ensureAvailable(8);

        buffer.putLong(b);

    }

    private void writeDouble(double b) throws IOException {

        ensureAvailable(8);

        buffer.putDouble(b);

    }

    private void writeFloat(float b) throws IOException {

        ensureAvailable(4);

        buffer.putFloat(b);

    }

    private void writeShort(char b) throws IOException {

        ensureAvailable(2);

        buffer.putChar(b);

    }

    private void writeString(String str) throws IOException {

        byte[] bytes = str.getBytes(utf8);

        writeBytes(bytes);

    }

    private void writeBytes(byte[] b) throws IOException {

        if (b == null) {

            writeInt(-1);

        } else {

            writeInt(b.length);

            writeBytesRaw(b);

        }

    }

    private void writeBytesRaw(byte[] b) throws IOException {

        int bytesWritten = 0;

        while (bytesWritten < b.length) {

            int toWrite = Math.min(b.length - bytesWritten, buffer.capacity());

            ensureAvailable(toWrite);

            buffer.put(b, bytesWritten, toWrite);

            bytesWritten += toWrite;

        }

    }

    private void writeInts(int[] b) throws IOException {

        if (b == null) {

            writeInt(-1);

        } else {

            writeInt(b.length);

            int sizeInBytes = b.length * 4;

            ensureAvailable(sizeInBytes);

            buffer.asIntBuffer().put(b);

            buffer.position(buffer.position() + sizeInBytes);

        }

    }

    private void writeDoubles(double[] b) throws IOException {

        if (b == null) {

            writeInt(-1);

        } else {

            writeInt(b.length);

            int sizeInBytes = b.length * 8;

            ensureAvailable(sizeInBytes);

            buffer.asDoubleBuffer().put(b);

            buffer.position(buffer.position() + sizeInBytes);

        }

    }

    private void writePoolObject(Object object) throws IOException {

        if (object == null) {

            writeByte(POOL_NULL);

            return;

        }

        Character id = constantPool.get(object);

        if (id == null) {

            addPoolEntry(object);

        } else {

            if (object instanceof Enum<?>) {

                writeByte(POOL_ENUM);

            } else if (object instanceof Class<?> || object instanceof JavaType) {

                writeByte(POOL_CLASS);

            } else if (object instanceof NodeClass) {

                writeByte(POOL_NODE_CLASS);

                writeByte(POOL_METHOD);

            } else if (object instanceof ResolvedJavaField) {

                writeByte(POOL_FIELD);

            } else if (object instanceof Signature) {

                writeByte(POOL_SIGNATURE);

            } else {

                writeByte(POOL_STRING);

            }

            writeShort(id.charValue());

        }

    }

    private static String getClassName(Class<?> klass) {

        if (!klass.isArray()) {

            return klass.getName();

        }

        return getClassName(klass.getComponentType()) + "[]";

    }

    private void addPoolEntry(Object object) throws IOException {

        char index = constantPool.add(object);

        writeByte(POOL_NEW);

        writeShort(index);

        if (object instanceof Class<?>) {

            Class<?> klass = (Class<?>) object;

            writeByte(POOL_CLASS);

            writeString(getClassName(klass));

            if (klass.isEnum()) {

                writeByte(ENUM_KLASS);

                Object[] enumConstants = klass.getEnumConstants();

                writeInt(enumConstants.length);

                for (Object o : enumConstants) {

                    writePoolObject(((Enum<?>) o).name());

                }

            } else {

                writeByte(KLASS);

            }

        } else if (object instanceof Enum<?>) {

            writeByte(POOL_ENUM);

            writePoolObject(object.getClass());

            writeInt(((Enum<?>) object).ordinal());

        } else if (object instanceof JavaType) {

            JavaType type = (JavaType) object;

            writeByte(POOL_CLASS);

            writeString(type.toJavaName());

            writeByte(KLASS);

        } else if (object instanceof NodeClass) {

            NodeClass<?> nodeClass = (NodeClass<?>) object;

            writeByte(POOL_NODE_CLASS);

            writeString(nodeClass.getNameTemplate());

            writeEdgesInfo(nodeClass, Inputs);

            writeEdgesInfo(nodeClass, Successors);

            writeByte(POOL_METHOD);

            writePoolObject(method.getDeclaringClass());

            writePoolObject(method.getName());

            writePoolObject(method.getSignature());

            writeInt(method.getModifiers());

            writeBytes(method.getCode());

        } else if (object instanceof ResolvedJavaField) {

            writeByte(POOL_FIELD);

            ResolvedJavaField field = ((ResolvedJavaField) object);

            writePoolObject(field.getDeclaringClass());

            writePoolObject(field.getName());

            writePoolObject(field.getType().getName());

            writeInt(field.getModifiers());

        } else if (object instanceof Signature) {

            writeByte(POOL_SIGNATURE);

            Signature signature = ((Signature) object);

            int args = signature.getParameterCount(false);

            writeShort((char) args);

            for (int i = 0; i < args; i++) {

                writePoolObject(signature.getParameterType(i, null).getName());

            }

            writePoolObject(signature.getReturnType(null).getName());

        } else {

            writeByte(POOL_STRING);

            writeString(object.toString());

        }

    }

    private void writeEdgesInfo(NodeClass<?> nodeClass, Edges.Type type) throws IOException {

        Edges edges = nodeClass.getEdges(type);

        writeShort((char) edges.getCount());

        for (int i = 0; i < edges.getCount(); i++) {

            writeByte(i < edges.getDirectCount() ? 0 : 1);

            writePoolObject(edges.getName(i));

            if (type == Inputs) {

                writePoolObject(((InputEdges) edges).getInputType(i));

            }

        }

    }

    private void writePropertyObject(Object obj) throws IOException {

        if (obj instanceof Integer) {

            writeByte(PROPERTY_INT);

            writeInt(((Integer) obj).intValue());

        } else if (obj instanceof Long) {

            writeByte(PROPERTY_LONG);

            writeLong(((Long) obj).longValue());

        } else if (obj instanceof Double) {

            writeByte(PROPERTY_DOUBLE);

            writeDouble(((Double) obj).doubleValue());

        } else if (obj instanceof Float) {

            writeByte(PROPERTY_FLOAT);

            writeFloat(((Float) obj).floatValue());

        } else if (obj instanceof Boolean) {

            if (((Boolean) obj).booleanValue()) {

                writeByte(PROPERTY_TRUE);

            } else {

                writeByte(PROPERTY_FALSE);

            }

        } else if (obj instanceof Graph) {

            writeByte(PROPERTY_SUBGRAPH);

            writeGraph((Graph) obj, null);

        } else if (obj instanceof CachedGraph) {

            writeByte(PROPERTY_SUBGRAPH);

            writeGraph(((CachedGraph<?>) obj).getReadonlyCopy(), null);

        } else if (obj != null && obj.getClass().isArray()) {

            Class<?> componentType = obj.getClass().getComponentType();

            if (componentType.isPrimitive()) {

                if (componentType == Double.TYPE) {

                    writeByte(PROPERTY_ARRAY);

                    writeByte(PROPERTY_DOUBLE);

                    writeDoubles((double[]) obj);

                } else if (componentType == Integer.TYPE) {

                    writeByte(PROPERTY_ARRAY);

                    writeByte(PROPERTY_INT);

                    writeInts((int[]) obj);

                } else {

                    writeByte(PROPERTY_POOL);

                    writePoolObject(obj);

                }

            } else {

                writeByte(PROPERTY_ARRAY);

                writeByte(PROPERTY_POOL);

                Object[] array = (Object[]) obj;

                writeInt(array.length);

                for (Object o : array) {

                    writePoolObject(o);

                }

            }

        } else {

            writeByte(PROPERTY_POOL);

            writePoolObject(obj);

        }

    }

    @SuppressWarnings("deprecation")

    private static int getNodeId(Node node) {

        return node.getId();

    }

    private Object getBlockForNode(Node node, NodeMap<Block> nodeToBlocks) {

        if (nodeToBlocks.isNew(node)) {

            return "NEW (not in schedule)";

        } else {

            Block block = nodeToBlocks.get(node);

            if (block != null) {

                return block.getId();

            } else if (node instanceof PhiNode) {

                return getBlockForNode(((PhiNode) node).merge(), nodeToBlocks);

            }

        }

        return null;

    }

    private void writeNodes(Graph graph, NodeMap<Block> nodeToBlocks, ControlFlowGraph cfg) throws IOException {

        Map<Object, Object> props = new HashMap<>();

        writeInt(graph.getNodeCount());

        for (Node node : graph.getNodes()) {