/*******************************************************************************
 * Copyright (c) 2012, 2013, 2014 Original authors and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Original authors and others - initial API and implementation
 *     Dirk Fauth <dirk.fauth@googlemail.com> - Added image scaling
 ******************************************************************************/
package org.eclipse.nebula.widgets.nattable.util;

import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.util.concurrent.atomic.AtomicLong;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Display;

public class GUIHelper {

    private static final String KEY_PREFIX = GUIHelper.class.getCanonicalName() + "."; //$NON-NLS-1$

    // Color

    public static final Color COLOR_GRAY = Display.getDefault().getSystemColor(SWT.COLOR_GRAY);
    public static final Color COLOR_WHITE = Display.getDefault().getSystemColor(SWT.COLOR_WHITE);
    public static final Color COLOR_DARK_GRAY = Display.getDefault().getSystemColor(SWT.COLOR_DARK_GRAY);
    public static final Color COLOR_BLACK = Display.getDefault().getSystemColor(SWT.COLOR_BLACK);
    public static final Color COLOR_BLUE = Display.getDefault().getSystemColor(SWT.COLOR_BLUE);
    public static final Color COLOR_RED = Display.getDefault().getSystemColor(SWT.COLOR_RED);
    public static final Color COLOR_YELLOW = Display.getDefault().getSystemColor(SWT.COLOR_YELLOW);
    public static final Color COLOR_GREEN = Display.getDefault().getSystemColor(SWT.COLOR_GREEN);

    public static final Color COLOR_LIST_BACKGROUND = Display.getDefault().getSystemColor(SWT.COLOR_LIST_BACKGROUND);
    public static final Color COLOR_LIST_FOREGROUND = Display.getDefault().getSystemColor(SWT.COLOR_LIST_FOREGROUND);
    public static final Color COLOR_LIST_SELECTION = Display.getDefault().getSystemColor(SWT.COLOR_LIST_SELECTION);
    public static final Color COLOR_LIST_SELECTION_TEXT = Display.getDefault().getSystemColor(SWT.COLOR_LIST_SELECTION_TEXT);

    public static final Color COLOR_WIDGET_BACKGROUND = Display.getDefault().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
    public static final Color COLOR_WIDGET_FOREGROUND = Display.getDefault().getSystemColor(SWT.COLOR_WIDGET_FOREGROUND);
    public static final Color COLOR_TITLE_INACTIVE_BACKGROUND = Display.getDefault().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND);
    public static final Color COLOR_WIDGET_BORDER = Display.getDefault().getSystemColor(SWT.COLOR_WIDGET_BORDER);
    public static final Color COLOR_WIDGET_DARK_SHADOW = Display.getDefault().getSystemColor(SWT.COLOR_WIDGET_DARK_SHADOW);
    public static final Color COLOR_WIDGET_LIGHT_SHADOW = Display.getDefault().getSystemColor(SWT.COLOR_WIDGET_LIGHT_SHADOW);
    public static final Color COLOR_WIDGET_NORMAL_SHADOW = Display.getDefault().getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW);
    public static final Color COLOR_WIDGET_HIGHLIGHT_SHADOW = Display.getDefault().getSystemColor(SWT.COLOR_WIDGET_HIGHLIGHT_SHADOW);

    public static Color getColor(RGB rgb) {
        return getColor(rgb.red, rgb.green, rgb.blue);
    }

    public static Color getColor(int red, int green, int blue) {
        String key = getColorKey(red, green, blue);
        if (JFaceResources.getColorRegistry().hasValueFor(key)) {
            return JFaceResources.getColorRegistry().get(key);
        } else {
            JFaceResources.getColorRegistry().put(key, new RGB(red, green, blue));
            return getColor(key);
        }
    }

    public static Color getColor(String key) {
        return JFaceResources.getColorRegistry().get(key);
    }

    private static String getColorKey(int red, int green, int blue) {
        return KEY_PREFIX + "_COLOR_" + red + "_" + green + "_" + blue; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
    }

    // Font

    public static final Font DEFAULT_FONT = Display.getDefault().getSystemFont();

    public static final int DEFAULT_RESIZE_HANDLE_SIZE = 4;
    public static final int DEFAULT_MIN_DISPLAY_SIZE = 5;
    public static final int DEFAULT_ANTIALIAS = SWT.DEFAULT;;
    public static final int DEFAULT_TEXT_ANTIALIAS = SWT.DEFAULT;;

    public static Font getFont(FontData... fontDatas) {
        StringBuilder keyBuilder = new StringBuilder();
        for (FontData fontData : fontDatas) {
            keyBuilder.append(fontData.toString());
        }
        String key = keyBuilder.toString();

        if (JFaceResources.getFontRegistry().hasValueFor(key)) {
            return JFaceResources.getFont(key);
        } else {
            JFaceResources.getFontRegistry().put(key, fontDatas);
            return JFaceResources.getFont(key);
        }
    }

    public static Font getFont(String key) {
        return JFaceResources.getFont(key);
    }

    // Image

    private static final String[] IMAGE_DIRS = new String[] { "org/eclipse/nebula/widgets/nattable/images/", "" }; //$NON-NLS-1$ //$NON-NLS-2$
    private static final String[] IMAGE_EXTENSIONS = new String[] { ".png", ".gif" }; //$NON-NLS-1$ //$NON-NLS-2$

    /**
     * This method extracts the base filename out of the given {@link URL} and
     * uses it as key to search for the {@link Image} in the
     * {@link ImageRegistry}. If the {@link Image} is not yet present it will
     * create the {@link Image} instance and register it automatically. On
     * creating and registering it will respect dpi scaling.
     *
     * @param url
     *            The {@link URL} of the image for initial loading.
     * @return The {@link Image} representation of an image external to
     *         NatTable.
     *
     * @see #getImageByURL(String, URL)
     */
    public static Image getImageByURL(URL url) {
        String basename = url.toString();
        basename = basename.substring(basename.lastIndexOf('/') + 1, basename.lastIndexOf('.'));
        return getImageByURL(basename, url);
    }

    /**
     * This method returns the {@link Image} that is registered for the given
     * key. If there is no {@link Image} registered for that key already, it
     * will create and register the {@link Image} that can be loaded by the
     * given {@link URL}.
     * <p>
     * This method returns an {@link Image} that matches the dpi settings. If
     * the dpi of an axis is bigger than 96 it will search for an image for the
     * bigger dpi. For this the filenames need to carry the dpi information.
     * </p>
     * <p>
     * For example if you request <i>checkbox.png</i> this method will search
     * for a scaled version relative to the requested image. The following will
     * give an example on the scaled files:
     * <ul>
     * <li>checkbox.png</li>
     * <li>checkbox_120_120.png</li>
     * <li>checkbox_128_128.png</li>
     * <li>checkbox_144_144.png</li>
     * <li>checkbox_192_192.png</li>
     * <li>checkbox_288_288.png</li>
     * </ul>
     * </p>
     * <p>
     * If the matching scaled version is not found, it will automatically
     * upscale the base image.
     * </p>
     * <p>
     * Note: If you want to get the image later again you can directly use
     * <code>JFaceResources.getImage(key)</code>.
     * </p>
     *
     * @param key
     *            The key under which the resource is registered in the image
     *            registry.
     * @param url
     *            The {@link URL} of the image for initial loading.
     * @return The {@link Image} representation of an image external to
     *         NatTable.
     */
    public static Image getImageByURL(String key, URL url) {
        Image image = JFaceResources.getImage(key);
        if (image == null) {
            if (needScaling()) {
                // modify url to contain scaling information in filename
                // create the matching URL for the scaled image
                String urlString = url.toString();
                int extIndex = urlString.lastIndexOf('.');
                String ext = urlString.substring(extIndex, urlString.length());
                String base = urlString.substring(0, extIndex);

                // check if there is a upscaled image available
                try {
                    URL scaleURL = new URL(base + getScalingImageSuffix() + ext);
                    URLConnection con = scaleURL.openConnection();
                    con.connect();
                    // as the connection could be established, the file exists
                    // this check is working in plain SWT aswell as in the OSGi
                    // context
                    JFaceResources.getImageRegistry().put(key, ImageDescriptor.createFromURL(scaleURL));
                } catch (IOException e) {
                    // if there is no upscaled image available, we upscale
                    // ourself
                    ImageData imageData = ImageDescriptor.createFromURL(url).getImageData();
                    imageData = imageData.scaledTo(
                            convertHorizontalPixelToDpi(imageData.width),
                            convertVerticalPixelToDpi(imageData.height));
                    JFaceResources.getImageRegistry().put(key, new Image(Display.getDefault(), imageData));
                }
            }
            else {
                JFaceResources.getImageRegistry().put(key, ImageDescriptor.createFromURL(url));
            }
            image = JFaceResources.getImage(key);
        }
        return image;
    }

    public static URL getScaledImageURL(URL url) {
        if (needScaling()) {
            // modify url to contain scaling information in filename
            // create the matching URL for the scaled image
            String urlString = url.toString();
            int extIndex = urlString.lastIndexOf('.');
            String ext = urlString.substring(extIndex, urlString.length());
            String base = urlString.substring(0, extIndex);

            // check if there is a upscaled image available
            try {
                URL scaleURL = new URL(base + getScalingImageSuffix() + ext);
                URLConnection con = scaleURL.openConnection();
                con.connect();
                // as the connection could be established, the file exists
                // this check is working in plain SWT aswell as in the OSGi
                // context
                return scaleURL;
            } catch (IOException e) {
                // do nothing, there is no upscaled image available, so we
                // simply use the given URL
            }
        }
        // scaling is not necessary, so just return the given URL
        return url;
    }

    /**
     * Returns the {@link Image} representation of a NatTable internal image
     * resource.
     * <p>
     * For upscaling this method checks whether there is a upscaled version of
     * the image available, otherwise it will upscale the existing image and
     * store that in the registry for further use.
     * </p>
     *
     * @param imageName
     *            The filename of the image (without extension).
     * @return The {@link Image} representation of the internal NatTable image
     *         resource or <code>null</code> if there is no image found for the
     *         given name at the internal image resource location.
     */
    public static Image getImage(String imageName) {
        Image image = JFaceResources.getImage(imageName);
        if (image == null) {
            URL imageUrl = getInternalImageUrl(imageName);
            if (imageUrl != null) {
                ImageDescriptor imageDescriptor = ImageDescriptor.createFromURL(imageUrl);

                if (needScaling() && !imageUrl.getFile().contains(getScalingImageSuffix())) {
                    // we need to upscale the image but we have no scaled
                    // version, therefore we manually perform an upscale
                    // it won't look nice but at least it is upscaled
                    ImageData imageData = imageDescriptor.getImageData();
                    imageData = imageData.scaledTo(
                            convertHorizontalPixelToDpi(imageData.width),
                            convertVerticalPixelToDpi(imageData.height));
                    JFaceResources.getImageRegistry().put(imageName, new Image(Display.getDefault(), imageData));
                }
                else {
                    JFaceResources.getImageRegistry().put(imageName, imageDescriptor.createImage());
                }

                image = JFaceResources.getImage(imageName);
            }
        }
        return image;
    }

    /**
     * Returns the {@link ImageDescriptor} for a NatTable internal image
     * resource.
     *
     * @param imageName
     *            The filename of the image (without extension).
     * @return The {@link ImageDescriptor} of the internal NatTable image
     *         resource or <code>null</code> if there is no image found for the
     *         given name at the internal image resource location.
     */
    public static ImageDescriptor getImageDescriptor(String imageName) {
        ImageDescriptor imageDescriptor = null;
        URL imageUrl = getInternalImageUrl(imageName);
        if (imageUrl != null) {
            imageDescriptor = ImageDescriptor.createFromURL(imageUrl);
        }
        return imageDescriptor;
    }

    /**
     * Searches for the image with the given filename in the NatTable internal
     * image resource folder with file extensions <i>.png</i> and <i>.gif</i>.
     *
     * @param imageName
     *            The filename of the image (without extension)
     * @return The URL of the internal NatTable image or <code>null</code> if
     *         there is no image found for the given name at the internal image
     *         resource location.
     */
    public static URL getInternalImageUrl(String imageName) {
        for (String dir : IMAGE_DIRS) {
            for (String ext : IMAGE_EXTENSIONS) {
                // TODO remove direct scaling information addition
                // add search for scaled image
                // e.g. imageName = checkbox -->
                // org/eclipse/nebula/widgets/nattable/images/checkbox_128_128.png
                URL url = null;
                if (needScaling()) {
                    url = GUIHelper.class.getClassLoader().getResource(
                            dir + imageName + getScalingImageSuffix() + ext);
                }

                // no scaling needed or no already scaled image found
                // search for the image without scaling extension
                if (url == null) {
                    url = GUIHelper.class.getClassLoader().getResource(dir + imageName + ext);
                }

                if (url != null) {
                    return url;
                }
            }
        }

        return null;
    }

    /**
     * <b>WARNING: DO NOT USE THIS METHOD AS IT IS MIGHT CAUSE RESOURCE HANDLING
     * ISSUES!!!<b/>
     *
     * @deprecated This method does not work correctly since it uses
     *             {@link ImageData#toString()}
     */
    @Deprecated
    public static Image getImage(ImageData data) {
        if (JFaceResources.getImage(data.toString()) == null) {
            JFaceResources.getImageRegistry().put(data.toString(), ImageDescriptor.createFromImageData(data));
        }
        return JFaceResources.getImage(data.toString());
    }

    // Sequence

    private static final AtomicLong atomicLong = new AtomicLong(0);

    public static String getSequenceNumber() {
        long id = atomicLong.addAndGet(1);
        return String.valueOf(id);
    }

    /**
     * Blend the two colour values returning a value that is halfway between
     * them.
     *
     * @param val1
     *            the first value
     * @param val2
     *            the second value
     * @return the blended colour
     */
    public static RGB blend(final RGB val1, final RGB val2) {
        final int red = blend(val1.red, val2.red);
        final int green = blend(val1.green, val2.green);
        final int blue = blend(val1.blue, val2.blue);
        return new RGB(red, green, blue);
    }

    /**
     * Blend the two colour values returning a value that is halfway between
     * them.
     *
     * @param temp1
     *            the first value
     * @param temp2
     *            the second value
     * @return the blended int value
     */
    private static int blend(final int temp1, final int temp2) {
        return (Math.abs(temp1 - temp2) / 2) + Math.min(temp1, temp2);
    }

    // DPI scaling

    private static float[] dpiFactor = new float[] { 1.0f, 1.25f, 1.33f, 1.5f, 2.0f, 3.0f };

    /**
     * Returns the factor for scaling calculations of pixels regarding the DPI.
     *
     * @param dpi
     *            The DPI for which the factor is requested.
     * @return The factor for dpi scaling calculations.
     */
    public static float getDpiFactor(int dpi) {
        float factor = 1.0f;
        switch (dpi) {
            case 96:
                factor = dpiFactor[0];
                break;
            case 120:
                factor = dpiFactor[1];
                break;
            case 128:
                factor = dpiFactor[2];
                break;
            case 144:
                factor = dpiFactor[3];
                break;
            case 192:
                factor = dpiFactor[4];
                break;
            case 288:
                factor = dpiFactor[5];
                break;
        }
        return factor;
    }

    /**
     * @return <code>true</code> if either the horizontal or the vertical DPI
     *         value is bigger than 96.
     */
    public static boolean needScaling() {
        return (getDpiX() > 96 || getDpiY() > 96);
    }

    /**
     * @return The horizontal dots per inch of the default display.
     */
    public static int getDpiX() {
        return Display.getDefault().getDPI().x;
    }

    /**
     * @return The vertical dots per inch of the default display.
     */
    public static int getDpiY() {
        return Display.getDefault().getDPI().y;
    }

    /**
     * @return The suffix that is used to mark an image as upscaled image.
     */
    public static String getScalingImageSuffix() {
        return "_" + getDpiX() + "_" + getDpiY(); //$NON-NLS-1$ //$NON-NLS-2$
    }

    /**
     * Converts the given amount of pixels to a DPI scaled value using the
     * factor for the horizontal DPI value.
     *
     * @param pixel
     *            the amount of pixels to convert.
     * @return The converted pixels.
     */
    public static int convertHorizontalPixelToDpi(int pixel) {
        return Float.valueOf(pixel * getDpiFactor(getDpiX())).intValue();
    }

    /**
     * Converts the given DPI scaled value to a pixel value using the factor for
     * the horizontal DPI.
     *
     * @param dpi
     *            the DPI value to convert.
     * @return The pixel value related to the given DPI
     */
    public static int convertHorizontalDpiToPixel(int dpi) {
        return Float.valueOf(dpi / getDpiFactor(getDpiY())).intValue();
    }

    /**
     * Converts the given amount of pixels to a DPI scaled value using the
     * factor for the vertical DPI.
     *
     * @param pixel
     *            the amount of pixels to convert.
     * @return The converted pixels.
     */
    public static int convertVerticalPixelToDpi(int pixel) {
        return Float.valueOf(pixel * getDpiFactor(getDpiX())).intValue();
    }

    /**
     * Converts the given DPI scaled value to a pixel value using the factor for
     * the vertical DPI.
     *
     * @param dpi
     *            the DPI value to convert.
     * @return The pixel value related to the given DPI
     */
    public static int convertVerticalDpiToPixel(int dpi) {
        return Float.valueOf(dpi / getDpiFactor(getDpiY())).intValue();
    }

}