package local.flpaint.colors {

    import local.flpaint.colors.RGB;
    import local.flpaint.colors.HSB;

    public class Convert {

        public function Convert() {} // Classe statique

        public static function rgbToHex (rgbObject:RGB):uint {
            // Raccourcis, séparation des couleurs de l'objet
            var red:uint = rgbObject.redValue,
            green:uint = rgbObject.greenValue,
            blue:uint = rgbObject.blueValue;

            // S'assure que les arguments restent dans le bon interval
            red = Math.max(0, Math.min(255, red));
            green = Math.max(0, Math.min(255, green));
            blue = Math.max(0, Math.min(255, blue));

            return (red << 16) | (green << 8) | blue;
        }

        public static function hexToRgb (hexValue:uint):RGB {
            // S'assure que l'argument reste dans le bon interval
            hexValue = Math.max(0x000000, Math.min(0xFFFFFF, hexValue));

            // Créé un nouvel objet RGB à partir de la valeur hexadécimale
            return new RGB((hexValue >> 16) & 0xFF, (hexValue >> 8) & 0xFF, hexValue & 0x0000FF);
        }

        public static function hsbToRgb (hsbObject:HSB):RGB {
            // Raccourcis, permet de pouvoir manipuler les valeurs en tant que Numbers pour les calculs
            var h:Number = hsbObject.hueValue, s:Number = hsbObject.saturationValue, v:Number = hsbObject.brightnessValue;

            // Variables utilisées afin d'assigner les nouvelles valeurs RGB
            var i:Number, f:Number, p:Number, q:Number, t:Number;

            // Variables contenant les valeurs finales RGB
            var r:Number, g:Number, b:Number;

            // S'assure que les arguments restent dans le bon interval
            h = Math.max(0, Math.min(360, h));
            s = Math.max(0, Math.min(100, s));
            v = Math.max(0, Math.min(100, v));

            // La saturation et la luminosité doivent être un pourcentage exprimé entre 0 et 1 pour les calculs
            s = s / 100;
            v = v / 100;

            if (s == 0) {
                // Si la saturation est égale à 0, la couleur sera grise
                r = g = b = v;
            } else {
                h /= 60; // Définit les secteurs 0 à 5
                i = Math.floor(h);
                f = h - i; //
                p = v * (1 - s);
                q = v * (1 - s * f);
                t = v * (1 - s * (1 - f));

                // Définit les nouvelles valeurs de RGB selon le secteur de la couleur
                switch (i) {
                    case 0:
                        r = v;
                        g = t;
                        b = p;
                        break;
                    case 1:
                        r = q;
                        g = v;
                        b = p;
                        break;
                    case 2:
                        r = p;
                        g = v;
                        b = t;
                        break;
                    case 3:
                        r = p;
                        g = q;
                        b = v;
                        break;
                    case 4:
                        r = t;
                        g = p;
                        b = v;
                        break;
                    default: // case 5
                        r = v;
                        g = p;
                        b = q;
                }
            }

            return new RGB(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255));
        }

        public static function rgbToHsb (rgbObject:RGB):HSB {
            // Raccourcis, permet de pouvoir manipuler les valeurs en tant que Numbers pour les calculs
            var r:Number = rgbObject.redValue, g:Number = rgbObject.greenValue, b:Number = rgbObject.blueValue;

            // Variables contenant les valeurs finales HSB
            var h:Number, s:Number, v:Number;

            // Variables de travail (servent à calculer les nouvelles valeurs HSB)
            var max:Number, min:Number, delta:Number;

            // Passage à une valeur entre 0 et 1
            r /= 255;
            g /= 255;
            b /= 255;

            // Calcul du maximum et du minimum parmis les valeurs RGB
            max = Math.max(r, g, b);
            min = Math.min(r, g, b);
            h = s = v = max;
            delta = max - min;
            s = (max == 0) ? 0 : delta/max; // Valeur de la saturation

            if (max == min) { // La couleur est grise
                h = 0;
            } else {
                switch (max) {
                    case r:
                        h = (g - b) / delta + ((g < b) ? 6 : 0);
                        break;
                    case g:
                        h = (b - r) / delta + 2;
                        break;
                    case b:
                        h = (r - g) / delta + 4;
                        break;
                }
                h /= 6 ; // 6 secteurs de couleur
            }

            return new HSB(Math.round(h * 360), Math.round(s * 100), Math.round(v * 100));
        }

        public static function hexToHsb (hexCode:uint):HSB {
            // Méthode raccourci pour effectuer une conversion
            return Convert.rgbToHsb(Convert.hexToRgb(hexCode));
        }

        public static function hsbToHex (hsbObject:HSB):uint {
            // Méthode raccourci pour effectuer une conversion
            return Convert.rgbToHex(Convert.hsbToRgb(hsbObject));
        }

        public static function rgbToMatrix (rgb:RGB, alpha:Number=1):ColorMatrix {
            // Vérifie que l'interval du paramètre est entre 0 et 1
            alpha = Math.max(0, Math.min(1, alpha));

            // Créé une matrice de couleur à partir des valeurs RGB
            return new ColorMatrix(new Array( rgb.redValue/255, 0, 0, 0, 0,
                                              0, rgb.greenValue/255, 0, 0, 0,
                                              0, 0, rgb.blueValue/255, 0, 0,
                                              0, 0, 0, alpha, 0 ));
        }

        public static function hexToMatrix (hexCode:uint, alpha:Number=1):ColorMatrix {
            // Vérifie que l'interval du paramètre est entre 0 et 1
            alpha = Math.max(0, Math.min(1, alpha));

            var rgb:RGB = Convert.hexToRgb(hexCode);
            return Convert.rgbToMatrix(rgb, alpha);
        }

        public static function hsbToMatrix (hsb:HSB, alpha:Number=1):ColorMatrix {
            // Vérifie que l'interval du paramètre est entre 0 et 1
            alpha = Math.max(0, Math.min(1, alpha));

            var rgb:RGB = Convert.hsbToRgb(hsb);
            return Convert.rgbToMatrix(rgb, alpha);
        }

    }

}