/*
 *  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.
 */
/**
 * @author Oleg V. Khaschansky
 * @version $Revision$
 */

package java.awt;

import java.awt.color.ColorSpace;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.ColorModel;
import java.awt.image.DataBufferInt;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.io.Serializable;
import java.util.Arrays;

import org.apache.harmony.awt.internal.nls.Messages;

/**
 * The Color class defines colors in the default sRGB color space or in the
 * specified ColorSpace. Every Color contains alpha value. The alpha value
 * defines the transparency of a color and can be represented by a float value
 * in the range 0.0 - 1.0 or 0 - 255.
 * 
 * @since Android 1.0
 */
public class Color implements Paint, Serializable {

    /**
     * The Constant serialVersionUID.
     */
    private static final long serialVersionUID = 118526816881161077L;

    /*
     * The values of the following colors are based on 1.5 release behavior
     * which can be revealed using the following or similar code: Color c =
     * Color.white; System.out.println(c);
     */

    /**
     * The color white.
     */
    public static final Color white = new Color(255, 255, 255);

    /**
     * The color white.
     */
    public static final Color WHITE = white;

    /**
     * The color light gray.
     */
    public static final Color lightGray = new Color(192, 192, 192);

    /**
     * The color light gray.
     */
    public static final Color LIGHT_GRAY = lightGray;

    /**
     * The color gray.
     */
    public static final Color gray = new Color(128, 128, 128);

    /**
     * The color gray.
     */
    public static final Color GRAY = gray;

    /**
     * The color dark gray.
     */
    public static final Color darkGray = new Color(64, 64, 64);

    /**
     * The color dark gray.
     */
    public static final Color DARK_GRAY = darkGray;

    /**
     * The color black.
     */
    public static final Color black = new Color(0, 0, 0);

    /**
     * The color black.
     */
    public static final Color BLACK = black;

    /**
     * The color red.
     */
    public static final Color red = new Color(255, 0, 0);

    /**
     * The color red.
     */
    public static final Color RED = red;

    /**
     * The color pink.
     */
    public static final Color pink = new Color(255, 175, 175);

    /**
     * The color pink.
     */
    public static final Color PINK = pink;

    /**
     * The color orange.
     */
    public static final Color orange = new Color(255, 200, 0);

    /**
     * The color orange.
     */
    public static final Color ORANGE = orange;

    /**
     * The color yellow.
     */
    public static final Color yellow = new Color(255, 255, 0);

    /**
     * The color yellow.
     */
    public static final Color YELLOW = yellow;

    /**
     * The color green.
     */
    public static final Color green = new Color(0, 255, 0);

    /**
     * The color green.
     */
    public static final Color GREEN = green;

    /**
     * The color magenta.
     */
    public static final Color magenta = new Color(255, 0, 255);

    /**
     * The color magenta.
     */
    public static final Color MAGENTA = magenta;

    /**
     * The color cyan.
     */
    public static final Color cyan = new Color(0, 255, 255);

    /**
     * The color cyan.
     */
    public static final Color CYAN = cyan;

    /**
     * The color blue.
     */
    public static final Color blue = new Color(0, 0, 255);

    /**
     * The color blue.
     */
    public static final Color BLUE = blue;

    /**
     * integer RGB value.
     */
    int value;

    /**
     * Float sRGB value.
     */
    private float[] frgbvalue;

    /**
     * Color in an arbitrary color space with <code>float</code> components. If
     * null, other value should be used.
     */
    private float fvalue[];

    /**
     * Float alpha value. If frgbvalue is null, this is not valid data.
     */
    private float falpha;

    /**
     * The color's color space if applicable.
     */
    private ColorSpace cs;

    /*
     * The value of the SCALE_FACTOR is based on 1.5 release behavior which can
     * be revealed using the following code: Color c = new Color(100, 100, 100);
     * Color bc = c.brighter(); System.out.println("Brighter factor: " +
     * ((float)c.getRed())/((float)bc.getRed())); Color dc = c.darker();
     * System.out.println("Darker factor: " +
     * ((float)dc.getRed())/((float)c.getRed())); The result is the same for
     * brighter and darker methods, so we need only one scale factor for both.
     */
    /**
     * The Constant SCALE_FACTOR.
     */
    private static final double SCALE_FACTOR = 0.7;

    /**
     * The Constant MIN_SCALABLE.
     */
    private static final int MIN_SCALABLE = 3; // should increase when

    // multiplied by SCALE_FACTOR

    /**
     * The current paint context.
     */
    transient private PaintContext currentPaintContext;

    /**
     * Creates a color in the specified ColorSpace, the specified color
     * components and the specified alpha.
     * 
     * @param cspace
     *            the ColorSpace to be used to define the components.
     * @param components
     *            the components.
     * @param alpha
     *            the alpha.
     */
    public Color(ColorSpace cspace, float[] components, float alpha) {
        int nComps = cspace.getNumComponents();
        float comp;
        fvalue = new float[nComps];

        for (int i = 0; i < nComps; i++) {
            comp = components[i];
            if (comp < 0.0f || comp > 1.0f) {
                // awt.107=Color parameter outside of expected range: component
                // {0}.
                throw new IllegalArgumentException(Messages.getString("awt.107", i)); //$NON-NLS-1$
            }
            fvalue[i] = components[i];
        }

        if (alpha < 0.0f || alpha > 1.0f) {
            // awt.108=Alpha value outside of expected range.
            throw new IllegalArgumentException(Messages.getString("awt.108")); //$NON-NLS-1$
        }
        falpha = alpha;

        cs = cspace;

        frgbvalue = cs.toRGB(fvalue);

        value = ((int)(frgbvalue[2] * 255 + 0.5)) | (((int)(frgbvalue[1] * 255 + 0.5)) << 8)
                | (((int)(frgbvalue[0] * 255 + 0.5)) << 16) | (((int)(falpha * 255 + 0.5)) << 24);
    }

    /**
     * Instantiates a new sRGB color with the specified combined RGBA value
     * consisting of the alpha component in bits 24-31, the red component in
     * bits 16-23, the green component in bits 8-15, and the blue component in
     * bits 0-7. If the hasalpha argument is false, the alpha has default value
     * - 255.
     * 
     * @param rgba
     *            the RGBA components.
     * @param hasAlpha
     *            the alpha parameter is true if alpha bits are valid, false
     *            otherwise.
     */
    public Color(int rgba, boolean hasAlpha) {
        if (!hasAlpha) {
            value = rgba | 0xFF000000;
        } else {
            value = rgba;
        }
    }

    /**
     * Instantiates a new color with the specified red, green, blue and alpha
     * components.
     * 
     * @param r
     *            the red component.
     * @param g
     *            the green component.
     * @param b
     *            the blue component.
     * @param a
     *            the alpha component.
     */
    public Color(int r, int g, int b, int a) {
        if ((r & 0xFF) != r || (g & 0xFF) != g || (b & 0xFF) != b || (a & 0xFF) != a) {
            // awt.109=Color parameter outside of expected range.
            throw new IllegalArgumentException(Messages.getString("awt.109")); //$NON-NLS-1$
        }
        value = b | (g << 8) | (r << 16) | (a << 24);
    }

    /**
     * Instantiates a new opaque sRGB color with the specified red, green, and
     * blue values. The Alpha component is set to the default - 1.0.
     * 
     * @param r
     *            the red component.
     * @param g
     *            the green component.
     * @param b
     *            the blue component.
     */
    public Color(int r, int g, int b) {
        if ((r & 0xFF) != r || (g & 0xFF) != g || (b & 0xFF) != b) {
            // awt.109=Color parameter outside of expected range.
            throw new IllegalArgumentException(Messages.getString("awt.109")); //$NON-NLS-1$
        }
        // 0xFF for alpha channel
        value = b | (g << 8) | (r << 16) | 0xFF000000;
    }

    /**
     * Instantiates a new sRGB color with the specified RGB value consisting of
     * the red component in bits 16-23, the green component in bits 8-15, and
     * the blue component in bits 0-7. Alpha has default value - 255.
     * 
     * @param rgb
     *            the RGB components.
     */
    public Color(int rgb) {
        value = rgb | 0xFF000000;
    }

    /**
     * Instantiates a new color with the specified red, green, blue and alpha
     * components.
     * 
     * @param r
     *            the red component.
     * @param g
     *            the green component.
     * @param b
     *            the blue component.
     * @param a
     *            the alpha component.
     */
    public Color(float r, float g, float b, float a) {
        this((int)(r * 255 + 0.5), (int)(g * 255 + 0.5), (int)(b * 255 + 0.5), (int)(a * 255 + 0.5));
        falpha = a;
        fvalue = new float[3];
        fvalue[0] = r;
        fvalue[1] = g;
        fvalue[2] = b;
        frgbvalue = fvalue;
    }

    /**
     * Instantiates a new color with the specified red, green, and blue
     * components and default alpha value - 1.0.
     * 
     * @param r
     *            the red component.
     * @param g
     *            the green component.
     * @param b
     *            the blue component.
     */
    public Color(float r, float g, float b) {
        this(r, g, b, 1.0f);
    }

    public PaintContext createContext(ColorModel cm, Rectangle r, Rectangle2D r2d,
            AffineTransform xform, RenderingHints rhs) {
        if (currentPaintContext != null) {
            return currentPaintContext;
        }
        currentPaintContext = new Color.ColorPaintContext(value);
        return currentPaintContext;
    }

    /**
     * Returns a string representation of the Color object.
     * 
     * @return the string representation of the Color object.
     */
    @Override
    public String toString() {
        /*
         * The format of the string is based on 1.5 release behavior which can
         * be revealed using the following code: Color c = new Color(1, 2, 3);
         * System.out.println(c);
         */

        return getClass().getName() + "[r=" + getRed() + //$NON-NLS-1$
                ",g=" + getGreen() + //$NON-NLS-1$
                ",b=" + getBlue() + //$NON-NLS-1$
                "]"; //$NON-NLS-1$
    }

    /**
     * Compares the specified Object to the Color.
     * 
     * @param obj
     *            the Object to be compared.
     * @return true, if the specified Object is a Color whose value is equal to
     *         this Color, false otherwise.
     */
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Color) {
            return ((Color)obj).value == this.value;
        }
        return false;
    }

    /**
     * Returns a float array containing the color and alpha components of the
     * Color in the specified ColorSpace.
     * 
     * @param colorSpace
     *            the specified ColorSpace.
     * @param components
     *            the results of this method will be written to this float
     *            array. If null, a float array will be created.
     * @return the color and alpha components in a float array.
     */
    public float[] getComponents(ColorSpace colorSpace, float[] components) {
        int nComps = colorSpace.getNumComponents();
        if (components == null) {
            components = new float[nComps + 1];
        }

        getColorComponents(colorSpace, components);

        if (frgbvalue != null) {
            components[nComps] = falpha;
        } else {
            components[nComps] = getAlpha() / 255f;
        }

        return components;
    }

    /**
     * Returns a float array containing the color components of the Color in the
     * specified ColorSpace.
     * 
     * @param colorSpace
     *            the specified ColorSpace.
     * @param components
     *            the results of this method will be written to this float
     *            array. If null, a float array will be created.
     * @return the color components in a float array.
     */
    public float[] getColorComponents(ColorSpace colorSpace, float[] components) {
        float[] cieXYZComponents = getColorSpace().toCIEXYZ(getColorComponents(null));
        float[] csComponents = colorSpace.fromCIEXYZ(cieXYZComponents);

        if (components == null) {
            return csComponents;
        }

        for (int i = 0; i < csComponents.length; i++) {
            components[i] = csComponents[i];
        }

        return components;
    }

    /**
     * Gets the ColorSpace of this Color.
     * 
     * @return the ColorSpace object.
     */
    public ColorSpace getColorSpace() {
        if (cs == null) {
            cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
        }

        return cs;
    }

    /**
     * Creates a new Color which is a darker than this Color according to a
     * fixed scale factor.
     * 
     * @return the darker Color.
     */
    public Color darker() {
        return new Color((int)(getRed() * SCALE_FACTOR), (int)(getGreen() * SCALE_FACTOR),
                (int)(getBlue() * SCALE_FACTOR));
    }

    /**
     * Creates a new Color which is a brighter than this Color.
     * 
     * @return the brighter Color.
     */
    public Color brighter() {

        int r = getRed();
        int b = getBlue();
        int g = getGreen();

        if (r == 0 && b == 0 && g == 0) {
            return new Color(MIN_SCALABLE, MIN_SCALABLE, MIN_SCALABLE);
        }

        if (r < MIN_SCALABLE && r != 0) {
            r = MIN_SCALABLE;
        } else {
            r = (int)(r / SCALE_FACTOR);
            r = (r > 255) ? 255 : r;
        }

        if (b < MIN_SCALABLE && b != 0) {
            b = MIN_SCALABLE;
        } else {
            b = (int)(b / SCALE_FACTOR);
            b = (b > 255) ? 255 : b;
        }

        if (g < MIN_SCALABLE && g != 0) {
            g = MIN_SCALABLE;
        } else {
            g = (int)(g / SCALE_FACTOR);
            g = (g > 255) ? 255 : g;
        }

        return new Color(r, g, b);
    }

    /**
     * Returns a float array containing the color and alpha components of the
     * Color in the default sRGB color space.
     * 
     * @param components
     *            the results of this method will be written to this float
     *            array. A new float array will be created if this argument is
     *            null.
     * @return the RGB color and alpha components in a float array.
     */
    public float[] getRGBComponents(float[] components) {
        if (components == null) {
            components = new float[4];
        }

        if (frgbvalue != null) {
            components[3] = falpha;
        } else {
            components[3] = getAlpha() / 255f;
        }

        getRGBColorComponents(components);

        return components;
    }

    /**
     * Returns a float array containing the color components of the Color in the
     * default sRGB color space.
     * 
     * @param components
     *            the results of this method will be written to this float
     *            array. A new float array will be created if this argument is
     *            null.
     * @return the RGB color components in a float array.
     */
    public float[] getRGBColorComponents(float[] components) {
        if (components == null) {
            components = new float[3];
        }

        if (frgbvalue != null) {
            components[2] = frgbvalue[2];
            components[1] = frgbvalue[1];
            components[0] = frgbvalue[0];
        } else {
            components[2] = getBlue() / 255f;
            components[1] = getGreen() / 255f;
            components[0] = getRed() / 255f;
        }

        return components;
    }

    /**
     * Returns a float array which contains the color and alpha components of
     * the Color in the ColorSpace of the Color.
     * 
     * @param components
     *            the results of this method will be written to this float
     *            array. A new float array will be created if this argument is
     *            null.
     * @return the color and alpha components in a float array.
     */
    public float[] getComponents(float[] components) {
        if (fvalue == null) {
            return getRGBComponents(components);
        }

        int nColorComps = fvalue.length;

        if (components == null) {
            components = new float[nColorComps + 1];
        }

        getColorComponents(components);

        components[nColorComps] = falpha;

        return components;
    }

    /**
     * Returns a float array which contains the color components of the Color in
     * the ColorSpace of the Color.
     * 
     * @param components
     *            the results of this method will be written to this float
     *            array. A new float array will be created if this argument is
     *            null.
     * @return the color components in a float array.
     */
    public float[] getColorComponents(float[] components) {
        if (fvalue == null) {
            return getRGBColorComponents(components);
        }

        if (components == null) {
            components = new float[fvalue.length];
        }

        for (int i = 0; i < fvalue.length; i++) {
            components[i] = fvalue[i];
        }

        return components;
    }

    /**
     * Returns a hash code of this Color object.
     * 
     * @return a hash code of this Color object.
     */
    @Override
    public int hashCode() {
        return value;
    }

    public int getTransparency() {
        switch (getAlpha()) {
            case 0xff:
                return Transparency.OPAQUE;
            case 0:
                return Transparency.BITMASK;
            default:
                return Transparency.TRANSLUCENT;
        }
    }

    /**
     * Gets the red component of the Color in the range 0-255.
     * 
     * @return the red component of the Color.
     */
    public int getRed() {
        return (value >> 16) & 0xFF;
    }

    /**
     * Gets the RGB value that represents the color in the default sRGB
     * ColorModel.
     * 
     * @return the RGB color value in the default sRGB ColorModel.
     */
    public int getRGB() {
        return value;
    }

    /**
     * Gets the green component of the Color in the range 0-255.
     * 
     * @return the green component of the Color.
     */
    public int getGreen() {
        return (value >> 8) & 0xFF;
    }

    /**
     * Gets the blue component of the Color in the range 0-255.
     * 
     * @return the blue component of the Color.
     */
    public int getBlue() {
        return value & 0xFF;
    }

    /**
     * Gets the alpha component of the Color in the range 0-255.
     * 
     * @return the alpha component of the Color.
     */
    public int getAlpha() {
        return (value >> 24) & 0xFF;
    }

    /**
     * Gets the Color from the specified string, or returns the Color specified
     * by the second parameter.
     * 
     * @param nm
     *            the specified string.
     * @param def
     *            the default Color.
     * @return the color from the specified string, or the Color specified by
     *         the second parameter.
     */
    public static Color getColor(String nm, Color def) {
        Integer integer = Integer.getInteger(nm);

        if (integer == null) {
            return def;
        }

        return new Color(integer.intValue());
    }

    /**
     * Gets the Color from the specified string, or returns the Color converted
     * from the second parameter.
     * 
     * @param nm
     *            the specified string.
     * @param def
     *            the default Color.
     * @return the color from the specified string, or the Color converted from
     *         the second parameter.
     */
    public static Color getColor(String nm, int def) {
        Integer integer = Integer.getInteger(nm);

        if (integer == null) {
            return new Color(def);
        }

        return new Color(integer.intValue());
    }

    /**
     * Gets the Color from the specified String.
     * 
     * @param nm
     *            the specified string.
     * @return the Color object, or null.
     */
    public static Color getColor(String nm) {
        Integer integer = Integer.getInteger(nm);

        if (integer == null) {
            return null;
        }

        return new Color(integer.intValue());
    }

    /**
     * Decodes a String to an integer and returns the specified opaque Color.
     * 
     * @param nm
     *            the String which represents an opaque color as a 24-bit
     *            integer.
     * @return the Color object from the given String.
     * @throws NumberFormatException
     *             if the specified string can not be converted to an integer.
     */
    public static Color decode(String nm) throws NumberFormatException {
        Integer integer = Integer.decode(nm);
        return new Color(integer.intValue());
    }

    /**
     * Gets a Color object using the specified values of the HSB color model.
     * 
     * @param h
     *            the hue component of the Color.
     * @param s
     *            the saturation of the Color.
     * @param b
     *            the brightness of the Color.
     * @return a color object with the specified hue, saturation and brightness
     *         values.
     */
    public static Color getHSBColor(float h, float s, float b) {
        return new Color(HSBtoRGB(h, s, b));
    }

    /**
     * Converts the Color specified by the RGB model to an equivalent color in
     * the HSB model.
     * 
     * @param r
     *            the red component.
     * @param g
     *            the green component.
     * @param b
     *            the blue component.
     * @param hsbvals
     *            the array of result hue, saturation, brightness values or
     *            null.
     * @return the float array of hue, saturation, brightness values.
     */
    public static float[] RGBtoHSB(int r, int g, int b, float[] hsbvals) {
        if (hsbvals == null) {
            hsbvals = new float[3];
        }

        int V = Math.max(b, Math.max(r, g));
        int temp = Math.min(b, Math.min(r, g));

        float H, S, B;

        B = V / 255.f;

        if (V == temp) {
            H = S = 0;
        } else {
            S = (V - temp) / ((float)V);

            float Cr = (V - r) / (float)(V - temp);
            float Cg = (V - g) / (float)(V - temp);
            float Cb = (V - b) / (float)(V - temp);

            if (r == V) {
                H = Cb - Cg;
            } else if (g == V) {
                H = 2 + Cr - Cb;
            } else {
                H = 4 + Cg - Cr;
            }

            H /= 6.f;
            if (H < 0) {
                H++;
            }
        }

        hsbvals[0] = H;
        hsbvals[1] = S;
        hsbvals[2] = B;

        return hsbvals;
    }

    /**
     * Converts the Color specified by the HSB model to an equivalent color in
     * the default RGB model.
     * 
     * @param hue
     *            the hue component of the Color.
     * @param saturation
     *            the saturation of the Color.
     * @param brightness
     *            the brightness of the Color.
     * @return the RGB value of the color with the specified hue, saturation and
     *         brightness.
     */
    public static int HSBtoRGB(float hue, float saturation, float brightness) {
        float fr, fg, fb;

        if (saturation == 0) {
            fr = fg = fb = brightness;
        } else {
            float H = (hue - (float)Math.floor(hue)) * 6;
            int I = (int)Math.floor(H);
            float F = H - I;
            float M = brightness * (1 - saturation);
            float N = brightness * (1 - saturation * F);
            float K = brightness * (1 - saturation * (1 - F));

            switch (I) {
                case 0:
                    fr = brightness;
                    fg = K;
                    fb = M;
                    break;
                case 1:
                    fr = N;
                    fg = brightness;
                    fb = M;
                    break;
                case 2:
                    fr = M;
                    fg = brightness;
                    fb = K;
                    break;
                case 3:
                    fr = M;
                    fg = N;
                    fb = brightness;
                    break;
                case 4:
                    fr = K;
                    fg = M;
                    fb = brightness;
                    break;
                case 5:
                    fr = brightness;
                    fg = M;
                    fb = N;
                    break;
                default:
                    fr = fb = fg = 0; // impossible, to supress compiler error
            }
        }

        int r = (int)(fr * 255. + 0.5);
        int g = (int)(fg * 255. + 0.5);
        int b = (int)(fb * 255. + 0.5);

        return (r << 16) | (g << 8) | b | 0xFF000000;
    }

    /**
     * The Class ColorPaintContext.
     */
    class ColorPaintContext implements PaintContext {

        /**
         * The RGB value.
         */
        int rgbValue;

        /**
         * The saved raster.
         */
        WritableRaster savedRaster = null;

        /**
         * Instantiates a new color paint context.
         * 
         * @param rgb
         *            the RGB value.
         */
        protected ColorPaintContext(int rgb) {
            rgbValue = rgb;
        }

        public void dispose() {
            savedRaster = null;
        }

        public ColorModel getColorModel() {
            return ColorModel.getRGBdefault();
        }

        public Raster getRaster(int x, int y, int w, int h) {
            if (savedRaster == null || w != savedRaster.getWidth() || h != savedRaster.getHeight()) {
                savedRaster = getColorModel().createCompatibleWritableRaster(w, h);

                // Suppose we have here simple INT/RGB color/sample model
                DataBufferInt intBuffer = (DataBufferInt)savedRaster.getDataBuffer();
                int rgbValues[] = intBuffer.getData();
                int rgbFillValue = rgbValue;
                Arrays.fill(rgbValues, rgbFillValue);
            }

            return savedRaster;
        }
    }
}