/*

 * Copyright (c) 2011, 2019, 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.graphio;

import java.io.Closeable;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.channels.WritableByteChannel;

import java.nio.charset.Charset;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.Map;

import java.util.Objects;

abstract class GraphProtocol<Graph, Node, NodeClass, Edges, Block, ResolvedJavaMethod, ResolvedJavaField, Signature, NodeSourcePosition, Location> implements Closeable {

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

    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 POOL_NODE_SOURCE_POSITION = 0x09;

    private static final int POOL_NODE = 0x0a;

    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;

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

    private static final int MAJOR_VERSION = 6;

    private static final int MINOR_VERSION = 1;

    private final ConstantPool constantPool;

    private final ByteBuffer buffer;

    private final WritableByteChannel channel;

    private final boolean embedded;

    final int versionMajor;

    final int versionMinor;

    private boolean printing;

    /**

     * See {@code org.graalvm.compiler.serviceprovider.BufferUtil}.

     */

    private static Buffer asBaseBuffer(Buffer obj) {

        return obj;

    }

    GraphProtocol(WritableByteChannel channel, int major, int minor, boolean embedded) throws IOException {

        if (major > MAJOR_VERSION || (major == MAJOR_VERSION && minor > MINOR_VERSION)) {

            throw new IllegalArgumentException("Unrecognized version " + major + "." + minor);

        }

        this.versionMajor = major;

        this.versionMinor = minor;

        this.constantPool = new ConstantPool();

        this.buffer = ByteBuffer.allocateDirect(256 * 1024);

        this.channel = channel;

        this.embedded = embedded;

        if (!embedded) {

            writeVersion();

            flushEmbedded();

        }

    }

    GraphProtocol(GraphProtocol<?, ?, ?, ?, ?, ?, ?, ?, ?, ?> parent) {

        this.versionMajor = parent.versionMajor;

        this.versionMinor = parent.versionMinor;

        this.constantPool = parent.constantPool;

        this.buffer = parent.buffer;

        this.channel = parent.channel;

        this.embedded = parent.embedded;

    }

    @SuppressWarnings("all")

    public final void print(Graph graph, Map<? extends Object, ? extends Object> properties, int id, String format, Object... args) throws IOException {

        printing = true;

        try {

            writeByte(BEGIN_GRAPH);

            if (versionMajor >= 3) {

                writeInt(id);

                writeString(format);

                writeInt(args.length);

                for (Object a : args) {

                    writePropertyObject(graph, a);

                }

            } else {

                writePoolObject(formatTitle(graph, id, format, args));

            }

            writeGraph(graph, properties);

            flushEmbedded();

            flush();

        } finally {

            printing = false;

        }

    }

    public final void beginGroup(Graph noGraph, String name, String shortName, ResolvedJavaMethod method, int bci, Map<? extends Object, ? extends Object> properties) throws IOException {

        printing = true;

        try {

            writeByte(BEGIN_GROUP);

            writePoolObject(name);

            writePoolObject(shortName);

            writePoolObject(method);

            writeInt(bci);

            writeProperties(noGraph, properties);

            flushEmbedded();

        } finally {

            printing = false;

        }

    }

    public final void endGroup() throws IOException {

        printing = true;

        try {

            writeByte(CLOSE_GROUP);

            flushEmbedded();

        } finally {

            printing = false;

        }

    }

    final int write(ByteBuffer src) throws IOException {

        if (printing) {

            throw new IllegalStateException("Trying to write during graph print.");

        }

        constantPool.reset();

        return writeBytesRaw(src);

    }

    final boolean isOpen() {

        return channel.isOpen();

    }

    @Override

    public final void close() {

        try {

            flush();

            channel.close();

        } catch (IOException ex) {

            throw new Error(ex);

        }

    }

    protected abstract Graph findGraph(Graph current, Object obj);

    protected abstract ResolvedJavaMethod findMethod(Object obj);

    /**

     * Attempts to recognize the provided object as a node. Used to encode it with

     * {@link #POOL_NODE} pool type.

     *

     * @param obj any object

     * @return <code>null</code> if it is not a node object, non-null otherwise

     */

    protected abstract Node findNode(Object obj);

    /**

     * Determines whether the provided object is node class or not.

     *

     * @param obj object to check

     * @return {@code null} if {@code obj} does not represent a NodeClass otherwise the NodeClass

     *         represented by {@code obj}

     */

    protected abstract NodeClass findNodeClass(Object obj);

    /**

     * Returns the NodeClass for a given Node {@code obj}.

     *

     * @param obj instance of node

     * @return non-{@code null} instance of the node's class object

     */

    protected abstract NodeClass findClassForNode(Node obj);

    /**

     * Find a Java class. The returned object must be acceptable by

     * {@link #findJavaTypeName(java.lang.Object)} and return valid name for the class.

     *

     * @param clazz node class object

     * @return object representing the class, for example {@link Class}

     */

    protected abstract Object findJavaClass(NodeClass clazz);

    protected abstract Object findEnumClass(Object enumValue);

    protected abstract String findNameTemplate(NodeClass clazz);

    protected abstract Edges findClassEdges(NodeClass nodeClass, boolean dumpInputs);

    protected abstract int findNodeId(Node n);

    protected abstract void findExtraNodes(Node node, Collection<? super Node> extraNodes);

    protected abstract boolean hasPredecessor(Node node);

    protected abstract int findNodesCount(Graph info);

    protected abstract Iterable<? extends Node> findNodes(Graph info);

    protected abstract void findNodeProperties(Node node, Map<String, Object> props, Graph info);

    protected abstract Collection<? extends Node> findBlockNodes(Graph info, Block block);

    protected abstract int findBlockId(Block sux);

    protected abstract Collection<? extends Block> findBlocks(Graph graph);

    protected abstract Collection<? extends Block> findBlockSuccessors(Block block);

    protected abstract String formatTitle(Graph graph, int id, String format, Object... args);

    protected abstract int findSize(Edges edges);

    protected abstract boolean isDirect(Edges edges, int i);

    protected abstract String findName(Edges edges, int i);

    protected abstract Object findType(Edges edges, int i);

    protected abstract Collection<? extends Node> findNodes(Graph graph, Node node, Edges edges, int i);

    protected abstract int findEnumOrdinal(Object obj);

    protected abstract String[] findEnumTypeValues(Object clazz);

    protected abstract String findJavaTypeName(Object obj);

    protected abstract byte[] findMethodCode(ResolvedJavaMethod method);

    protected abstract int findMethodModifiers(ResolvedJavaMethod method);

    protected abstract Signature findMethodSignature(ResolvedJavaMethod method);

    protected abstract String findMethodName(ResolvedJavaMethod method);

    protected abstract Object findMethodDeclaringClass(ResolvedJavaMethod method);

    protected abstract int findFieldModifiers(ResolvedJavaField field);

    protected abstract String findFieldTypeName(ResolvedJavaField field);

    protected abstract String findFieldName(ResolvedJavaField field);

    protected abstract Object findFieldDeclaringClass(ResolvedJavaField field);

    protected abstract ResolvedJavaField findJavaField(Object object);

    protected abstract Signature findSignature(Object object);

    protected abstract int findSignatureParameterCount(Signature signature);

    protected abstract String findSignatureParameterTypeName(Signature signature, int index);

    protected abstract String findSignatureReturnTypeName(Signature signature);

    protected abstract NodeSourcePosition findNodeSourcePosition(Object object);

    protected abstract ResolvedJavaMethod findNodeSourcePositionMethod(NodeSourcePosition pos);

    protected abstract NodeSourcePosition findNodeSourcePositionCaller(NodeSourcePosition pos);

    protected abstract int findNodeSourcePositionBCI(NodeSourcePosition pos);

    protected abstract Iterable<Location> findLocation(ResolvedJavaMethod method, int bci, NodeSourcePosition pos);

    protected abstract String findLocationFile(Location loc) throws IOException;

    protected abstract int findLocationLine(Location loc);

    protected abstract URI findLocationURI(Location loc) throws URISyntaxException;

    protected abstract String findLocationLanguage(Location loc);

    protected abstract int findLocationStart(Location loc);

    protected abstract int findLocationEnd(Location loc);

    private void writeVersion() throws IOException {

        writeBytesRaw(MAGIC_BYTES);

        writeByte(versionMajor);

        writeByte(versionMinor);

    }

    private void flushEmbedded() throws IOException {

        if (embedded) {

            flush();

            constantPool.reset();

        }

    }

    private void flush() throws IOException {

        asBaseBuffer(buffer).flip();

        /*

         * Try not to let interrupted threads abort 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 int writeBytesRaw(ByteBuffer b) throws IOException {

        int limit = b.limit();

        int written = 0;

        while (b.position() < limit) {

            int toWrite = Math.min(limit - b.position(), buffer.capacity());

            ensureAvailable(toWrite);

            asBaseBuffer(b).limit(b.position() + toWrite);

            try {

                buffer.put(b);

                written += toWrite;

            } finally {

                asBaseBuffer(b).limit(limit);

            }

        }

        return written;

    }

    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);

            asBaseBuffer(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);

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

        }

    }

    private void writePoolObject(Object obj) throws IOException {

        Object object = obj;

        if (object == null) {

            writeByte(POOL_NULL);

            return;

        }

        Character id = constantPool.get(object);

        if (id == null) {

            addPoolEntry(object);

        } else {

            int type = findPoolType(object, null);

            writeByte(type);

            writeShort(id.charValue());

        }

    }

    private int findPoolType(Object obj, Object[] found) throws IOException {

        Object object = obj;

        if (object == null) {

            return POOL_NULL;

        }

        if (isFound(findJavaField(object), found)) {

            return POOL_FIELD;

        } else if (isFound(findSignature(object), found)) {

            return POOL_SIGNATURE;

        } else if (versionMajor >= 4 && isFound(findNodeSourcePosition(object), found)) {

            return POOL_NODE_SOURCE_POSITION;

        } else {

            final Node node = findNode(object);

            if (versionMajor == 4 && node != null) {

                object = classForNode(node);

            }

            if (isFound(findNodeClass(object), found)) {

                return POOL_NODE_CLASS;

            } else if (versionMajor >= 5 && isFound(node, found)) {

                return POOL_NODE;

            } else if (isFound(findMethod(object), found)) {

                return POOL_METHOD;

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

                if (found != null) {

                    found[0] = ((Enum<?>) object).ordinal();

                }

                return POOL_ENUM;

            } else {

                int val = findEnumOrdinal(object);

                if (val >= 0) {

                    if (found != null) {

                        found[0] = val;

                    }

                    return POOL_ENUM;

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

                    if (found != null) {

                        found[0] = ((Class<?>) object).getName();

                    }