NumberFormat.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.Exceptions;
 
namespace NanoXLSX.Styles
{
    public class NumberFormat : AbstractStyle
    {
        #region constants
        public static readonly int CustomFormatStartNumber = 164;
        public static readonly FormatNumber DefaultNumber = FormatNumber.None;
 
        #endregion
        private int customFormatID;
 
        #region enums
        public enum FormatNumber
        {
            None = 0,
            Format1 = 1,
            Format2 = 2,
            Format3 = 3,
            Format4 = 4,
            Format5 = 5,
            Format6 = 6,
            Format7 = 7,
            Format8 = 8,
            Format9 = 9,
            Format10 = 10,
            Format11 = 11,
            Format12 = 12,
            Format13 = 13,
            Format14 = 14,
            Format15 = 15,
            Format16 = 16,
            Format17 = 17,
            Format18 = 18,
            Format19 = 19,
            Format20 = 20,
            Format21 = 21,
            Format22 = 22,
            Format37 = 37,
            Format38 = 38,
            Format39 = 39,
            Format40 = 40,
            Format45 = 45,
            Format46 = 46,
            Format47 = 47,
            Format48 = 48,
            Format49 = 49,
            Custom = 164,
        }

        public enum FormatRange
        {
            DefinedFormat,
            CustomFormat,
            Invalid,
            Undefined,
        }
        #endregion
 
        #region privateFields
        private string customFormatCode;
 
        #endregion
 
        #region properties
        [Append]
        public string CustomFormatCode
        {
            get => customFormatCode;
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    throw new FormatException("A custom format code cannot be null or empty");
                }
                customFormatCode = value;
            }
        }

        [Append]
        public int CustomFormatID
        {
            get { return customFormatID; }
            set
            {
                if (value < CustomFormatStartNumber && !StyleRepository.Instance.ImportInProgress)
                {
                    throw new StyleException("The number '" + value + "' is not a valid custom format ID. Must be at least " + CustomFormatStartNumber);
                }
                customFormatID = value;
            }
        }

        [Append(Ignore = true)]
        public bool IsCustomFormat
        {
            get
            {
                if (Number == FormatNumber.Custom)
                { return true; }
                else { return false; }
            }
        }

        [Append]
        public FormatNumber Number { get; set; }
        #endregion
 
        #region constructors
        public NumberFormat()
        {
            Number = DefaultNumber;
            customFormatCode = string.Empty;
            CustomFormatID = CustomFormatStartNumber;
        }
        #endregion
 
        #region methods

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("\"NumberFormat\": {\n");
            AddPropertyAsJson(sb, "CustomFormatCode", CustomFormatCode);
            AddPropertyAsJson(sb, "CustomFormatID", CustomFormatID);
            AddPropertyAsJson(sb, "Number", Number);
            AddPropertyAsJson(sb, "HashCode", this.GetHashCode(), true);
            sb.Append("\n}");
            return sb.ToString();
        }

        public override AbstractStyle Copy()
        {
            NumberFormat copy = new NumberFormat
            {
                customFormatCode = customFormatCode,
                CustomFormatID = CustomFormatID,
                Number = Number
            };
            return copy;
        }

        public NumberFormat CopyNumberFormat()
        {
            return (NumberFormat)Copy();
        }

        public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = 495605284;
                hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(CustomFormatCode);
                hashCode = hashCode * -1521134295 + CustomFormatID.GetHashCode();
                hashCode = hashCode * -1521134295 + Number.GetHashCode();
                return hashCode;
            }
        }

        public override bool Equals(object obj)
        {
            return obj is NumberFormat format &&
                   CustomFormatCode == format.CustomFormatCode &&
                   CustomFormatID == format.CustomFormatID &&
                   Number == format.Number;
        }
 
        #endregion
 
        #region staticMethods

        public static bool IsDateFormat(FormatNumber number)
        {
            switch (number)
            {
                case FormatNumber.Format14:
                case FormatNumber.Format15:
                case FormatNumber.Format16:
                case FormatNumber.Format17:
                case FormatNumber.Format22:
                    return true;
                default:
                    return false;
            }
        }

        public static bool IsTimeFormat(FormatNumber number)
        {
            switch (number)
            {
                case FormatNumber.Format18:
                case FormatNumber.Format19:
                case FormatNumber.Format20:
                case FormatNumber.Format21:
                case FormatNumber.Format45:
                case FormatNumber.Format46:
                case FormatNumber.Format47:
                    return true;
                default:
                    return false;
            }
        }

        public static FormatRange TryParseFormatNumber(int number, out FormatNumber formatNumber)
        {
 
            bool isDefined = System.Enum.IsDefined(typeof(FormatNumber), number);
            if (isDefined)
            {
                formatNumber = (FormatNumber)number;
                return FormatRange.DefinedFormat;
            }
            if (number < 0)
            {
                formatNumber = FormatNumber.None;
                return FormatRange.Invalid;
            }
            else if (number > 0 && number < CustomFormatStartNumber)
            {
                formatNumber = FormatNumber.None;
                return FormatRange.Undefined;
            }
            else
            {
                formatNumber = FormatNumber.Custom;
                return FormatRange.CustomFormat;
            }
        }
 
        #endregion
 
    }
}