/*
 * 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.
 */

/* $Id$ */

package org.apache.fop.render.intermediate;

import java.awt.Rectangle;
import java.awt.geom.AffineTransform;

import org.apache.xmlgraphics.util.DoubleFormatUtil;

import org.apache.fop.apps.FOPException;
import org.apache.fop.fonts.FontInfo;

/**
 * Utility functions for the intermediate format.
 */
public final class IFUtil {

    private IFUtil() {
    }

    private static String format(double value) {
        if (value == -0.0) {
            //Don't allow negative zero because of testing
            //See http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3
            value = 0.0;
        }
        StringBuffer buf = new StringBuffer();
        DoubleFormatUtil.formatDouble(value, 6, 6, buf);
        return buf.toString();
    }

    /**
     * Converts an {@link AffineTransform} instance to an SVG style transform method.
     * @param transform the transformation matrix
     * @param sb the StringBuffer to write the transform method to
     * @return the StringBuffer passed to this method
     */
    public static StringBuffer toString(AffineTransform transform, StringBuffer sb) {
        if (transform.isIdentity()) {
            return sb;
        }
        double[] matrix = new double[6];
        transform.getMatrix(matrix);
        if (matrix[0] == 1 && matrix[3] == 1 && matrix[1] == 0 && matrix[2] == 0) {
            sb.append("translate(");
            sb.append(format(matrix[4]));
            if (matrix[5] != 0) {
                sb.append(',').append(format(matrix[5]));
            }
        } else {
            sb.append("matrix(");
            for (int i = 0; i < 6; i++) {
                if (i > 0) {
                    sb.append(',');
                }
                sb.append(format(matrix[i]));
            }
        }
        sb.append(')');
        return sb;
    }

    /**
     * Converts an {@link AffineTransform} array to an SVG style transform method sequence.
     * @param transforms the transformation matrix array
     * @param sb the StringBuffer to write the transform method sequence to
     * @return the StringBuffer passed to this method
     */
    public static StringBuffer toString(AffineTransform[] transforms, StringBuffer sb) {
        for (int i = 0, c = transforms.length; i < c; i++) {
            if (i > 0) {
                sb.append(' ');
            }
            toString(transforms[i], sb);
        }
        return sb;
    }

    /**
     * Converts an {@link AffineTransform} array to an SVG style transform method sequence.
     * @param transforms the transformation matrix array
     * @return the formatted array
     */
    public static String toString(AffineTransform[] transforms) {
        return toString(transforms, new StringBuffer()).toString();
    }

    /**
     * Converts an {@link AffineTransform} instance to an SVG style transform method.
     * @param transform the transformation matrix
     * @return the formatted array
     */
    public static String toString(AffineTransform transform) {
        return toString(transform, new StringBuffer()).toString();
    }

    /**
     * Converts an array of integer coordinates into a space-separated string.
     * @param coordinates the coordinates
     * @return the space-separated array of coordinates
     */
    public static String toString(int[] coordinates) {
        if (coordinates == null) {
            return "";
        }
        StringBuffer sb = new StringBuffer();
        for (int i = 0, c = coordinates.length; i < c; i++) {
            if (i > 0) {
                sb.append(' ');
            }
            sb.append(Integer.toString(coordinates[i]));
        }
        return sb.toString();
    }

    /**
     * Converts a rectangle into a space-separated string.
     * @param rect the rectangle
     * @return the space-separated array of coordinates
     */
    public static String toString(Rectangle rect) {
        if (rect == null) {
            return "";
        }
        StringBuffer sb = new StringBuffer();
        sb.append(rect.x).append(' ').append(rect.y).append(' ');
        sb.append(rect.width).append(' ').append(rect.height);
        return sb.toString();
    }

    /**
     * Sets up the fonts on a document handler. If the document handler provides a configurator
     * object the configuration from the {@link org.apache.fop.apps.FopFactory} will be used.
     * Otherwise, a default font configuration will be set up.
     * @param documentHandler the document handler
     * @param fontInfo the font info object (may be null)
     * @throws FOPException if an error occurs while setting up the fonts
     */
    public static void setupFonts(IFDocumentHandler documentHandler, FontInfo fontInfo)
                throws FOPException {
        if (fontInfo == null) {
            fontInfo = new FontInfo();
        }
        if (documentHandler instanceof IFSerializer) {
            IFSerializer serializer = (IFSerializer)documentHandler;
            if (serializer.getMimickedDocumentHandler() != null) {
                //Use the mimicked document handler's configurator to set up fonts
                documentHandler = serializer.getMimickedDocumentHandler();
            }
        }
        IFDocumentHandlerConfigurator configurator = documentHandler.getConfigurator();
        if (configurator != null) {
            configurator.setupFontInfo(documentHandler.getMimeType(), fontInfo);
            documentHandler.setFontInfo(fontInfo);
        } else {
            documentHandler.setDefaultFontInfo(fontInfo);
        }
    }

    /**
     * Sets up the fonts on a document handler. If the document handler provides a configurator
     * object the configuration from the {@link org.apache.fop.apps.FopFactory} will be used.
     * Otherwise, a default font configuration will be set up.
     * @param documentHandler the document handler
     * @throws FOPException if an error occurs while setting up the fonts
     */
    public static void setupFonts(IFDocumentHandler documentHandler) throws FOPException {
        setupFonts(documentHandler, null);
    }

    /**
     * Returns the MIME type of the output format that the given document handler is supposed to
     * handle. If the document handler is an {@link IFSerializer} it returns the MIME type of the
     * document handler it is mimicking.
     * @param documentHandler the document handler
     * @return the effective MIME type
     */
    public static String getEffectiveMIMEType(IFDocumentHandler documentHandler) {
        if (documentHandler instanceof IFSerializer) {
            IFDocumentHandler mimic = ((IFSerializer)documentHandler).getMimickedDocumentHandler();
            if (mimic != null) {
                return mimic.getMimeType();
            }
        }
        return documentHandler.getMimeType();
    }

    /**
     * Convert the general gpos 'dp' adjustments to the older 'dx' adjustments.
     * This utility method is used to provide backward compatibility in implementations
     * of IFPainter that have not yet been upgraded to the general position adjustments format.
     * @param dp an array of 4-tuples, expressing [X,Y] placment
     * adjustments and [X,Y] advancement adjustments, in that order (may be null)
     * @param count if <code>dp</code> is not null, then a count of dp values to convert
     * @return if <code>dp</code> is not null, then an array of adjustments to the current
     * x position prior to rendering individual glyphs; otherwise, null
     */
    public static int[] convertDPToDX(int[][] dp, int count) {
        int[] dx;
        if (dp != null) {
            dx = new int [ count ];
            for (int i = 0, n = count; i < n; i++) {
                if (dp [ i ] != null) {
                    dx [ i ] = dp [ i ] [ 0 ];      // xPlaAdjust[i]
                }
            }
        } else {
            dx = null;
        }
        return dx;
    }

    /**
     * Convert the general gpos 'dp' adjustments to the older 'dx' adjustments.
     * This utility method is used to provide backward compatibility in implementations
     * of IFPainter that have not yet been upgraded to the general position adjustments format.
     * @param dp an array of 4-tuples, expressing [X,Y] placment
     * adjustments and [X,Y] advancement adjustments, in that order (may be null)
     * @return if <code>dp</code> is not null, then an array of adjustments to the current
     * x position prior to rendering individual glyphs; otherwise, null
     */
    public static int[] convertDPToDX(int[][] dp) {
        return convertDPToDX(dp, (dp != null) ? dp.length : 0);
    }

    /**
     * Convert the general gpos 'dp' adjustments to the older 'dx' adjustments.
     * This utility method is used to provide backward compatibility in implementations
     * of IFPainter that have not yet been upgraded to the general position adjustments format.
     * @param dx an array of adjustments to the current x position prior to rendering
     * individual glyphs or null
     * @param count if <code>dx</code> is not null, then a count of dx values to convert
     * @return if <code>dx</code> is not null, then an array of 4-tuples, expressing [X,Y]
     * placment adjustments and [X,Y] advancement adjustments, in that order; otherwise, null
     */
    public static int[][] convertDXToDP(int[] dx, int count) {
        int[][] dp;
        if (dx != null) {
            dp = new int [ count ] [ 4 ];
            for (int i = 0, n = count; i < n; i++) {
                int[] pa = dp [ i ];
                int   d  = dx [ i ];
                pa [ 0 ] = d;                   // xPlaAdjust[i]
                pa [ 2 ] = d;                   // xAdvAdjust[i]
            }
        } else {
            dp = null;
        }
        return dp;
    }

    /**
     * Convert the general gpos 'dp' adjustments to the older 'dx' adjustments.
     * This utility method is used to provide backward compatibility in implementations
     * of IFPainter that have not yet been upgraded to the general position adjustments format.
     * @param dx an array of adjustments to the current x position prior to rendering
     * individual glyphs or null
     * @return if <code>dx</code> is not null, then an array of 4-tuples, expressing [X,Y]
     * placment adjustments and [X,Y] advancement adjustments, in that order; otherwise, null
     */
    public static int[][] convertDXToDP(int[] dx) {
        return convertDXToDP(dx, (dx != null) ? dx.length : 0);
    }

    /**
     * Determine if position adjustment is the identity adjustment, i.e., no non-zero adjustment.
     * @param pa a 4-tuple, expressing [X,Y] placment and [X,Y] advance adjuustments (may be null)
     * @return true if <code>dp</code> is null or contains no non-zero adjustment
     */
    public static boolean isPAIdentity(int[] pa) {
        if (pa == null) {
            return true;
        } else {
            for (int k = 0; k < 4; k++) {
                if (pa[k] != 0) {
                    return false;
                }
            }
            return true;
        }
    }

    /**
     * Determine if position adjustments is the identity adjustment, i.e., no non-zero adjustment.
     * @param dp an array of 4-tuples, expressing [X,Y] placment
     * adjustments and [X,Y] advancement adjustments, in that order (may be null)
     * @return true if <code>dp</code> is null or contains no non-zero adjustment
     */
    public static boolean isDPIdentity(int[][] dp) {
        if (dp == null) {
            return true;
        } else {
            for (int[] aDp : dp) {
                if (!isPAIdentity(aDp)) {
                    return false;
                }
            }
            return true;
        }
    }

    /**
     * Determine if position adjustments comprises only DX adjustments as encoded by
     * {@link #convertDPToDX}. Note that if given a set of all all zero position
     * adjustments, both this method and {@link #isDPIdentity} will return true;
     * however, this method may return true when {@link #isDPIdentity} returns false.
     * @param dp an array of 4-tuples, expressing [X,Y] placment
     * adjustments and [X,Y] advancement adjustments, in that order (may be null)
     * @return true if <code>dp</code> is not null and contains only xPlaAdjust
     * and xAdvAdjust values consistent with the output of {@link #convertDPToDX}.
     */
    public static boolean isDPOnlyDX(int[][] dp) {
        if (dp == null) {
            return false;
        } else {
            for (int[] pa : dp) {
                if ((pa != null) && (pa[0] != pa[2])) {
                    return false;
                }
            }
            return true;
        }
    }

    /**
     * Adjust a position adjustments array. If both <code>paDst</code> and <code>paSrc</code> are
     * non-null, then <code>paSrc[i]</code> is added to <code>paDst[i]</code>.
     * @param paDst a 4-tuple, expressing [X,Y] placment
     * and [X,Y] advance adjuustments (may be null)
     * @param paSrc a 4-tuple, expressing [X,Y] placment
     * and [X,Y] advance adjuustments (may be null)
     */
    public static void adjustPA(int[] paDst, int[] paSrc) {
        if ((paDst != null) && (paSrc != null)) {
            assert paDst.length == 4;
            assert paSrc.length == 4;
            for (int i = 0; i < 4; i++) {
                paDst[i] += paSrc[i];
            }
        }
    }

    /**
     * Copy entries from position adjustments.
     * @param dp an array of 4-tuples, expressing [X,Y] placment
     * adjustments and [X,Y] advancement adjustments, in that order
     * @param offset starting offset from which to copy
     * @param count number of entries to copy
     * @return a deep copy of the count position adjustment entries start at
     * offset
     */
    public static int[][] copyDP(int[][] dp, int offset, int count) {
        if ((dp == null) || (offset > dp.length) || ((offset + count) > dp.length)) {
            throw new IllegalArgumentException();
        } else {
            int[][] dpNew = new int [ count ] [];
            for (int i = 0, n = count; i < n; i++) {
                int[] paSrc = dp [ i + offset ];
                if (paSrc != null) {
                    int[] paDst = new int [ 4 ];
                    System.arraycopy(paSrc, 0, paDst, 0, 4);
                    dpNew [ i ] = paDst;
                }
            }
            return dpNew;
        }
    }

}
