/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.imaging.formats.rgbe;

import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteOrder;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.imaging.ImagingException;
import org.apache.commons.imaging.bytesource.ByteSource;
import org.apache.commons.imaging.common.Allocator;
import org.apache.commons.imaging.common.BinaryFunctions;
import org.apache.commons.imaging.common.ByteConversions;
import org.apache.commons.imaging.common.GenericImageMetadata;
import org.apache.commons.imaging.common.ImageMetadata;

class RgbeInfo implements Closeable {
    // #?RADIANCE
    private static final byte[] HEADER = {
        0x23, 0x3F, 0x52, 0x41, 0x44, 0x49, 0x41, 0x4E, 0x43, 0x45
    };
    private static final Pattern RESOLUTION_STRING = Pattern.compile("-Y (\\d+) \\+X (\\d+)");

    private static final byte[] TWO_TWO = { 0x2, 0x2 };
    private static void decompress(final InputStream in, final byte[] out)
            throws IOException,ImagingException {
        int position = 0;
        final int total = out.length;

        while (position < total) {
            final int n = in.read();

            if (n < 0) {
                throw new ImagingException("Error decompressing RGBE file");
            }

            if (n > 128) {
                final int value = in.read();

                for (int i = 0; i < (n & 0x7f); i++) {
                    out[position++] = (byte) value;
                }
            } else {
                for (int i = 0; i < n; i++) {
                    out[position++] = (byte) in.read();
                }
            }
        }
    }
    private final InputStream in;
    private GenericImageMetadata metadata;
    private int width = -1;

    private int height = -1;

    RgbeInfo(final ByteSource byteSource) throws IOException {
        this.in = byteSource.getInputStream();
    }

    @Override
    public void close() throws IOException {
        in.close();
    }

    int getHeight() throws IOException, ImagingException {
        if (-1 == height) {
            readDimensions();
        }

        return height;
    }

    ImageMetadata getMetadata() throws IOException, ImagingException {
        if (null == metadata) {
            readMetadata();
        }

        return metadata;
    }

    public float[][] getPixelData() throws IOException, ImagingException {
        // Read into local variables to ensure that we have seeked into the file
        // far enough
        final int ht = getHeight();
        final int wd = getWidth();

        if (wd >= 32768) {
            throw new ImagingException("Scan lines must be less than 32768 bytes long");
        }

        final byte[] scanLineBytes = ByteConversions.toBytes((short) wd,
                ByteOrder.BIG_ENDIAN);
        final byte[] rgbe = Allocator.byteArray(wd * 4);
        final float[][] out = new float[3][Allocator.check(wd * ht)];

        for (int i = 0; i < ht; i++) {
            BinaryFunctions.readAndVerifyBytes(in, TWO_TWO, "Scan line " + i + " expected to start with 0x2 0x2");
            BinaryFunctions.readAndVerifyBytes(in, scanLineBytes, "Scan line " + i + " length expected");

            decompress(in, rgbe);

            for (int channel = 0; channel < 3; channel++) {
                final int channelOffset = channel * wd;
                final int eOffset = 3 * wd;

                for (int p = 0; p < wd; p++) {
                    final int mantissa = rgbe[p + eOffset] & 0xff;
                    final int pos = p + i * wd;

                    if (0 == mantissa) {
                        out[channel][pos] = 0;
                    } else {
                        final float mult = (float) Math.pow(2, mantissa - (128 + 8));
                        out[channel][pos] = ((rgbe[p + channelOffset] & 0xff) + 0.5f) * mult;
                    }
                }
            }
        }

        return out;
    }

    int getWidth() throws IOException, ImagingException {
        if (-1 == width) {
            readDimensions();
        }

        return width;
    }

    private void readDimensions() throws IOException, ImagingException {
        getMetadata(); // Ensure we've read past this

        final InfoHeaderReader reader = new InfoHeaderReader(in);
        final String resolution = reader.readNextLine();
        final Matcher matcher = RESOLUTION_STRING.matcher(resolution);

        if (!matcher.matches()) {
            throw new ImagingException(
                    "Invalid HDR resolution string. Only \"-Y N +X M\" is supported. Found \""
                            + resolution + "\"");
        }

        height = Integer.parseInt(matcher.group(1));
        width = Integer.parseInt(matcher.group(2));
    }

    private void readMetadata() throws IOException, ImagingException {
        BinaryFunctions.readAndVerifyBytes(in, HEADER, "Not a valid HDR: Incorrect Header");

        final InfoHeaderReader reader = new InfoHeaderReader(in);

        if (!reader.readNextLine().isEmpty()) {
            throw new ImagingException("Not a valid HDR: Incorrect Header");
        }

        metadata = new GenericImageMetadata();

        String info = reader.readNextLine();

        while (!info.isEmpty()) {
            final int equals = info.indexOf('=');

            if (equals > 0) {
                final String variable = info.substring(0, equals);
                final String value = info.substring(equals + 1);

                if ("FORMAT".equals(value) && !"32-bit_rle_rgbe".equals(value)) {
                    throw new ImagingException("Only 32-bit_rle_rgbe images are supported, trying to read " + value);
                }

                metadata.add(variable, value);
            } else {
                metadata.add("<command>", info);
            }

            info = reader.readNextLine();
        }
    }
}
