﻿using System;
using BugseePlugin.Internals;

namespace BugseePlugin.Appearance
{
    /// <summary>
    /// Default implementation of IBugseeColor
    /// </summary>
    public struct BugseeColor : IBugseeColor
    {
        private long value;

        [Flags]
        internal enum ColorType : short
        {
            Empty = 0,
            Known = 1,
            ARGB = 2,
            Named = 4,
            System = 8
        }

        internal short state;
        internal short knownColor;
        internal string name;

        /// <summary>
        /// Alpha component
        /// </summary>
        public byte A
        {
            get { return (byte)(Value >> 24); }
        }

        /// <summary>
        /// Red component
        /// </summary>
        public byte R
        {
            get { return (byte)(Value >> 16); }
        }

        /// <summary>
        /// Green component
        /// </summary>
        public byte G
        {
            get { return (byte)(Value >> 8); }
        }

        /// <summary>
        /// Blue component
        /// </summary>
        public byte B
        {
            get { return (byte)Value; }
        }

        /// <summary>
        /// Emoty color
        /// </summary>
        public static readonly BugseeColor Empty;

        /// <summary>
        /// This color name
        /// </summary>
        public string Name
        {
            get
            {
                if (IsNamedColor)
                    return KnownColors.GetName(knownColor);
                else
                    return String.Format("{0:x}", ToArgb());
            }
        }

        /// <summary>
        /// Returns true if this is a known color
        /// </summary>
        public bool IsKnownColor
        {
            get
            {
                return (state & ((short)ColorType.Known)) != 0;
            }
        }

        /// <summary>
        /// Returns true if this is the system color
        /// </summary>
        public bool IsSystemColor
        {
            get
            {
                return (state & ((short)ColorType.System)) != 0;
            }
        }

        /// <summary>
        /// Returns true if this color has predefined name (exists in a known colors)
        /// </summary>
        public bool IsNamedColor
        {
            get
            {
                return (state & (short)(ColorType.Known | ColorType.Named)) != 0;
            }
        }

        /// <summary>
        /// Returns true if this color is empty
        /// </summary>
        public bool IsEmpty
        {
            get
            {
                return state == (short)ColorType.Empty;
            }
        }

        internal long Value
        {
            get
            {
                // Optimization for known colors that were deserialized
                // from an MS serialized stream.  
                if (value == 0 && IsKnownColor)
                {
                    value = FromKnownColor((KnownColor)knownColor).ToArgb() & 0xFFFFFFFF;
                }
                return value;
            }
            set { this.value = value; }
        }

        /// <summary>
        /// Compares two BugseeColor instances
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns></returns>
        public static bool operator ==(BugseeColor left, BugseeColor right)
        {
            if (left.Value != right.Value)
                return false;
            if (left.IsNamedColor != right.IsNamedColor)
                return false;
            if (left.IsSystemColor != right.IsSystemColor)
                return false;
            if (left.IsEmpty != right.IsEmpty)
                return false;
            if (left.IsNamedColor)
            {
                // then both are named (see previous check) and so we need to compare them
                // but otherwise we don't as it kills performance (Name calls String.Format)
                if (left.Name != right.Name)
                    return false;
            }
            return true;
        }

        /// <summary>
        /// Inequality Operator
        /// </summary>
        ///
        /// <remarks>
        /// Compares two Color objects. The return value is
        /// based on the equivalence of the A,R,G,B properties 
        /// of the two colors.
        /// </remarks>

        public static bool operator !=(BugseeColor left, BugseeColor right)
        {
            return !(left == right);
        }

        /// <inheritdoc />
        public override int GetHashCode()
        {
            return (int)(Value ^ (Value >> 32));
        }

        /// <inheritdoc />
        public float GetBrightness()
        {
            byte minval = Math.Min(R, Math.Min(G, B));
            byte maxval = Math.Max(R, Math.Max(G, B));

            return (float)(maxval + minval) / 510;
        }

        /// <inheritdoc />
        public float GetSaturation()
        {
            byte minval = (byte)Math.Min(R, Math.Min(G, B));
            byte maxval = (byte)Math.Max(R, Math.Max(G, B));

            if (maxval == minval)
                return 0.0f;

            int sum = maxval + minval;
            if (sum > 255)
                sum = 510 - sum;

            return (float)(maxval - minval) / sum;
        }

        /// <inheritdoc />
        public float GetHue()
        {
            int r = R;
            int g = G;
            int b = B;
            byte minval = (byte)Math.Min(r, Math.Min(g, b));
            byte maxval = (byte)Math.Max(r, Math.Max(g, b));

            if (maxval == minval)
                return 0.0f;

            float diff = (float)(maxval - minval);
            float rnorm = (maxval - r) / diff;
            float gnorm = (maxval - g) / diff;
            float bnorm = (maxval - b) / diff;

            float hue = 0.0f;
            if (r == maxval)
                hue = 60.0f * (6.0f + bnorm - gnorm);
            if (g == maxval)
                hue = 60.0f * (2.0f + rnorm - bnorm);
            if (b == maxval)
                hue = 60.0f * (4.0f + gnorm - rnorm);
            if (hue > 360.0f)
                hue = hue - 360.0f;

            return hue;
        }

        /// <inheritdoc />
        public string ToHex()
        {
            return $"{toHtmlHex()}{A.ToString("{0:x2}")}";
        }

        /// <inheritdoc />
        public string toHtmlHex()
        {
            return $"{R.ToString("{0:x2}")}{G.ToString("{0:x2}")}{B.ToString("{0:x2}")}";
        }

        /// <inheritdoc />
        public override bool Equals(object obj)
        {
            if (!(obj is BugseeColor))
                return false;
            BugseeColor c = (BugseeColor)obj;
            return this == c;
        }

        /// <summary>
        /// Creates BugseeColor from KnownColor
        /// </summary>
        /// <param name="color"></param>
        /// <returns></returns>
        public static BugseeColor FromKnownColor(KnownColor color)
        {
            BugseeColor c;
            short n = (short)color;
            if ((n <= 0) || (n >= KnownColors.ArgbValues.Length))
            {
                // This is what it returns!
                c = FromArgb(0, 0, 0, 0);
                c.state |= (short)ColorType.Named;
            }
            else
            {
                c = new BugseeColor();
                c.state = (short)(ColorType.ARGB | ColorType.Known | ColorType.Named);
                if ((n < 27) || (n > 169))
                    c.state |= (short)ColorType.System;
                c.Value = KnownColors.ArgbValues[n];
            }
            c.knownColor = n;
            return c;
        }

        /// <summary>
        /// Creates BugseeColor from the specified name
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static BugseeColor FromName(string name)
        {
            try
            {
                KnownColor kc = (KnownColor)Enum.Parse(typeof(KnownColor), name, true);
                return FromKnownColor(kc);
            }
            catch
            {
                // This is what it returns!      
                BugseeColor d = FromArgb(0, 0, 0, 0);
                d.name = name;
                d.state |= (short)ColorType.Named;
                return d;
            }
        }

        /// <summary>
        /// Creates BugseeColor from the specified components (Alpha, Red, Green and Blue)
        /// </summary>
        /// <param name="alpha"></param>
        /// <param name="red"></param>
        /// <param name="green"></param>
        /// <param name="blue"></param>
        /// <returns></returns>
        public static BugseeColor FromArgb(int alpha, int red, int green, int blue)
        {
            CheckARGBValues(alpha, red, green, blue);

            var color = new BugseeColor();
            color.Value = (int)((uint)alpha << 24) + (red << 16) + (green << 8) + blue;

            return color;
        }

        /// <summary>
        /// Converts this BugseeColor instance to the string representation
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            if (IsEmpty)
                return "Color [Empty]";

            // Use the property here, not the field.
            if (IsNamedColor)
                return "Color [" + Name + "]";

            return String.Format("Color [A={0}, R={1}, G={2}, B={3}]", A, R, G, B);
        }

        private static void CheckARGBValues(int alpha, int red, int green, int blue)
        {
            if ((alpha > 255) || (alpha < 0))
                throw new ArgumentException($"Invalid alpha component value: {alpha}");

            CheckRGBValues(red, green, blue);
        }

        private static void CheckRGBValues(int red, int green, int blue)
        {
            if ((red > 255) || (red < 0))
                throw new ArgumentException($"Invalid red component value: {red}");
            if ((green > 255) || (green < 0))
                throw new ArgumentException($"Invalid green component value: {green}");
            if ((blue > 255) || (blue < 0))
                throw new ArgumentException($"Invalid blue component value: {blue}");
        }

        /// <inheritdoc />
        public int ToArgb()
        {
            return (int)Value;
        }

        /// <summary>
        /// Creates BugseeColor from the existing BugseeColor and provided
        /// alpha
        /// </summary>
        /// <param name="alpha"></param>
        /// <param name="baseColor"></param>
        /// <returns></returns>
        public static BugseeColor FromArgb(int alpha, BugseeColor baseColor)
        {
            return FromArgb(alpha, baseColor.R, baseColor.G, baseColor.B);
        }

        /// <summary>
        /// Creates BugseeColor from the integer all the color
        /// components (Alpha, Red, Green and Blue)
        /// </summary>
        /// <param name="argb"></param>
        /// <returns></returns>
        public static BugseeColor FromArgb(int argb)
        {
            return FromArgb((argb >> 24) & 0x0FF, (argb >> 16) & 0x0FF, (argb >> 8) & 0x0FF, argb & 0x0FF);
        }


        /// <summary>
        /// Transparent color
        /// </summary>
        public static BugseeColor Transparent
        {
            get { return FromKnownColor(KnownColor.Transparent); }
        }

        /// <summary>
        /// AliceBlue color
        /// </summary>
        public static BugseeColor AliceBlue
        {
            get { return FromKnownColor(KnownColor.AliceBlue); }
        }

        /// <summary>
        /// AntiqueWhite color
        /// </summary>
        public static BugseeColor AntiqueWhite
        {
            get { return FromKnownColor(KnownColor.AntiqueWhite); }
        }

        /// <summary>
        /// Aqua color
        /// </summary>
        public static BugseeColor Aqua
        {
            get { return FromKnownColor(KnownColor.Aqua); }
        }

        /// <summary>
        /// Aquamarine color
        /// </summary>
        public static BugseeColor Aquamarine
        {
            get { return FromKnownColor(KnownColor.Aquamarine); }
        }

        /// <summary>
        /// Azure color
        /// </summary>
        public static BugseeColor Azure
        {
            get { return FromKnownColor(KnownColor.Azure); }
        }

        /// <summary>
        /// Beige color
        /// </summary>
        public static BugseeColor Beige
        {
            get { return FromKnownColor(KnownColor.Beige); }
        }

        /// <summary>
        /// Bisque color
        /// </summary>
        public static BugseeColor Bisque
        {
            get { return FromKnownColor(KnownColor.Bisque); }
        }

        /// <summary>
        /// Black color
        /// </summary>
        public static BugseeColor Black
        {
            get { return FromKnownColor(KnownColor.Black); }
        }

        /// <summary>
        /// BlanchedAlmond color
        /// </summary>
        public static BugseeColor BlanchedAlmond
        {
            get { return FromKnownColor(KnownColor.BlanchedAlmond); }
        }

        /// <summary>
        /// Blue color
        /// </summary>
        public static BugseeColor Blue
        {
            get { return FromKnownColor(KnownColor.Blue); }
        }

        /// <summary>
        /// BlueViolet color
        /// </summary>
        public static BugseeColor BlueViolet
        {
            get { return FromKnownColor(KnownColor.BlueViolet); }
        }

        /// <summary>
        /// Brown color
        /// </summary>
        public static BugseeColor Brown
        {
            get { return FromKnownColor(KnownColor.Brown); }
        }

        /// <summary>
        /// BurlyWood color
        /// </summary>
        public static BugseeColor BurlyWood
        {
            get { return FromKnownColor(KnownColor.BurlyWood); }
        }

        /// <summary>
        /// CadetBlue color
        /// </summary>
        public static BugseeColor CadetBlue
        {
            get { return FromKnownColor(KnownColor.CadetBlue); }
        }

        /// <summary>
        /// Chartreuse color
        /// </summary>
        public static BugseeColor Chartreuse
        {
            get { return FromKnownColor(KnownColor.Chartreuse); }
        }

        /// <summary>
        /// Chocolate color
        /// </summary>
        public static BugseeColor Chocolate
        {
            get { return FromKnownColor(KnownColor.Chocolate); }
        }

        /// <summary>
        /// Coral color
        /// </summary>
        public static BugseeColor Coral
        {
            get { return FromKnownColor(KnownColor.Coral); }
        }

        /// <summary>
        /// CornflowerBlue color
        /// </summary>
        public static BugseeColor CornflowerBlue
        {
            get { return FromKnownColor(KnownColor.CornflowerBlue); }
        }

        /// <summary>
        /// Cornsilk color
        /// </summary>
        public static BugseeColor Cornsilk
        {
            get { return FromKnownColor(KnownColor.Cornsilk); }
        }

        /// <summary>
        /// Crimson color
        /// </summary>
        public static BugseeColor Crimson
        {
            get { return FromKnownColor(KnownColor.Crimson); }
        }

        /// <summary>
        /// Cyan color
        /// </summary>
        public static BugseeColor Cyan
        {
            get { return FromKnownColor(KnownColor.Cyan); }
        }

        /// <summary>
        /// DarkBlue color
        /// </summary>
        public static BugseeColor DarkBlue
        {
            get { return FromKnownColor(KnownColor.DarkBlue); }
        }

        /// <summary>
        /// DarkCyan color
        /// </summary>
        public static BugseeColor DarkCyan
        {
            get { return FromKnownColor(KnownColor.DarkCyan); }
        }

        /// <summary>
        /// DarkGoldenrod color
        /// </summary>
        public static BugseeColor DarkGoldenrod
        {
            get { return FromKnownColor(KnownColor.DarkGoldenrod); }
        }

        /// <summary>
        /// DarkGray color
        /// </summary>
        public static BugseeColor DarkGray
        {
            get { return FromKnownColor(KnownColor.DarkGray); }
        }

        /// <summary>
        /// DarkGreen color
        /// </summary>
        public static BugseeColor DarkGreen
        {
            get { return FromKnownColor(KnownColor.DarkGreen); }
        }

        /// <summary>
        /// DarkKhaki color
        /// </summary>
        public static BugseeColor DarkKhaki
        {
            get { return FromKnownColor(KnownColor.DarkKhaki); }
        }

        /// <summary>
        /// DarkMagenta color
        /// </summary>
        public static BugseeColor DarkMagenta
        {
            get { return FromKnownColor(KnownColor.DarkMagenta); }
        }

        /// <summary>
        /// DarkOliveGreen color
        /// </summary>
        public static BugseeColor DarkOliveGreen
        {
            get { return FromKnownColor(KnownColor.DarkOliveGreen); }
        }

        /// <summary>
        /// DarkOrange color
        /// </summary>
        public static BugseeColor DarkOrange
        {
            get { return FromKnownColor(KnownColor.DarkOrange); }
        }

        /// <summary>
        /// DarkOrchid color
        /// </summary>
        public static BugseeColor DarkOrchid
        {
            get { return FromKnownColor(KnownColor.DarkOrchid); }
        }

        /// <summary>
        /// DarkRed color
        /// </summary>
        public static BugseeColor DarkRed
        {
            get { return FromKnownColor(KnownColor.DarkRed); }
        }

        /// <summary>
        /// DarkSalmon color
        /// </summary>
        public static BugseeColor DarkSalmon
        {
            get { return FromKnownColor(KnownColor.DarkSalmon); }
        }

        /// <summary>
        /// DarkSeaGreen color
        /// </summary>
        public static BugseeColor DarkSeaGreen
        {
            get { return FromKnownColor(KnownColor.DarkSeaGreen); }
        }

        /// <summary>
        /// DarkSlateBlue color
        /// </summary>
        public static BugseeColor DarkSlateBlue
        {
            get { return FromKnownColor(KnownColor.DarkSlateBlue); }
        }

        /// <summary>
        /// DarkSlateGray color
        /// </summary>
        public static BugseeColor DarkSlateGray
        {
            get { return FromKnownColor(KnownColor.DarkSlateGray); }
        }

        /// <summary>
        /// DarkTurquoise color
        /// </summary>
        public static BugseeColor DarkTurquoise
        {
            get { return FromKnownColor(KnownColor.DarkTurquoise); }
        }

        /// <summary>
        /// DarkViolet color
        /// </summary>
        public static BugseeColor DarkViolet
        {
            get { return FromKnownColor(KnownColor.DarkViolet); }
        }

        /// <summary>
        /// DeepPink color
        /// </summary>
        public static BugseeColor DeepPink
        {
            get { return FromKnownColor(KnownColor.DeepPink); }
        }

        /// <summary>
        /// DeepSkyBlue color
        /// </summary>
        public static BugseeColor DeepSkyBlue
        {
            get { return FromKnownColor(KnownColor.DeepSkyBlue); }
        }

        /// <summary>
        /// DimGray color
        /// </summary>
        public static BugseeColor DimGray
        {
            get { return FromKnownColor(KnownColor.DimGray); }
        }

        /// <summary>
        /// DodgerBlue color
        /// </summary>
        public static BugseeColor DodgerBlue
        {
            get { return FromKnownColor(KnownColor.DodgerBlue); }
        }

        /// <summary>
        /// Firebrick color
        /// </summary>
        public static BugseeColor Firebrick
        {
            get { return FromKnownColor(KnownColor.Firebrick); }
        }

        /// <summary>
        /// FloralWhite color
        /// </summary>
        public static BugseeColor FloralWhite
        {
            get { return FromKnownColor(KnownColor.FloralWhite); }
        }

        /// <summary>
        /// ForestGreen color
        /// </summary>
        public static BugseeColor ForestGreen
        {
            get { return FromKnownColor(KnownColor.ForestGreen); }
        }

        /// <summary>
        /// Fuchsia color
        /// </summary>
        public static BugseeColor Fuchsia
        {
            get { return FromKnownColor(KnownColor.Fuchsia); }
        }

        /// <summary>
        /// Gainsboro color
        /// </summary>
        public static BugseeColor Gainsboro
        {
            get { return FromKnownColor(KnownColor.Gainsboro); }
        }

        /// <summary>
        /// GhostWhite color
        /// </summary>
        public static BugseeColor GhostWhite
        {
            get { return FromKnownColor(KnownColor.GhostWhite); }
        }

        /// <summary>
        /// Gold color
        /// </summary>
        public static BugseeColor Gold
        {
            get { return FromKnownColor(KnownColor.Gold); }
        }

        /// <summary>
        /// Goldenrod color
        /// </summary>
        public static BugseeColor Goldenrod
        {
            get { return FromKnownColor(KnownColor.Goldenrod); }
        }

        /// <summary>
        /// Gray color
        /// </summary>
        public static BugseeColor Gray
        {
            get { return FromKnownColor(KnownColor.Gray); }
        }

        /// <summary>
        /// Green color
        /// </summary>
        public static BugseeColor Green
        {
            get { return FromKnownColor(KnownColor.Green); }
        }

        /// <summary>
        /// GreenYellow color
        /// </summary>
        public static BugseeColor GreenYellow
        {
            get { return FromKnownColor(KnownColor.GreenYellow); }
        }

        /// <summary>
        /// Honeydew color
        /// </summary>
        public static BugseeColor Honeydew
        {
            get { return FromKnownColor(KnownColor.Honeydew); }
        }

        /// <summary>
        /// HotPink color
        /// </summary>
        public static BugseeColor HotPink
        {
            get { return FromKnownColor(KnownColor.HotPink); }
        }

        /// <summary>
        /// IndianRed color
        /// </summary>
        public static BugseeColor IndianRed
        {
            get { return FromKnownColor(KnownColor.IndianRed); }
        }

        /// <summary>
        /// Indigo color
        /// </summary>
        public static BugseeColor Indigo
        {
            get { return FromKnownColor(KnownColor.Indigo); }
        }

        /// <summary>
        /// Ivory color
        /// </summary>
        public static BugseeColor Ivory
        {
            get { return FromKnownColor(KnownColor.Ivory); }
        }

        /// <summary>
        /// Khaki color
        /// </summary>
        public static BugseeColor Khaki
        {
            get { return FromKnownColor(KnownColor.Khaki); }
        }

        /// <summary>
        /// Lavender color
        /// </summary>
        public static BugseeColor Lavender
        {
            get { return FromKnownColor(KnownColor.Lavender); }
        }

        /// <summary>
        /// LavenderBlush color
        /// </summary>
        public static BugseeColor LavenderBlush
        {
            get { return FromKnownColor(KnownColor.LavenderBlush); }
        }

        /// <summary>
        /// LawnGreen color
        /// </summary>
        public static BugseeColor LawnGreen
        {
            get { return FromKnownColor(KnownColor.LawnGreen); }
        }

        /// <summary>
        /// LemonChiffon color
        /// </summary>
        public static BugseeColor LemonChiffon
        {
            get { return FromKnownColor(KnownColor.LemonChiffon); }
        }

        /// <summary>
        /// LightBlue color
        /// </summary>
        public static BugseeColor LightBlue
        {
            get { return FromKnownColor(KnownColor.LightBlue); }
        }

        /// <summary>
        /// LightCoral color
        /// </summary>
        public static BugseeColor LightCoral
        {
            get { return FromKnownColor(KnownColor.LightCoral); }
        }

        /// <summary>
        /// LightCyan color
        /// </summary>
        public static BugseeColor LightCyan
        {
            get { return FromKnownColor(KnownColor.LightCyan); }
        }

        /// <summary>
        /// LightGoldenrodYellow color
        /// </summary>
        public static BugseeColor LightGoldenrodYellow
        {
            get { return FromKnownColor(KnownColor.LightGoldenrodYellow); }
        }

        /// <summary>
        /// LightGreen color
        /// </summary>
        public static BugseeColor LightGreen
        {
            get { return FromKnownColor(KnownColor.LightGreen); }
        }

        /// <summary>
        /// LightGray color
        /// </summary>
        public static BugseeColor LightGray
        {
            get { return FromKnownColor(KnownColor.LightGray); }
        }

        /// <summary>
        /// LightPink color
        /// </summary>
        public static BugseeColor LightPink
        {
            get { return FromKnownColor(KnownColor.LightPink); }
        }

        /// <summary>
        /// LightSalmon color
        /// </summary>
        public static BugseeColor LightSalmon
        {
            get { return FromKnownColor(KnownColor.LightSalmon); }
        }

        /// <summary>
        /// LightSeaGreen color
        /// </summary>
        public static BugseeColor LightSeaGreen
        {
            get { return FromKnownColor(KnownColor.LightSeaGreen); }
        }

        /// <summary>
        /// LightSkyBlue color
        /// </summary>
        public static BugseeColor LightSkyBlue
        {
            get { return FromKnownColor(KnownColor.LightSkyBlue); }
        }

        /// <summary>
        /// LightSlateGray color
        /// </summary>
        public static BugseeColor LightSlateGray
        {
            get { return FromKnownColor(KnownColor.LightSlateGray); }
        }

        /// <summary>
        /// LightSteelBlue color
        /// </summary>
        public static BugseeColor LightSteelBlue
        {
            get { return FromKnownColor(KnownColor.LightSteelBlue); }
        }

        /// <summary>
        /// LightYellow color
        /// </summary>
        public static BugseeColor LightYellow
        {
            get { return FromKnownColor(KnownColor.LightYellow); }
        }

        /// <summary>
        /// Lime color
        /// </summary>
        public static BugseeColor Lime
        {
            get { return FromKnownColor(KnownColor.Lime); }
        }

        /// <summary>
        /// LimeGreen color
        /// </summary>
        public static BugseeColor LimeGreen
        {
            get { return FromKnownColor(KnownColor.LimeGreen); }
        }

        /// <summary>
        /// Linen color
        /// </summary>
        public static BugseeColor Linen
        {
            get { return FromKnownColor(KnownColor.Linen); }
        }

        /// <summary>
        /// Magenta color
        /// </summary>
        public static BugseeColor Magenta
        {
            get { return FromKnownColor(KnownColor.Magenta); }
        }

        /// <summary>
        /// Maroon color
        /// </summary>
        public static BugseeColor Maroon
        {
            get { return FromKnownColor(KnownColor.Maroon); }
        }

        /// <summary>
        /// MediumAquamarine color
        /// </summary>
        public static BugseeColor MediumAquamarine
        {
            get { return FromKnownColor(KnownColor.MediumAquamarine); }
        }

        /// <summary>
        /// MediumBlue color
        /// </summary>
        public static BugseeColor MediumBlue
        {
            get { return FromKnownColor(KnownColor.MediumBlue); }
        }

        /// <summary>
        /// MediumOrchid color
        /// </summary>
        public static BugseeColor MediumOrchid
        {
            get { return FromKnownColor(KnownColor.MediumOrchid); }
        }

        /// <summary>
        /// MediumPurple color
        /// </summary>
        public static BugseeColor MediumPurple
        {
            get { return FromKnownColor(KnownColor.MediumPurple); }
        }

        /// <summary>
        /// MediumSeaGreen color
        /// </summary>
        public static BugseeColor MediumSeaGreen
        {
            get { return FromKnownColor(KnownColor.MediumSeaGreen); }
        }

        /// <summary>
        /// MediumSlateBlue color
        /// </summary>
        public static BugseeColor MediumSlateBlue
        {
            get { return FromKnownColor(KnownColor.MediumSlateBlue); }
        }

        /// <summary>
        /// MediumSpringGreen color
        /// </summary>
        public static BugseeColor MediumSpringGreen
        {
            get { return FromKnownColor(KnownColor.MediumSpringGreen); }
        }

        /// <summary>
        /// MediumTurquoise color
        /// </summary>
        public static BugseeColor MediumTurquoise
        {
            get { return FromKnownColor(KnownColor.MediumTurquoise); }
        }

        /// <summary>
        /// MediumVioletRed color
        /// </summary>
        public static BugseeColor MediumVioletRed
        {
            get { return FromKnownColor(KnownColor.MediumVioletRed); }
        }

        /// <summary>
        /// MidnightBlue color
        /// </summary>
        public static BugseeColor MidnightBlue
        {
            get { return FromKnownColor(KnownColor.MidnightBlue); }
        }

        /// <summary>
        /// MintCream color
        /// </summary>
        public static BugseeColor MintCream
        {
            get { return FromKnownColor(KnownColor.MintCream); }
        }

        /// <summary>
        /// MistyRose color
        /// </summary>
        public static BugseeColor MistyRose
        {
            get { return FromKnownColor(KnownColor.MistyRose); }
        }

        /// <summary>
        /// Moccasin color
        /// </summary>
        public static BugseeColor Moccasin
        {
            get { return FromKnownColor(KnownColor.Moccasin); }
        }

        /// <summary>
        /// NavajoWhite color
        /// </summary>
        public static BugseeColor NavajoWhite
        {
            get { return FromKnownColor(KnownColor.NavajoWhite); }
        }

        /// <summary>
        /// Navy color
        /// </summary>
        public static BugseeColor Navy
        {
            get { return FromKnownColor(KnownColor.Navy); }
        }

        /// <summary>
        /// OldLace color
        /// </summary>
        public static BugseeColor OldLace
        {
            get { return FromKnownColor(KnownColor.OldLace); }
        }

        /// <summary>
        /// Olive color
        /// </summary>
        public static BugseeColor Olive
        {
            get { return FromKnownColor(KnownColor.Olive); }
        }

        /// <summary>
        /// OliveDrab color
        /// </summary>
        public static BugseeColor OliveDrab
        {
            get { return FromKnownColor(KnownColor.OliveDrab); }
        }

        /// <summary>
        /// Orange color
        /// </summary>
        public static BugseeColor Orange
        {
            get { return FromKnownColor(KnownColor.Orange); }
        }

        /// <summary>
        /// OrangeRed color
        /// </summary>
        public static BugseeColor OrangeRed
        {
            get { return FromKnownColor(KnownColor.OrangeRed); }
        }

        /// <summary>
        /// Orchid color
        /// </summary>
        public static BugseeColor Orchid
        {
            get { return FromKnownColor(KnownColor.Orchid); }
        }

        /// <summary>
        /// PaleGoldenrod color
        /// </summary>
        public static BugseeColor PaleGoldenrod
        {
            get { return FromKnownColor(KnownColor.PaleGoldenrod); }
        }

        /// <summary>
        /// PaleGreen color
        /// </summary>
        public static BugseeColor PaleGreen
        {
            get { return FromKnownColor(KnownColor.PaleGreen); }
        }

        /// <summary>
        /// PaleTurquoise color
        /// </summary>
        public static BugseeColor PaleTurquoise
        {
            get { return FromKnownColor(KnownColor.PaleTurquoise); }
        }

        /// <summary>
        /// PaleVioletRed color
        /// </summary>
        public static BugseeColor PaleVioletRed
        {
            get { return FromKnownColor(KnownColor.PaleVioletRed); }
        }

        /// <summary>
        /// PapayaWhip color
        /// </summary>
        public static BugseeColor PapayaWhip
        {
            get { return FromKnownColor(KnownColor.PapayaWhip); }
        }

        /// <summary>
        /// PeachPuff color
        /// </summary>
        public static BugseeColor PeachPuff
        {
            get { return FromKnownColor(KnownColor.PeachPuff); }
        }

        /// <summary>
        /// Peru color
        /// </summary>
        public static BugseeColor Peru
        {
            get { return FromKnownColor(KnownColor.Peru); }
        }

        /// <summary>
        /// Pink color
        /// </summary>
        public static BugseeColor Pink
        {
            get { return FromKnownColor(KnownColor.Pink); }
        }

        /// <summary>
        /// Plum color
        /// </summary>
        public static BugseeColor Plum
        {
            get { return FromKnownColor(KnownColor.Plum); }
        }

        /// <summary>
        /// PowderBlue color
        /// </summary>
        public static BugseeColor PowderBlue
        {
            get { return FromKnownColor(KnownColor.PowderBlue); }
        }

        /// <summary>
        /// Purple color
        /// </summary>
        public static BugseeColor Purple
        {
            get { return FromKnownColor(KnownColor.Purple); }
        }

        /// <summary>
        /// Red color
        /// </summary>
        public static BugseeColor Red
        {
            get { return FromKnownColor(KnownColor.Red); }
        }

        /// <summary>
        /// RosyBrown color
        /// </summary>
        public static BugseeColor RosyBrown
        {
            get { return FromKnownColor(KnownColor.RosyBrown); }
        }

        /// <summary>
        /// RoyalBlue color
        /// </summary>
        public static BugseeColor RoyalBlue
        {
            get { return FromKnownColor(KnownColor.RoyalBlue); }
        }

        /// <summary>
        /// SaddleBrown color
        /// </summary>
        public static BugseeColor SaddleBrown
        {
            get { return FromKnownColor(KnownColor.SaddleBrown); }
        }

        /// <summary>
        /// Salmon color
        /// </summary>
        public static BugseeColor Salmon
        {
            get { return FromKnownColor(KnownColor.Salmon); }
        }

        /// <summary>
        /// SandyBrown color
        /// </summary>
        public static BugseeColor SandyBrown
        {
            get { return FromKnownColor(KnownColor.SandyBrown); }
        }

        /// <summary>
        /// SeaGreen color
        /// </summary>
        public static BugseeColor SeaGreen
        {
            get { return FromKnownColor(KnownColor.SeaGreen); }
        }

        /// <summary>
        /// SeaShell color
        /// </summary>
        public static BugseeColor SeaShell
        {
            get { return FromKnownColor(KnownColor.SeaShell); }
        }

        /// <summary>
        /// Sienna color
        /// </summary>
        public static BugseeColor Sienna
        {
            get { return FromKnownColor(KnownColor.Sienna); }
        }

        /// <summary>
        /// Silver color
        /// </summary>
        public static BugseeColor Silver
        {
            get { return FromKnownColor(KnownColor.Silver); }
        }

        /// <summary>
        /// SkyBlue color
        /// </summary>
        public static BugseeColor SkyBlue
        {
            get { return FromKnownColor(KnownColor.SkyBlue); }
        }

        /// <summary>
        /// SlateBlue color
        /// </summary>
        public static BugseeColor SlateBlue
        {
            get { return FromKnownColor(KnownColor.SlateBlue); }
        }

        /// <summary>
        /// SlateGray color
        /// </summary>
        public static BugseeColor SlateGray
        {
            get { return FromKnownColor(KnownColor.SlateGray); }
        }

        /// <summary>
        /// Snow color
        /// </summary>
        public static BugseeColor Snow
        {
            get { return FromKnownColor(KnownColor.Snow); }
        }

        /// <summary>
        /// SpringGreen color
        /// </summary>
        public static BugseeColor SpringGreen
        {
            get { return FromKnownColor(KnownColor.SpringGreen); }
        }

        /// <summary>
        /// SteelBlue color
        /// </summary>
        public static BugseeColor SteelBlue
        {
            get { return FromKnownColor(KnownColor.SteelBlue); }
        }

        /// <summary>
        /// Tan color
        /// </summary>
        public static BugseeColor Tan
        {
            get { return FromKnownColor(KnownColor.Tan); }
        }

        /// <summary>
        /// Teal color
        /// </summary>
        public static BugseeColor Teal
        {
            get { return FromKnownColor(KnownColor.Teal); }
        }

        /// <summary>
        /// Thistle color
        /// </summary>
        public static BugseeColor Thistle
        {
            get { return FromKnownColor(KnownColor.Thistle); }
        }

        /// <summary>
        /// Tomato color
        /// </summary>
        public static BugseeColor Tomato
        {
            get { return FromKnownColor(KnownColor.Tomato); }
        }

        /// <summary>
        /// Turquoise color
        /// </summary>
        public static BugseeColor Turquoise
        {
            get { return FromKnownColor(KnownColor.Turquoise); }
        }

        /// <summary>
        /// Violet color
        /// </summary>
        public static BugseeColor Violet
        {
            get { return FromKnownColor(KnownColor.Violet); }
        }

        /// <summary>
        /// Wheat color
        /// </summary>
        public static BugseeColor Wheat
        {
            get { return FromKnownColor(KnownColor.Wheat); }
        }

        /// <summary>
        /// White color
        /// </summary>
        public static BugseeColor White
        {
            get { return FromKnownColor(KnownColor.White); }
        }

        /// <summary>
        /// WhiteSmoke color
        /// </summary>
        public static BugseeColor WhiteSmoke
        {
            get { return FromKnownColor(KnownColor.WhiteSmoke); }
        }

        /// <summary>
        /// Yellow color
        /// </summary>
        public static BugseeColor Yellow
        {
            get { return FromKnownColor(KnownColor.Yellow); }
        }

        /// <summary>
        /// YellowGreen color
        /// </summary>
        public static BugseeColor YellowGreen
        {
            get { return FromKnownColor(KnownColor.YellowGreen); }
        }
    }
}
