Color.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way
 * Copyright Raphael Stoeckli © 2026
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System;
using System.Collections.Generic;
using NanoXLSX.Exceptions;
using NanoXLSX.Interfaces;
using NanoXLSX.Themes;
 
namespace NanoXLSX.Colors
{
    public class Color : IComparable
    {
 
        #region enums
        public enum ColorType
        {
            None,
            Auto,
            Rgb,
            Indexed,
            Theme,
            System
        }
        #endregion
 
        #region properties
        public ColorType Type { get; private set; }

        public bool Auto { get; private set; }

        public SrgbColor RgbColor { get; private set; }

        public IndexedColor IndexedColor { get; private set; }

        public ThemeColor ThemeColor { get; private set; }

        public SystemColor SystemColor { get; private set; }

        public double? Tint { get; set; }

        public bool IsDefined => Type != ColorType.None;

        public IColor Value
        {
            get
            {
                switch (Type)
                {
                    case ColorType.Rgb:
                        return RgbColor;
                    case ColorType.Indexed:
                        return IndexedColor;
                    case ColorType.Theme:
                        return ThemeColor;
                    case ColorType.System:
                        return SystemColor;
                    case ColorType.Auto:
                        return AutoColor.Instance;
                    default:
                        return null;
                }
            }
        }
 
        #endregion
 
        #region constructors
        private Color() { }
        #endregion
 
        #region methods
        public string GetArgbValue()
        {
            if (Type == ColorType.Rgb)
            {
                return RgbColor.ColorValue;
            }
            else if (Type == ColorType.Indexed)
            {
                return IndexedColor.GetArgbValue();
            }
            else
            {
                return null;
            }
        }
        #endregion
 
        #region factory methods
        public static Color CreateNone()
        {
            return new Color { Type = ColorType.None };
        }

        public static Color CreateAuto()
        {
            return new Color
            {
                Type = ColorType.Auto,
                Auto = true
            };
        }

        public static Color CreateRgb(SrgbColor color)
        {
            // If null is passed, error handling is already covered by the string method
            return new Color
            {
                Type = ColorType.Rgb,
                RgbColor = color
            };
        }

        public static Color CreateRgb(string rgbValue)
        {
            // Validation is done in SrgbColor class
            return new Color
            {
                Type = ColorType.Rgb,
                RgbColor = new SrgbColor(rgbValue)
            };
        }

        public static Color CreateIndexed(IndexedColor color)
        {
            if (color == null)
            {
                throw new StyleException("An indexed color cannot be null");
            }
            return new Color
            {
                Type = ColorType.Indexed,
                IndexedColor = color
            };
        }

        public static Color CreateIndexed(IndexedColor.Value indexValue)
        {
            return new Color
            {
                Type = ColorType.Indexed,
                IndexedColor = new IndexedColor(indexValue)
            };
        }

        public static Color CreateIndexed(int index)
        {
            return new Color
            {
                Type = ColorType.Indexed,
                IndexedColor = new IndexedColor(index)
            };
        }

        public static Color CreateTheme(ThemeColor color, double? tint = null)
        {
            if (color == null)
            {
                throw new StyleException("A theme color cannot be null");
            }
            return new Color
            {
                Type = ColorType.Theme,
                ThemeColor = color,
                Tint = tint
            };
        }

        public static Color CreateTheme(Theme.ColorSchemeElement index, double? tint = null)
        {
            return new Color
            {
                Type = ColorType.Theme,
                ThemeColor = new ThemeColor(index),
                Tint = tint
            };
        }

        public static Color CreateTheme(int index, double? tint = null)
        {
            return new Color
            {
                Type = ColorType.Theme,
                ThemeColor = new ThemeColor(index),
                Tint = tint
            };
        }

        public static Color CreateSystem(SystemColor color)
        {
            if (color == null)
            {
                throw new StyleException("A system color cannot be null");
            }
            return new Color
            {
                Type = ColorType.System,
                SystemColor = color
            };
        }

        public static Color CreateSystem(SystemColor.Value systemColorValue)
        {
            return new Color
            {
                Type = ColorType.System,
                SystemColor = new SystemColor(systemColorValue)
            };
        }
 
        #endregion

        public static implicit operator Color(string rgbValue)
        {
            return CreateRgb(rgbValue);
        }

        public static implicit operator Color(int colorIndex)
        {
            return CreateIndexed(colorIndex);
        }

        public static implicit operator Color(IndexedColor.Value colorIndex)
        {
            return CreateIndexed(colorIndex);
        }

        public override string ToString()
        {
            switch (Type)
            {
                case ColorType.Rgb:
                    return "RGBColor:" + RgbColor.StringValue;
                case ColorType.Indexed:
                    return "IndexedColor:" + IndexedColor.StringValue;
                case ColorType.Theme:
                    return "ThemeColor:" + ThemeColor.StringValue;
                case ColorType.System:
                    return "SystemColor:" + SystemColor.StringValue;
                case ColorType.Auto:
                    return "Auto-Color";
                default:
                    return "Undefined Color";
            }
        }
 

        public override bool Equals(object obj)
        {
            return obj is Color color &&
                   Type == color.Type &&
                   Auto == color.Auto &&
                   EqualityComparer<SrgbColor>.Default.Equals(RgbColor, color.RgbColor) &&
                   EqualityComparer<IndexedColor>.Default.Equals(IndexedColor, color.IndexedColor) &&
                   EqualityComparer<ThemeColor>.Default.Equals(ThemeColor, color.ThemeColor) &&
                   EqualityComparer<SystemColor>.Default.Equals(SystemColor, color.SystemColor) &&
                   Tint == color.Tint &&
                   IsDefined == color.IsDefined;
        }

        public override int GetHashCode()
        {
            var hashCode = -1729664991;
            hashCode = hashCode * -1521134295 + Type.GetHashCode();
            hashCode = hashCode * -1521134295 + Auto.GetHashCode();
            hashCode = hashCode * -1521134295 + EqualityComparer<AutoColor>.Default.GetHashCode(AutoColor.Instance);
            hashCode = hashCode * -1521134295 + EqualityComparer<SrgbColor>.Default.GetHashCode(RgbColor);
            hashCode = hashCode * -1521134295 + EqualityComparer<IndexedColor>.Default.GetHashCode(IndexedColor);
            hashCode = hashCode * -1521134295 + EqualityComparer<ThemeColor>.Default.GetHashCode(ThemeColor);
            hashCode = hashCode * -1521134295 + EqualityComparer<SystemColor>.Default.GetHashCode(SystemColor);
            hashCode = hashCode * -1521134295 + Tint.GetHashCode();
            hashCode = hashCode * -1521134295 + IsDefined.GetHashCode();
            return hashCode;
        }

        public int CompareTo(object obj)
        {
            if (obj == null)
            {
                return 1;
            }
 
            if (!(obj is Color other))
            {
                throw new StyleException("The provided object to compare is not a Color");
            }
 
            // 1) Compare by color type first
            int typeCompare = Type.CompareTo(other.Type);
            if (typeCompare != 0)
            {
                return typeCompare;
            }
 
            // 2) Same type -> compare internal representation
            switch (Type)
            {
                case ColorType.None:
                    return 0;
                case ColorType.Auto:
                    return 0;
                case ColorType.Rgb:
                    return string.Compare(
                        RgbColor?.StringValue,
                        other.RgbColor?.StringValue,
                        StringComparison.OrdinalIgnoreCase);
                case ColorType.Indexed:
                    // Numeric comparison of palette index
                    return IndexedColor.ColorValue.CompareTo(other.IndexedColor.ColorValue);
                case ColorType.Theme:
                    {
                        // Numeric comparison of theme slot
                        int themeCompare = ThemeColor.ColorValue.CompareTo(other.ThemeColor.ColorValue);
                        if (themeCompare != 0)
                        {
                            return themeCompare;
                        }
                        // Same theme slot -> compare tint
                        return Nullable.Compare(Tint, other.Tint);
                    }
                case ColorType.System:
                    // Enum-based comparison -> not string-based
                    return SystemColor.ColorValue.CompareTo(other.SystemColor.ColorValue);
                default:
                    // Defensive fallback —> should normally never happen
                    return string.Compare(
                        Value?.StringValue,
                        other.Value?.StringValue,
                        StringComparison.OrdinalIgnoreCase);
            }
        }
 
    }
}