/*
 * Copyright (c) 1997-2018 IDRsolutions (https://www.idrsolutions.com)
 */


package org.jpedal.examples.images;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import org.jpedal.examples.handlers.DefaultImageHelper;
import org.jpedal.exception.PdfException;
import org.jpedal.io.ColorSpaceConvertor;
import org.jpedal.utils.LogWriter;

/**
 <h2>Clipped Image Extraction from PDF files</h2>
 <br>
 * This class provides a simple Java API to extract clipped images from a PDF file and also
 * a static convenience method if you just want to dump all the images from a PDF file
 * or directory containing PDF files at a set of sizes<br>
 <br>
 <h3>Example 1 - access API methods</h3>
 <pre><code>ExtractClippedImages extract=new ExtractClippedImages("C:/pdfs/mypdf.pdf");
 * //extract.setPassword("password");
 * if (extract.openPDFFile()) {
 *     int pageCount=extract.getPageCount();
 *     for (int page=1; page&lt;=pageCount; page++) {
 *
 *        int imagesOnPageCount=extract.getImageCount(page);
 *        for (int image=0; image&lt;imagesOnPageCount; image++) {
 *             BufferedImage image=extract.getClippedImage(page, image);
 *        }
 *     }
 * }
 *
 * extract.closePDFfile();</code></pre>
 <br>
 <h3>Example 2 - convenience static method</h3>
 * Extract images with clip applied and rescale to set of predefined pixel heights (-1 is raw size)<br>
 <pre><code>ExtractClippedImages.writeAllClippedImagesToDirs(inputDir, outDir, new String[]{"500","scaled","-1","rawSize"});</code></pre>
 *
 <h3>Example 3 - Access directly from the Jar</h3>
 * ExtractClippedImages can run from jar directly using the command and will extract all files from a PDF file or directory
 * to a defined output directory:<br>
 *
 <code>java -cp libraries_needed org/jpedal/examples/ ExtractClippedImages $inputDir $output_dir imageOutputType h1 dir1 h2 dir2 ... hn dirn</code><br>
 *
 * Values with SPACES must be surrounded by "" as in "This is one value". The values passed are:
 *
 <ul>
 <li>$inputDir - directory containing files.</li>
 <li>$output_dir - directory to put files in.</li>
 <li>imageOutputType - save images as jpeg, tiff or png.</li>
 <li>Any number of pairs of values: h dir</li>
 </ul>
 *
 * h - height required in pixels as an integer for output (-1 means keep current size) dir - directory to write out images.<br>
 *
 * So to create 3 versions of the image (one at original size, one at 100 and one at 50 pixels high), you would use:<br>
 *
 <b>java -cp libraries_needed org/jpedal/examples/images/ExtractClippedImages pdfFiles ouput /logs/image.log -1 raw 100 medium 50 thumbnail/</b><br>
 *
 * Note image quality depends on the raw image in the original. It can be VERY memory intensive.<br>
 *
 <br><a href="https://support.idrsolutions.com/hc/en-us/articles/115001993492">See our support pages for more information on extracting images.</a>
 */
public class ExtractClippedImages extends BaseImageExtraction {

    /**
     * number of output directories
     */
    private static int outputCount;

    /**
     * sizes to output at -1 means unchanged
     */
    private static float[] outputSizes;

    /**
     * target directories for files
     */
    private static String[] outputDirectories;

    /**
     * background colour to add to JPEG
     */
    private static final Color backgroundColor = Color.WHITE;

    /**
     * Sets up an ExtractClippedImages instance to open a PDF File
     *
     @param fileName full path to a single PDF file
     */
    public ExtractClippedImages(final String fileName) {
        super(fileName);

        init();
    }

    /**
     * Sets up an ExtractClippedImages instance to open  a PDF file contained as a BLOB within a byte[] stream
     *
     @param byteArray
     */
    public ExtractClippedImages(final byte[] byteArray) {
        super(byteArray);

        init();

    }

    /**
     * extract any image from any page - recommended you process images on each page in turn as quicker
     *
     @param page        logical page number (1 is first page)
     @param imageNumber image on page (0 is first image)
     @return BufferedImage
     @throws PdfException PdfException
     */
    public BufferedImage getClippedImage(final int page, final int imageNumberthrows PdfException {

        return getClippedImage(page, getImageName(page, imageNumber));
    }

    /**
     * extract any image from any page - recommended you process images on each page in turn as quicker
     *
     @param page       logical page number (1 is first page)
     @param image_name name of image
     @return BufferedImage
     @throws PdfException PdfException
     */
    private BufferedImage getClippedImage(final int page, final String image_namethrows PdfException {

        selectPage(page);

        return decode_pdf.getObjectStore().loadStoredImage("CLIP_" + image_name);

    }

    /**
     * Convenience method to Extract all the images in a directory of PDF files
     *
     @param inputDir directory of input files
     @param outDir directory of output files
     @param subDirs sub directory of files
     @throws org.jpedal.exception.PdfException PdfException
     */
    public static void writeAllClippedImagesToDirs(final String inputDir, final String outDir, final String imageType, final String[] subDirsthrows PdfException {

        final ExtractClippedImages extract = new ExtractClippedImages(inputDir);

        extract.setup(outDir, imageType, subDirs);

        extract.processFiles(inputDir);

        extract.closePDFfile();

    }

    private void setup(String outDir, final String imageType, final String[] subDirsthrows PdfException {

        //check output dir has separator
        if (!outDir.endsWith(separator)) {
            outDir += separator;
        }

        this.imageType = imageType;

        //read output values
        outputCount = (subDirs.length2;

        //read and create output directories
        outputSizes = new float[outputCount];
        outputDirectories = new String[outputCount];
        for (int i = 0; i < outputCount; i++) {

            try {
                outputSizes[i= Float.parseFloat(subDirs[(i * 2)]);
            catch (final Exception e) {
                throw new PdfException("Exception " + e + " reading integer " + subDirs[(i * 2)]);
            }

            try {
                //outputDirectories[i]=outDir;//args[1+(i*2)];

                outputDirectories[i= outDir + subDirs[(i * 2)];

                if ((!outputDirectories[i].endsWith("\\")) && (!outputDirectories[i].endsWith("/"))) {
                    outputDirectories[i+= separator;
                }

                final File dir = new File(outputDirectories[i]);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
            catch (final Exception e) {
                throw new PdfException("Exception " + e + " with directory " + subDirs[(i * 2)]);
            }
        }
    }

    /**
     * routine to decodeFile a PDF file
     */
    @Override
    void decodeFile(final String file_namethrows PdfException {

        if (openPDFFile()) {

            //page range
            final int start = 1;
            final int end = getPageCount();

            try {
                for (int page = start; page < end + 1; page++) { //read pages

                    LogWriter.writeLog("Decoding Page " + page);

                    //image count (note image 1 is item 0, so any loop runs 0 to count-1)
                    final int image_count = getImageCount(page);

                    //tell user
                    if (image_count > 0) {
                        LogWriter.writeLog("page" ' ' + page + "contains " + image_count + " images");
                    else {
                        LogWriter.writeLog("No bitmapped images on page " + page);
                    }

                    LogWriter.writeLog("Writing out " + image_count + " images");

                    //location of images
                    final float[] x1 = new float[image_count];
                    final float[] y1 = new float[image_count];
                    final float[] w = new float[image_count];
                    final float[] h = new float[image_count];

                    final String[] image_name = new String[image_count];
                    final BufferedImage[] image = new BufferedImage[image_count];

                    //work through and get each image details
                    for (int i = 0; i < image_count; i++) {

                        image_name[i= getImageName(page, i);

                        //we need some duplicates as we update some values on merge but still need originals at end
                        //so easiest just to store
                        x1[i= pdf_images.getImageXCoord(i);
                        y1[i= pdf_images.getImageYCoord(i);
                        w[i= pdf_images.getImageWidth(i);
                        h[i= pdf_images.getImageHeight(i);

                        image[i= getClippedImage(page, image_name[i]);

                    }

                    //save each image
                    for (int i = 0; i < image_count; i++) {

                        if (image[i!= null) {
                            //if(isMerged[i]){  //uncomment if you want just merged images
                            generateVersions(file_name, page, "<PAGELOCATION x1=\"" + x1[i"\" "
                                    "y1=\"" (y1[i+ h[i]) "\" "
                                    "x2=\"" (x1[i+ w[i]) "\" "
                                    "y2=\"" (y1[i]) "\" />\n", image[i], i);
                            //}
                        }
                    }

                    //flush images in case we do more than 1 page so only contains
                    //images from current page
                    decode_pdf.flushObjectValues(true);

                }
            catch (final Exception e) {
                decode_pdf.closePdfFile();
                LogWriter.writeLog("Exception " + e.getMessage());

                e.printStackTrace();
            }
        }

        decode_pdf.closePdfFile();

    }

    private void generateVersions(final String file_name, final int page, final String s, final BufferedImage bufferedImage, final int i) {

        for (int versions = 0; versions < outputCount; versions++) {
            try {
                //find out format image was saved in

                //load image (converted to rgb)
                BufferedImage image_to_save = bufferedImage;
                if (image_to_save == null) {
                    continue;
                }

                int index = file_name.lastIndexOf('\\');
                if (index == -1) {
                    index = file_name.lastIndexOf('/');
                }
                if (index == -1) {
                    index = 0;
                }
                final String nameToUse = file_name.substring(index, file_name.length() 4);
                final String outputName = outputDirectories[versions+ nameToUse + '_' + page + '_' + i;

                float scaling = 1;

                final int newHeight = image_to_save.getHeight();

                //scale
                if (outputSizes[versions0) {

                    scaling = outputSizes[versions/ newHeight;

                    if (scaling > 1) {
                        scaling = 1;
                    else {

                        final Image scaledImage = image_to_save.getScaledInstance(-1(intoutputSizes[versions], BufferedImage.SCALE_SMOOTH);

                        image_to_save = new BufferedImage(scaledImage.getWidth(null), scaledImage.getHeight(null), BufferedImage.TYPE_INT_ARGB);

                        final Graphics2D g2 = image_to_save.createGraphics();

                        g2.drawImage(scaledImage, 00null);
                        //ImageIO.write((RenderedImage) scaledImage,"PNG",new File(outputName));


                    }
                }

                //final String tiffFlag=System.getProperty("org.jpedal.compress_tiff");
                //final String jpgFlag=System.getProperty("org.jpedal.jpeg_dpi");
                //final boolean compressTiffs = tiffFlag!=null;

                //no transparency on JPEG so give background and draw on
                if (imageType.startsWith("jp")) {

                    final int iw = image_to_save.getWidth();
                    final int ih = image_to_save.getHeight();
                    final BufferedImage background = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_RGB);

                    final Graphics2D g2 = (Graphics2Dbackground.getGraphics();
                    g2.setPaint(backgroundColor);
                    g2.fillRect(00, iw, ih);

                    g2.drawImage(image_to_save, 00null);
                    image_to_save = background;

                }

                if (image_to_save.getType() == BufferedImage.TYPE_CUSTOM) {
                    image_to_save = ColorSpaceConvertor.convertToARGB(image_to_save);
                }

                try {
                    DefaultImageHelper.write(image_to_save, imageType, outputName + '.' + imageType);
                catch (final IOException ex) {
                    LogWriter.writeLog("Exception in writing image " + ex);
                }

                //save an xml file with details

                //LogWriter.writeLog( "Writing out "+(outputName + ".xml"));
                final OutputStreamWriter output_stream = new OutputStreamWriter(new FileOutputStream(outputName + ".xml")"UTF-8");

                output_stream.write(
                        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
                output_stream.write(
                        "<!-- Pixel Location of image x1,y1,x2,y2\n");
                output_stream.write("(x1,y1 is top left corner)\n");
                output_stream.write(
                        "(origin is bottom left corner)  -->\n");
                output_stream.write("\n\n<META>\n");
                output_stream.write(s);
                output_stream.write("<FILE>" + file_name + "</FILE>\n");
                output_stream.write("<ORIGINALHEIGHT>" + newHeight + "</ORIGINALHEIGHT>\n");
                output_stream.write("<SCALEDHEIGHT>" + image_to_save.getHeight() "</SCALEDHEIGHT>\n");
                output_stream.write("<SCALING>" + scaling + "</SCALING>\n");
                output_stream.write("</META>\n");
                output_stream.close();
            catch (final Exception ee) {
                LogWriter.writeLog("Exception " + ee + " in extracting images");
            }
        }
    }


    /**
     * main routine which checks for any files passed and runs the demo
     *
     @param args arguments
     */
    @SuppressWarnings("unused")
    public static void main(final String[] args) {

        final String[] subDirs = validateInputValues(args);

        try {
            ExtractClippedImages.writeAllClippedImagesToDirs(args[0], args[1], args[2], subDirs);
        catch (final PdfException e) {
            throw new RuntimeException(e);
        }

    }

    private static String[] validateInputValues(final String[] argsthrows RuntimeException {

        final String[] subDirs;
        String inputDir;  //rootDir containing files

        //exit and report if wrong number of values
        if (args.length >= && (args.length % 2== 1) {

            LogWriter.writeLog("Values read");
            LogWriter.writeLog("inputDir=" + args[0]);
            LogWriter.writeLog("type=" + args[1]);
            LogWriter.writeLog("Directory and height pair values" + args[3" <> " + args[4'<');

            inputDir = args[0];

            outputCount = (args.length - 3);

            subDirs = new String[outputCount];

            for (int i = 0; i < outputCount; i++) {
                LogWriter.writeLog(args[i + 3]);
                if (((i % 2== 0&& (!args[i + 3].matches("((-|\\+)?[0-9]+(\\.[0-9]+)?)+"))) {
                    throw new RuntimeException("Invalid value: " + args[i + 3]);
                }
                subDirs[i= args[i + 3];
            }

        else if (((args.length - 32== 1) {
            throw new RuntimeException("Value/Directory pairs invalid");
        else {
            System.out.println("Requires");
            System.out.println("inputDir processedDir imageOutputType");
            System.out.println("height Directory (as many pairs as you like)");
            throw new RuntimeException("Not enough parameters passed to software");
        }

        final File pdf_file = new File(inputDir);

        if (!pdf_file.exists()) {
            throw new RuntimeException("Directory " + inputDir + " not found");
        }

        return subDirs;
    }

    @Override
    void init() {

        type = ExtractTypes.CLIPPED_IMAGES;

        super.init();
    }

    /**
     * returns an image count for the selected page
     *
     @param page logical page number
     @return int number of images (0 if no images)
     @throws PdfException PdfException
     */
    public int getImageCount(final int pagethrows PdfException {

        selectPage(page);

        //image count (note image 1 is item 0, so any loop runs 0 to count-1)
        return pdf_images.getImageCount();
    }


    /**
     * Return name of image (composite of filename and Internal PDF image name)
     *
     @param page        - logical page number
     @param imageNumber - number of image (0 is first image)
     @return - String containing image name
     @throws PdfException PdfException
     */
    private String getImageName(final int page, final int imageNumberthrows PdfException {

        selectPage(page);

        return pdf_images.getImageName(imageNumber);
    }
}