/*
 * Copyright (c) 2017 United States Government as represented by the Administrator of the
 * National Aeronautics and Space Administration. All Rights Reserved.
 */

package gov.nasa.worldwind.globe;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ShortBuffer;

import gov.nasa.worldwind.formats.tiff.Subfile;
import gov.nasa.worldwind.formats.tiff.Tiff;
import gov.nasa.worldwind.render.ImageSource;
import gov.nasa.worldwind.util.Logger;
import gov.nasa.worldwind.util.Retriever;
import gov.nasa.worldwind.util.SynchronizedPool;
import gov.nasa.worldwind.util.WWUtil;

public class ElevationRetriever extends Retriever<ImageSource, Void, ShortBuffer> {

    protected SynchronizedPool<byte[]> pageBuffers = new SynchronizedPool<>();

    protected SynchronizedPool<ByteBuffer> tiffData = new SynchronizedPool<>();

    protected int defaultPageBufferSize = 1024 * 16;

    protected int defaultTiffDataSize = 132000;

    public ElevationRetriever(int maxSimultaneousRetrievals) {
        super(maxSimultaneousRetrievals);
        for (int i = 0; i < maxSimultaneousRetrievals; i++) {
            pageBuffers.release(new byte[this.defaultPageBufferSize]);
            tiffData.release(ByteBuffer.allocate(this.defaultTiffDataSize));
        }
    }

    @Override
    protected void retrieveAsync(ImageSource key, Void unused, Callback<ImageSource, Void, ShortBuffer> callback) {
        try {
            ShortBuffer buffer = this.decodeCoverage(key);

            if (buffer != null) {
                callback.retrievalSucceeded(this, key, unused, buffer);
            } else {
                callback.retrievalFailed(this, key, null); // failed but no exception
            }
        } catch (Throwable logged) {
            callback.retrievalFailed(this, key, logged); // failed with exception
        }
    }

    protected ShortBuffer decodeCoverage(ImageSource imageSource) throws IOException {
        if (imageSource.isUrl()) {
            return this.decodeUrl(imageSource.asUrl());
        }

        return this.decodeUnrecognized(imageSource);
    }

    protected ShortBuffer decodeUrl(String urlString) throws IOException {
        // TODO establish a file caching service for remote resources
        // TODO retry absent resources, they are currently handled but suppressed entirely after the first failure
        // TODO configurable connect and read timeouts

        InputStream stream = null;
        try {
            URLConnection conn = new URL(urlString).openConnection();
            conn.setConnectTimeout(3000);
            conn.setReadTimeout(30000);

            stream = new BufferedInputStream(conn.getInputStream());
            String contentType = conn.getContentType();
            if (contentType.equalsIgnoreCase("application/bil16")) {
                return this.readBil16Data(stream);
            } else if (contentType.equalsIgnoreCase("image/tiff")) {
                return this.readTiffData(stream);
            } else {
                // TODO error message
                return null;
            }
        } finally {
            WWUtil.closeSilently(stream);
        }
    }

    protected ShortBuffer decodeUnrecognized(ImageSource imageSource) {
        Logger.log(Logger.WARN, "Unrecognized image source \'" + imageSource + "\'");
        return null;
    }

    protected ShortBuffer readTiffData(InputStream stream) throws IOException {
        byte[] page = this.pageBuffers.acquire();
        if (page == null) {
            page = new byte[this.defaultPageBufferSize];
        }
        ByteBuffer tiffBuffer = this.tiffData.acquire();
        if (tiffBuffer == null) {
            tiffBuffer = ByteBuffer.allocate(this.defaultTiffDataSize);
        }
        tiffBuffer.clear();
        ByteBuffer buffer = this.bufferStream(stream, tiffBuffer, page);
        Tiff tiff = new Tiff(buffer);
        Subfile subfile = tiff.getSubfiles().get(0);
        // check that the format of the subfile matches our supported data types
        if (subfile.getSampleFormat()[0] == 2 &&
            subfile.getBitsPerSample()[0] == 16 &&
            subfile.getSamplesPerPixel() == 1) {
            int dataSize = subfile.getDataSize();
            ByteBuffer result = subfile.getData(ByteBuffer.allocate(dataSize));
            result.clear();
            this.pageBuffers.release(page);
            this.tiffData.release(buffer);
            return result.asShortBuffer();
        } else {
            // TODO error message
            return null;
        }
    }

    protected ShortBuffer readBil16Data(InputStream stream) throws IOException {
        byte[] page = this.pageBuffers.acquire();
        if (page == null) {
            page = new byte[this.defaultPageBufferSize];
        }
        ShortBuffer result = this.bufferStream(stream, ByteBuffer.allocate(page.length), page).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer();
        this.pageBuffers.release(page);
        return result;
    }

    protected ByteBuffer bufferStream(InputStream stream, ByteBuffer buffer, byte[] page) throws IOException {
        if (stream == null) {
            // TODO error message
        }

        if (buffer == null) {
            // TODO error message
        }

        if (page == null) {
            // TODO error message
        }

        int readCount;
        while ((readCount = stream.read(page, 0, page.length)) != -1) {
            if (readCount > buffer.remaining()) {
                ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity() + page.length);
                newBuffer.put((ByteBuffer) buffer.flip());
                buffer = newBuffer;
            }

            buffer.put(page, 0, readCount);
        }

        buffer.flip();

        return buffer;
    }
}