Border.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 © 2025
 * 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.Collections.Generic;
using System.Text;
using NanoXLSX.Utils;
 
namespace NanoXLSX.Styles
{
    public class Border : AbstractStyle
    {
 
        #region constants
        public static readonly StyleValue DefaultBorderStyle = StyleValue.None;

        public static readonly string DefaultBorderColor = "";
 
        #endregion
 
        #region privateFields
        private string diagonalColor;
        private string leftColor;
        private string rightColor;
        private string topColor;
        private string bottomColor;
        #endregion
 
 
        #region enums
        public enum StyleValue
        {
            None,
            Hair,
            Dotted,
            DashDotDot,
            DashDot,
            Dashed,
            Thin,
            MediumDashDotDot,
            SlantDashDot,
            MediumDashDot,
            MediumDashed,
            Medium,
            Thick,
#pragma warning disable CA1720 // Suppress: Identifiers should not contain types
            Double,
#pragma warning restore CA1720
        }
        #endregion
 
        #region properties
        [Append]
        public string BottomColor
        {
            get => bottomColor;
            set
            {
                Validators.ValidateColor(value, true, true);
                if (value != null)
                {
                    bottomColor = ParserUtils.ToUpper(value);
                }
                else
                {
                    bottomColor = value;
                }
            }
        }

        [Append]
        public StyleValue BottomStyle { get; set; }
        [Append]
        public string DiagonalColor
        {
            get => diagonalColor;
            set
            {
                Validators.ValidateColor(value, true, true);
                if (value != null)
                {
                    diagonalColor = ParserUtils.ToUpper(value);
                }
                else
                {
                    diagonalColor = value;
                }
            }
        }

        [Append]
        public bool DiagonalDown { get; set; }
        [Append]
        public bool DiagonalUp { get; set; }
        [Append]
        public StyleValue DiagonalStyle { get; set; }
        [Append]
        public string LeftColor
        {
            get => leftColor;
            set
            {
                Validators.ValidateColor(value, true, true);
                if (value != null)
                {
                    leftColor = ParserUtils.ToUpper(value);
                }
                else
                {
                    leftColor = value;
                }
            }
        }

        [Append]
        public StyleValue LeftStyle { get; set; }
        [Append]
        public string RightColor
        {
            get => rightColor;
            set
            {
                Validators.ValidateColor(value, true, true);
                if (value != null)
                {
                    rightColor = ParserUtils.ToUpper(value);
                }
                else
                {
                    rightColor = value;
                }
            }
        }

        [Append]
        public StyleValue RightStyle { get; set; }
        [Append]
        public string TopColor
        {
            get => topColor; set
            {
                Validators.ValidateColor(value, true, true);
                if (value != null)
                {
                    topColor = ParserUtils.ToUpper(value);
                }
                else
                {
                    topColor = value;
                }
            }
        }

        [Append]
        public StyleValue TopStyle { get; set; }
        #endregion
 
        #region constructors
        public Border()
        {
            BottomColor = DefaultBorderColor;
            TopColor = DefaultBorderColor;
            LeftColor = DefaultBorderColor;
            RightColor = DefaultBorderColor;
            DiagonalColor = DefaultBorderColor;
            LeftStyle = DefaultBorderStyle;
            RightStyle = DefaultBorderStyle;
            TopStyle = DefaultBorderStyle;
            BottomStyle = DefaultBorderStyle;
            DiagonalStyle = DefaultBorderStyle;
            DiagonalDown = false;
            DiagonalUp = false;
        }
        #endregion
 
        #region methods
        public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = -153001865;
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(BottomColor);
                hashCode = hashCode * -1521134295 + BottomStyle.GetHashCode();
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(DiagonalColor);
                hashCode = hashCode * -1521134295 + DiagonalDown.GetHashCode();
                hashCode = hashCode * -1521134295 + DiagonalUp.GetHashCode();
                hashCode = hashCode * -1521134295 + DiagonalStyle.GetHashCode();
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(LeftColor);
                hashCode = hashCode * -1521134295 + LeftStyle.GetHashCode();
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(RightColor);
                hashCode = hashCode * -1521134295 + RightStyle.GetHashCode();
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(TopColor);
                hashCode = hashCode * -1521134295 + TopStyle.GetHashCode();
                return hashCode;
            }
        }

        public override bool Equals(object obj)
        {
            return obj is Border border &&
                   BottomColor == border.BottomColor &&
                   BottomStyle == border.BottomStyle &&
                   DiagonalColor == border.DiagonalColor &&
                   DiagonalDown == border.DiagonalDown &&
                   DiagonalUp == border.DiagonalUp &&
                   DiagonalStyle == border.DiagonalStyle &&
                   LeftColor == border.LeftColor &&
                   LeftStyle == border.LeftStyle &&
                   RightColor == border.RightColor &&
                   RightStyle == border.RightStyle &&
                   TopColor == border.TopColor &&
                   TopStyle == border.TopStyle;
        }

        public override AbstractStyle Copy()
        {
            Border copy = new Border
            {
                BottomColor = BottomColor,
                BottomStyle = BottomStyle,
                DiagonalColor = DiagonalColor,
                DiagonalDown = DiagonalDown,
                DiagonalStyle = DiagonalStyle,
                DiagonalUp = DiagonalUp,
                LeftColor = LeftColor,
                LeftStyle = LeftStyle,
                RightColor = RightColor,
                RightStyle = RightStyle,
                TopColor = TopColor,
                TopStyle = TopStyle
            };
            return copy;
        }

        public Border CopyBorder()
        {
            return (Border)Copy();
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("\"Border\": {\n");
            AddPropertyAsJson(sb, "BottomStyle", BottomStyle);
            AddPropertyAsJson(sb, "DiagonalColor", DiagonalColor);
            AddPropertyAsJson(sb, "DiagonalDown", DiagonalDown);
            AddPropertyAsJson(sb, "DiagonalStyle", DiagonalStyle);
            AddPropertyAsJson(sb, "DiagonalUp", DiagonalUp);
            AddPropertyAsJson(sb, "LeftColor", LeftColor);
            AddPropertyAsJson(sb, "LeftStyle", LeftStyle);
            AddPropertyAsJson(sb, "RightColor", RightColor);
            AddPropertyAsJson(sb, "RightStyle", RightStyle);
            AddPropertyAsJson(sb, "TopColor", TopColor);
            AddPropertyAsJson(sb, "TopStyle", TopStyle);
            AddPropertyAsJson(sb, "HashCode", this.GetHashCode(), true);
            sb.Append("\n}");
            return sb.ToString();
        }

        internal bool IsEmpty()
        {
            bool state = true;
            if (BottomColor != DefaultBorderColor)
            { state = false; }
            if (TopColor != DefaultBorderColor)
            { state = false; }
            if (LeftColor != DefaultBorderColor)
            { state = false; }
            if (RightColor != DefaultBorderColor)
            { state = false; }
            if (DiagonalColor != DefaultBorderColor)
            { state = false; }
            if (LeftStyle != DefaultBorderStyle)
            { state = false; }
            if (RightStyle != DefaultBorderStyle)
            { state = false; }
            if (TopStyle != DefaultBorderStyle)
            { state = false; }
            if (BottomStyle != DefaultBorderStyle)
            { state = false; }
            if (DiagonalStyle != DefaultBorderStyle)
            { state = false; }
            if (DiagonalDown)
            { state = false; }
            if (DiagonalUp)
            { state = false; }
            return state;
        }
        #endregion
 
        #region staticMethods
        internal static string GetStyleName(StyleValue style)
        {
            string output = "";
            switch (style)
            {
                case StyleValue.Hair: output = "hair"; break;
                case StyleValue.Dotted: output = "dotted"; break;
                case StyleValue.DashDotDot: output = "dashDotDot"; break;
                case StyleValue.DashDot: output = "dashDot"; break;
                case StyleValue.Dashed: output = "dashed"; break;
                case StyleValue.Thin: output = "thin"; break;
                case StyleValue.MediumDashDotDot: output = "mediumDashDotDot"; break;
                case StyleValue.SlantDashDot: output = "slantDashDot"; break;
                case StyleValue.MediumDashDot: output = "mediumDashDot"; break;
                case StyleValue.MediumDashed: output = "mediumDashed"; break;
                case StyleValue.Medium: output = "medium"; break;
                case StyleValue.Thick: output = "thick"; break;
                case StyleValue.Double: output = "double"; break; // Default / none is already handled (ignored)
            }
            return output;
        }

        internal static StyleValue GetStyleEnum(string styleName)
        {
            switch (styleName)
            {
                case "hair": return StyleValue.Hair;
                case "dotted": return StyleValue.Dotted;
                case "dashDotDot": return StyleValue.DashDotDot;
                case "dashDot": return StyleValue.DashDot;
                case "dashed": return StyleValue.Dashed;
                case "thin": return StyleValue.Thin;
                case "mediumDashDotDot": return StyleValue.MediumDashDotDot;
                case "slantDashDot": return StyleValue.SlantDashDot;
                case "mediumDashDot": return StyleValue.MediumDashDot;
                case "mediumDashed": return StyleValue.MediumDashed;
                case "medium": return StyleValue.Medium;
                case "thick": return StyleValue.Thick;
                case "double": return StyleValue.Double;
 
                default:
                    return StyleValue.None; // fallback – change to throw if you'd prefer strict handling
            }
        }
        #endregion
 
    }
}