/*
 * 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.examples.tiff;

import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_CCITT_1D;
import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_CCITT_GROUP_3;
import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_CCITT_GROUP_4;
import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_DEFLATE_ADOBE;
import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_DEFLATE_PKZIP;
import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_LZW;
import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_PACKBITS;
import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_UNCOMPRESSED;
import static org.apache.commons.imaging.formats.tiff.constants.TiffConstants.TIFF_COMPRESSION_UNCOMPRESSED_1;

import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Formatter;

import org.apache.commons.imaging.FormatCompliance;
import org.apache.commons.imaging.ImagingException;
import org.apache.commons.imaging.bytesource.ByteSource;
import org.apache.commons.imaging.formats.tiff.TiffContents;
import org.apache.commons.imaging.formats.tiff.TiffDirectory;
import org.apache.commons.imaging.formats.tiff.TiffField;
import org.apache.commons.imaging.formats.tiff.TiffReader;
import org.apache.commons.imaging.formats.tiff.constants.TiffEpTagConstants;
import org.apache.commons.imaging.formats.tiff.constants.TiffPlanarConfiguration;
import org.apache.commons.imaging.formats.tiff.constants.TiffTagConstants;

/**
 * Provides methods to collect data for a tiff file. This class is intended for use with SurveyTiffFolder, though it could be integrated into other
 * applications.
 */
public class SurveyTiffFile {

    /**
     * Formats a header allowing space for the maximum length of the file paths in the list. If the comma-separated-value option is set, spaces will be
     * suppressed and commas introduced as separators.
     *
     * @param maxPathLen the maximum length of a file path (used if csv option is not set)
     * @param csv        true if formatting is configured for comma-separated-value files.
     * @return a valid string.
     */
    String formatHeader(final int maxPathLen, final boolean csv) {
        // After some false starts, it turned out that the easiest
        // way to do this is just to create a regular header and then
        // search-and-replace spaces with comma as appropriate.
        int n = maxPathLen;
        if (n < 10) {
            n = 10;
        }
        final int k0 = (n - 4) / 2;
        final int k1 = n - 4 - k0;

        final String header = String.format("%" + k0 + "sPath%" + k1 + "s%s", "", "",
                "    Size     Layout  Blk_sz     P_conf  Compress  " + "Predict  Data_Fmt   B/P B/S      Photo     ICC_Pro");
        if (csv) {
            return reformatHeaderForCsv(header);
        }
        return header;
    }

    String getBitsPerSampleString(final int[] bitsPerSample) {
        final StringBuilder s = new StringBuilder();
        for (int i = 0; i < bitsPerSample.length; i++) {
            if (i > 0) {
                s.append(".");
            }
            s.append(Integer.toString(bitsPerSample[i], 10));
        }
        return s.toString();
    }

    private String getCompressionString(final TiffDirectory directory) throws ImagingException {
        final short compressionFieldValue;
        if (directory.findField(TiffTagConstants.TIFF_TAG_COMPRESSION) != null) {
            compressionFieldValue = directory.getFieldValue(TiffTagConstants.TIFF_TAG_COMPRESSION);
        } else {
            compressionFieldValue = TIFF_COMPRESSION_UNCOMPRESSED_1;
        }
        final int compression = 0xffff & compressionFieldValue;
        switch (compression) {
        case TIFF_COMPRESSION_UNCOMPRESSED: // None;
            return "None";
        case TIFF_COMPRESSION_CCITT_1D: // CCITT Group 3 1-Dimensional Modified
            // Huffman run-length encoding.
            return "CCITT_1D";
        case TIFF_COMPRESSION_CCITT_GROUP_3:
            return "CCITT_3";
        case TIFF_COMPRESSION_CCITT_GROUP_4:
            return "CCITT_4";
        case TIFF_COMPRESSION_LZW:
            return "LZW";
        case TIFF_COMPRESSION_PACKBITS:
            return "PACKBITS";
        case TIFF_COMPRESSION_DEFLATE_ADOBE:
        case TIFF_COMPRESSION_DEFLATE_PKZIP:
            return "Deflate";
        default:
            return "None";
        }
    }

    String getIccProfileString(final TiffDirectory directory) throws ImagingException {
        final byte[] b = directory.getFieldValue(TiffEpTagConstants.EXIF_TAG_INTER_COLOR_PROFILE, false);
        if (b == null || b.length == 0) {
            return "N";
        }
        return "Y";
    }

    private String getPhotometricInterpreterString(final TiffDirectory directory, final int[] bitsPerSample) throws ImagingException {
        final int photometricInterpretation = 0xffff & directory.getFieldValue(TiffTagConstants.TIFF_TAG_PHOTOMETRIC_INTERPRETATION);

        switch (photometricInterpretation) {
        case 0:
            return "BiLev Inv";
        case 1:
            return "BiLevel";
        case 2:
            String a = "RGB";
            if (bitsPerSample.length == 4) {
                final Object o = directory.getFieldValue(TiffTagConstants.TIFF_TAG_EXTRA_SAMPLES);
                short extraSamples = 0;
                if (o instanceof Short) {
                    extraSamples = (Short) o;
                }
                if (extraSamples == 1) {
                    a = "RGB Pre-A";
                } else {
                    a = "RGBA";
                }
            }

            return a;
        case 3:
            return "Palette";

        case 5: // CMYK
            return "CMYK";
        case 6:
            return "YCbCr";
        case 8:
            return "CieLab";

        case 32844:
        case 32845:
            return "LogLuv";
        default:
            return "Unknown";

        }

    }

    String getPlanarConfigurationString(final TiffDirectory directory) throws ImagingException {

        // Obtain the planar configuration
        final TiffField pcField = directory.findField(TiffTagConstants.TIFF_TAG_PLANAR_CONFIGURATION);
        final TiffPlanarConfiguration planarConfiguration = pcField == null ? TiffPlanarConfiguration.CHUNKY
                : TiffPlanarConfiguration.lenientValueOf(pcField.getIntValue());

        if (planarConfiguration == TiffPlanarConfiguration.CHUNKY) {
            return "Chunky";
        }
        return "Planar";
    }

    String getPredictorString(final TiffDirectory directory) throws ImagingException {
        int predictor = -1;

        final TiffField predictorField = directory.findField(TiffTagConstants.TIFF_TAG_PREDICTOR);
        if (null != predictorField) {
            predictor = predictorField.getIntValueOrArraySum();
        }

        switch (predictor) {
        case TiffTagConstants.PREDICTOR_VALUE_HORIZONTAL_DIFFERENCING:
            return "Diff";
        case TiffTagConstants.PREDICTOR_VALUE_FLOATING_POINT_DIFFERENCING:
            return "FP Diff";
        default:
            return "None";

        }
    }

    String getSampleFormatString(final TiffDirectory directory) throws ImagingException {
        final short[] sSampleFmt = directory.getFieldValue(TiffTagConstants.TIFF_TAG_SAMPLE_FORMAT, false);
        if (sSampleFmt == null || sSampleFmt.length == 0) {
            return "Unknown";
        }
        String heterogeneous = "";
        for (int i = 1; i < sSampleFmt.length; i++) {
            if (sSampleFmt[i] != sSampleFmt[0]) {
                heterogeneous = "*";
                break;
            }
        }
        final int test = sSampleFmt[0];
        switch (test) {
        case TiffTagConstants.SAMPLE_FORMAT_VALUE_COMPLEX_INTEGER:
            return "Comp I" + heterogeneous;
        case TiffTagConstants.SAMPLE_FORMAT_VALUE_IEEE_FLOATING_POINT:
            return "Float" + heterogeneous;
        case TiffTagConstants.SAMPLE_FORMAT_VALUE_IEEE_COMPLEX_FLOAT:
            return "Comp F" + heterogeneous;
        case TiffTagConstants.SAMPLE_FORMAT_VALUE_TWOS_COMPLEMENT_SIGNED_INTEGER:
            return "Sgn Int" + heterogeneous;
        case TiffTagConstants.SAMPLE_FORMAT_VALUE_UNSIGNED_INTEGER:
            return "Uns Int" + heterogeneous;
        default:
            return "Unknown" + heterogeneous;
        }
    }

    /**
     * Prints the legend information to the output stream
     *
     * @param ps a valid instance
     */
    void printLegend(final PrintStream ps) {
        ps.println("Legend:");
        ps.println("  Size      Size of image (width-by-height)");
        ps.println("  Layout    Organization of the image file (strips versus tiles)");
        ps.println("  Blk_sz    Size of internal image blocks (strips versus tiles)");
        ps.println("  P_conf    Planar configuration, Chunky (interleaved samples) versus Planar ");
        ps.println("  Compress  Compression format");
        ps.println("  Predict   Predictor");
        ps.println("  Data_Fmt  Data format");
        ps.println("  B/P       Bits per pixel");
        ps.println("  B/S       Bits per sample");
        ps.println("  Photo     Photometric Interpretation (pixel color type)");
        ps.println("  ICC_Pro   Is ICC color profile supplied");
        ps.println("");
        ps.println("  RGBA       RGB with unassociated alpha (transparency)");
        ps.println("  RGBA_Pre-A RGB with associated (premultiplied) alpha");
        ps.println("");
    }

    /**
     * Reformats the header inserting commas and removing spaces
     *
     * @param s a valid string
     * @return a header suitable for a CSV file.
     */
    private String reformatHeaderForCsv(final String s) {
        final StringBuilder sb = new StringBuilder(s.length());
        boolean enableComma = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (Character.isWhitespace(c)) {
                if (enableComma) {
                    enableComma = false;
                    sb.append(',');
                }
            } else {
                enableComma = true;
                if (Character.isUpperCase(c)) {
                    c = Character.toLowerCase(c);
                }
                sb.append(c);
            }
        }
        return sb.toString();
    }

    public String surveyFile(final File file, final boolean csv) throws ImagingException, IOException {
        String delimiter = "  ";
        if (csv) {
            delimiter = ", ";
        }

        final StringBuilder sb = new StringBuilder();
        try (final Formatter fmt = new Formatter(sb)) {

            // Establish a TiffReader. This is just a simple constructor that
            // does not actually access the file. So the application cannot
            // obtain the byteOrder, or other details, until the contents have
            // been read. Then read the directories associated with the
            // file by passing in the byte source and options.
            final ByteSource byteSource = ByteSource.file(file);
            final TiffReader tiffReader = new TiffReader(true);
            final TiffContents contents = tiffReader.readDirectories(byteSource, false, // read image data, if present
                    FormatCompliance.getDefault());

            if (contents.directories.isEmpty()) {
                throw new ImagingException("No Image File Directory (IFD) found");
            }
            final TiffDirectory directory = contents.directories.get(0);

            // Get the metadata (Tags) and write them to standard output
            final boolean hasTiffImageData = directory.hasTiffImageData();
            if (!hasTiffImageData) {
                throw new ImagingException("No image data in file");
            }

            final int width = directory.getSingleFieldValue(TiffTagConstants.TIFF_TAG_IMAGE_WIDTH);
            final int height = directory.getSingleFieldValue(TiffTagConstants.TIFF_TAG_IMAGE_LENGTH);

            int samplesPerPixel = 1;
            final TiffField samplesPerPixelField = directory.findField(TiffTagConstants.TIFF_TAG_SAMPLES_PER_PIXEL);
            if (samplesPerPixelField != null) {
                samplesPerPixel = samplesPerPixelField.getIntValue();
            }
            int[] bitsPerSample = { 1 };
            int bitsPerPixel = samplesPerPixel;
            final TiffField bitsPerSampleField = directory.findField(TiffTagConstants.TIFF_TAG_BITS_PER_SAMPLE);
            if (bitsPerSampleField != null) {
                bitsPerSample = bitsPerSampleField.getIntArrayValue();
                bitsPerPixel = bitsPerSampleField.getIntValueOrArraySum();
            }
            if (samplesPerPixel != bitsPerSample.length) {
                throw new ImagingException("Tiff: samplesPerPixel (" + samplesPerPixel + ")!=fBitsPerSample.length (" + bitsPerSample.length + ")");
            }

            int rowsPerStrip = 0;
            int tileWidth = 0;
            int tileHeight = 0;

            final boolean imageDataInStrips = directory.imageDataInStrips();
            if (imageDataInStrips) {
                final TiffField rowsPerStripField = directory.findField(TiffTagConstants.TIFF_TAG_ROWS_PER_STRIP);
                rowsPerStrip = Integer.MAX_VALUE;
                if (null != rowsPerStripField) {
                    rowsPerStrip = rowsPerStripField.getIntValue();
                } else {
                    final TiffField imageHeight = directory.findField(TiffTagConstants.TIFF_TAG_IMAGE_LENGTH);
                    /*
                     * if rows per strip not present then rowsPerStrip is equal to imageLength or an infinity value;
                     */
                    if (imageHeight != null) {
                        rowsPerStrip = imageHeight.getIntValue();
                    }
                }
            } else {
                final TiffField tileWidthField = directory.findField(TiffTagConstants.TIFF_TAG_TILE_WIDTH);
                if (null == tileWidthField) {
                    throw new ImagingException("Can't find tile width field.");
                }
                tileWidth = tileWidthField.getIntValue();
                final TiffField tileLengthField = directory.findField(TiffTagConstants.TIFF_TAG_TILE_LENGTH);
                if (null == tileLengthField) {
                    throw new ImagingException("Can't find tile length field.");
                }
                tileHeight = tileLengthField.getIntValue();
            }

            final String compressionString = getCompressionString(directory);
            final String predictorString = getPredictorString(directory);
            final String planarConfigurationString = getPlanarConfigurationString(directory);
            final String bitsPerSampleString = getBitsPerSampleString(bitsPerSample);
            final String sampleFmtString = getSampleFormatString(directory);
            final String piString = getPhotometricInterpreterString(directory, bitsPerSample);
            final String iccString = getIccProfileString(directory);

            fmt.format("%s%4dx%-4d", delimiter, width, height);
            if (imageDataInStrips) {
                fmt.format("%sStrips%s%4dx%-4d", delimiter, delimiter, width, rowsPerStrip);
            } else {
                fmt.format("%sTiles %s%4dx%-4d", delimiter, delimiter, tileWidth, tileHeight);
            }

            fmt.format("%s%s", delimiter, planarConfigurationString);
            fmt.format("%s%-8s", delimiter, compressionString);
            fmt.format("%s%-7s", delimiter, predictorString);
            fmt.format("%s%-8s", delimiter, sampleFmtString);
            fmt.format("%s%3d", delimiter, bitsPerPixel);
            fmt.format("%s%-7s", delimiter, bitsPerSampleString);
            fmt.format("%s%-9s", delimiter, piString);
            fmt.format("%s%-7s", delimiter, iccString);

            if (csv) {
                return trimForCsv(sb);
            }
            return sb.toString();
        }
    }

    /**
     * Trims spaces from a range of characters intended for a CSV output
     *
     * @param source the standard source file
     * @return the equivalent string with spaces removed.
     */
    private String trimForCsv(final StringBuilder source) {
        int n = source.length();
        final StringBuilder sb = new StringBuilder(n);
        boolean spaceEnabled = false;
        boolean spacePending = false;
        for (int i = 0; i < n; i++) {
            final char c = source.charAt(i);
            if (Character.isWhitespace(c)) {
                if (spaceEnabled) {
                    spacePending = true;
                    spaceEnabled = false;
                }
            } else {

                if (Character.isLetter(c) || Character.isDigit(c)) {
                    if (spacePending) {
                        sb.append(' ');
                        spacePending = false;
                    }
                    spaceEnabled = true;
                } else {
                    spacePending = false;
                    spaceEnabled = false;
                }
                sb.append(c);
            }
        }
        n = sb.length();
        if (n > 0 && sb.charAt(n - 1) == ' ') {
            sb.setLength(n - 1);
        }
        return sb.toString();
    }
}
