/*

 * Copyright (c) 2014, 2017, 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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 jdk.internal.jimage;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.IntBuffer;

import java.nio.channels.FileChannel;

import java.nio.file.Path;

import java.nio.file.StandardOpenOption;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.Objects;

import java.util.stream.IntStream;

import jdk.internal.jimage.decompressor.Decompressor;

/**

 * @implNote This class needs to maintain JDK 8 source compatibility.

 *

 * It is used internally in the JDK to implement jimage/jrtfs access,

 * but also compiled and delivered as part of the jrtfs.jar to support access

 * to the jimage file provided by the shipped JDK by tools running on JDK 8.

 */

public class BasicImageReader implements AutoCloseable {

    private static boolean isSystemProperty(String key, String value, String def) {

        // No lambdas during bootstrap

        return AccessController.doPrivileged(

            new PrivilegedAction<Boolean>() {

                @Override

                public Boolean run() {

                    return value.equals(System.getProperty(key, def));

                }

            });

    }

    static private final boolean IS_64_BIT =

            isSystemProperty("sun.arch.data.model", "64", "32");

    static private final boolean USE_JVM_MAP =

            isSystemProperty("jdk.image.use.jvm.map", "true", "true");

    static private final boolean MAP_ALL =

            isSystemProperty("jdk.image.map.all", "true", IS_64_BIT ? "true" : "false");

    private final Path imagePath;

    private final ByteOrder byteOrder;

    private final String name;

    private final ByteBuffer memoryMap;

    private final FileChannel channel;

    private final ImageHeader header;

    private final long indexSize;

    private final IntBuffer redirect;

    private final IntBuffer offsets;

    private final ByteBuffer locations;

    private final ByteBuffer strings;

    private final ImageStringsReader stringsReader;

    private final Decompressor decompressor;

    protected BasicImageReader(Path path, ByteOrder byteOrder)

            throws IOException {

        this.imagePath = Objects.requireNonNull(path);

        this.byteOrder = Objects.requireNonNull(byteOrder);

        this.name = this.imagePath.toString();

        ByteBuffer map;

        if (USE_JVM_MAP && BasicImageReader.class.getClassLoader() == null) {

            // Check to see if the jvm has opened the file using libjimage

            // native entry when loading the image for this runtime

            map = NativeImageBuffer.getNativeMap(name);

         } else {

            map = null;

        }

        // Open the file only if no memory map yet or is 32 bit jvm

        if (map != null && MAP_ALL) {

            channel = null;

        } else {

            channel = FileChannel.open(imagePath, StandardOpenOption.READ);

            // No lambdas during bootstrap

            AccessController.doPrivileged(new PrivilegedAction<Void>() {

                @Override

                public Void run() {

                    if (BasicImageReader.class.getClassLoader() == null) {

                        try {

                            Class<?> fileChannelImpl =

                                Class.forName("sun.nio.ch.FileChannelImpl");

                            Method setUninterruptible =

                                    fileChannelImpl.getMethod("setUninterruptible");

                            setUninterruptible.invoke(channel);

                        } catch (ClassNotFoundException |

                                 NoSuchMethodException |

                                 IllegalAccessException |

                                 InvocationTargetException ex) {

                            // fall thru - will only happen on JDK-8 systems where this code

                            // is only used by tools using jrt-fs (non-critical.)

                        }

                    }

                    return null;

                }

            });

        }

        // If no memory map yet and 64 bit jvm then memory map entire file

        if (MAP_ALL && map == null) {

            map = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());

        }

        // Assume we have a memory map to read image file header

        ByteBuffer headerBuffer = map;

        int headerSize = ImageHeader.getHeaderSize();

        // If no memory map then read header from image file

        if (headerBuffer == null) {

            headerBuffer = ByteBuffer.allocateDirect(headerSize);

            if (channel.read(headerBuffer, 0L) == headerSize) {

                headerBuffer.rewind();

            } else {

                throw new IOException("\"" + name + "\" is not an image file");

            }

        } else if (headerBuffer.capacity() < headerSize) {

            throw new IOException("\"" + name + "\" is not an image file");

        }

        // Interpret the image file header

        header = readHeader(intBuffer(headerBuffer, 0, headerSize));

        indexSize = header.getIndexSize();

        // If no memory map yet then must be 32 bit jvm not previously mapped

        if (map == null) {

            // Just map the image index

            map = channel.map(FileChannel.MapMode.READ_ONLY, 0, indexSize);

        }

        memoryMap = map.asReadOnlyBuffer();

        // Interpret the image index

        if (memoryMap.capacity() < indexSize) {

            throw new IOException("The image file \"" + name + "\" is corrupted");

        }

        redirect = intBuffer(memoryMap, header.getRedirectOffset(), header.getRedirectSize());

        offsets = intBuffer(memoryMap, header.getOffsetsOffset(), header.getOffsetsSize());

        locations = slice(memoryMap, header.getLocationsOffset(), header.getLocationsSize());

        strings = slice(memoryMap, header.getStringsOffset(), header.getStringsSize());

        stringsReader = new ImageStringsReader(this);

        decompressor = new Decompressor();

    }

    protected BasicImageReader(Path imagePath) throws IOException {

        this(imagePath, ByteOrder.nativeOrder());

    }

    public static BasicImageReader open(Path imagePath) throws IOException {

        return new BasicImageReader(imagePath, ByteOrder.nativeOrder());

    }

    public ImageHeader getHeader() {

        return header;

    }

    private ImageHeader readHeader(IntBuffer buffer) throws IOException {

        ImageHeader result = ImageHeader.readFrom(buffer);

        if (result.getMagic() != ImageHeader.MAGIC) {

            throw new IOException("\"" + name + "\" is not an image file");

        }

        if (result.getMajorVersion() != ImageHeader.MAJOR_VERSION ||

            result.getMinorVersion() != ImageHeader.MINOR_VERSION) {

            throw new IOException("The image file \"" + name + "\" is not " +

                "the correct version. Major: " + result.getMajorVersion() +

                ". Minor: " + result.getMinorVersion());

        }

        return result;

    }

    private static ByteBuffer slice(ByteBuffer buffer, int position, int capacity) {

        // Note that this is the only limit and position manipulation of

        // BasicImageReader private ByteBuffers.  The synchronize could be avoided

        // by cloning the buffer to make a local copy, but at the cost of creating

        // a new object.

        synchronized(buffer) {

            buffer.limit(position + capacity);

            buffer.position(position);

            return buffer.slice();

        }

    }

    private IntBuffer intBuffer(ByteBuffer buffer, int offset, int size) {

        return slice(buffer, offset, size).order(byteOrder).asIntBuffer();

    }

    public static void releaseByteBuffer(ByteBuffer buffer) {

        Objects.requireNonNull(buffer);

        if (!MAP_ALL) {

            ImageBufferCache.releaseBuffer(buffer);

        }

    }

    public String getName() {

        return name;

    }

    public ByteOrder getByteOrder() {

        return byteOrder;

    }

    public Path getImagePath() {

        return imagePath;

    }

    @Override

    public void close() throws IOException {

        if (channel != null) {

            channel.close();

        }

    }

    public ImageStringsReader getStrings() {

        return stringsReader;

    }

    public synchronized ImageLocation findLocation(String module, String name) {

        Objects.requireNonNull(module);

        Objects.requireNonNull(name);

        // Details of the algorithm used here can be found in

        // jdk.tools.jlink.internal.PerfectHashBuilder.

        int count = header.getTableLength();

        int index = redirect.get(ImageStringsReader.hashCode(module, name) % count);

        if (index < 0) {

            // index is twos complement of location attributes index.

            index = -index - 1;

        } else if (index > 0) {

            // index is hash seed needed to compute location attributes index.

            index = ImageStringsReader.hashCode(module, name, index) % count;

        } else {

            // No entry.

            return null;

        }

        long[] attributes = getAttributes(offsets.get(index));

        if (!ImageLocation.verify(module, name, attributes, stringsReader)) {

            return null;

        }

        return new ImageLocation(attributes, stringsReader);

    }

    public synchronized ImageLocation findLocation(String name) {

        Objects.requireNonNull(name);

        // Details of the algorithm used here can be found in

        // jdk.tools.jlink.internal.PerfectHashBuilder.

        int count = header.getTableLength();

        int index = redirect.get(ImageStringsReader.hashCode(name) % count);

        if (index < 0) {

            // index is twos complement of location attributes index.

            index = -index - 1;

        } else if (index > 0) {

            // index is hash seed needed to compute location attributes index.

            index = ImageStringsReader.hashCode(name, index) % count;

        } else {

            // No entry.

            return null;

        }

        long[] attributes = getAttributes(offsets.get(index));

        if (!ImageLocation.verify(name, attributes, stringsReader)) {

            return null;

        }

        return new ImageLocation(attributes, stringsReader);

    }

    public String[] getEntryNames() {

        int[] attributeOffsets = new int[offsets.capacity()];

        offsets.get(attributeOffsets);

        return IntStream.of(attributeOffsets)

                        .filter(o -> o != 0)

                        .mapToObj(o -> ImageLocation.readFrom(this, o).getFullName())

                        .sorted()

                        .toArray(String[]::new);

    }

    ImageLocation getLocation(int offset) {

        return ImageLocation.readFrom(this, offset);

    }

    public long[] getAttributes(int offset) {

        if (offset < 0 || offset >= locations.limit()) {

            throw new IndexOutOfBoundsException("offset");

        }

        ByteBuffer buffer = slice(locations, offset, locations.limit() - offset);

        return ImageLocation.decompress(buffer);

    }

    public String getString(int offset) {

        if (offset < 0 || offset >= strings.limit()) {

            throw new IndexOutOfBoundsException("offset");

        }

        ByteBuffer buffer = slice(strings, offset, strings.limit() - offset);

        return ImageStringsReader.stringFromByteBuffer(buffer);

    }

    private byte[] getBufferBytes(ByteBuffer buffer) {

        Objects.requireNonNull(buffer);

        byte[] bytes = new byte[buffer.limit()];

        buffer.get(bytes);

        return bytes;

    }

    private ByteBuffer readBuffer(long offset, long size) {

        if (offset < 0 || Integer.MAX_VALUE <= offset) {

            throw new IndexOutOfBoundsException("Bad offset: " + offset);

        }

        if (size < 0 || Integer.MAX_VALUE <= size) {

            throw new IndexOutOfBoundsException("Bad size: " + size);

        }

        if (MAP_ALL) {

            ByteBuffer buffer = slice(memoryMap, (int)offset, (int)size);

            buffer.order(ByteOrder.BIG_ENDIAN);

            return buffer;

        } else {

            if (channel == null) {

                throw new InternalError("Image file channel not open");

            }

            ByteBuffer buffer = ImageBufferCache.getBuffer(size);

            int read;

            try {

                read = channel.read(buffer, offset);

                buffer.rewind();

            } catch (IOException ex) {

                ImageBufferCache.releaseBuffer(buffer);

                throw new RuntimeException(ex);

            }

            if (read != size) {

                ImageBufferCache.releaseBuffer(buffer);

                throw new RuntimeException("Short read: " + read +

                                           " instead of " + size + " bytes");

            }

            return buffer;

        }

    }

    public byte[] getResource(String name) {

        Objects.requireNonNull(name);

        ImageLocation location = findLocation(name);

        return location != null ? getResource(location) : null;

    }

    public byte[] getResource(ImageLocation loc) {

        ByteBuffer buffer = getResourceBuffer(loc);

        if (buffer != null) {

            byte[] bytes = getBufferBytes(buffer);

            ImageBufferCache.releaseBuffer(buffer);

            return bytes;

        }

        return null;

    }

    public ByteBuffer getResourceBuffer(ImageLocation loc) {

        Objects.requireNonNull(loc);

        long offset = loc.getContentOffset() + indexSize;

        long compressedSize = loc.getCompressedSize();

        long uncompressedSize = loc.getUncompressedSize();

        if (compressedSize < 0 || Integer.MAX_VALUE < compressedSize) {

            throw new IndexOutOfBoundsException(

                "Bad compressed size: " + compressedSize);

        }

        if (uncompressedSize < 0 || Integer.MAX_VALUE < uncompressedSize) {

            throw new IndexOutOfBoundsException(

                "Bad uncompressed size: " + uncompressedSize);

        }

        if (compressedSize == 0) {

            return readBuffer(offset, uncompressedSize);

        } else {

            ByteBuffer buffer = readBuffer(offset, compressedSize);

            if (buffer != null) {

                byte[] bytesIn = getBufferBytes(buffer);

                ImageBufferCache.releaseBuffer(buffer);

                byte[] bytesOut;

                try {

                    bytesOut = decompressor.decompressResource(byteOrder,

                            (int strOffset) -> getString(strOffset), bytesIn);

                } catch (IOException ex) {

                    throw new RuntimeException(ex);

                }

                return ByteBuffer.wrap(bytesOut);

            }

        }

        return null;

    }

    public InputStream getResourceStream(ImageLocation loc) {

        Objects.requireNonNull(loc);

        byte[] bytes = getResource(loc);

        return new ByteArrayInputStream(bytes);

    }

}