MultiDateOnlyRange.cs

// "Copyright (c) Cyrille NDOUMBE.
// Licenced under GNU General Public Licence, version 3.0"

#if NET6_0_OR_GREATER

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
#if NET8_0_OR_GREATER
using System.Numerics;
#endif
using System.Text;

namespace Candoumbe.Types.Calendar;

/// <summary>
/// A type that optimize the storage of several <see cref="DateOnlyRange"/>s.
/// </summary>
public class MultiDateOnlyRange : IEquatable<MultiDateOnlyRange>, IEnumerable<DateOnlyRange>
#if NET7_0_OR_GREATER
    , IAdditionOperators<MultiDateOnlyRange, MultiDateOnlyRange, MultiDateOnlyRange>
    , IAdditionOperators<MultiDateOnlyRange, DateOnlyRange, MultiDateOnlyRange>
    , IUnaryNegationOperators<MultiDateOnlyRange, MultiDateOnlyRange>
    , IEqualityOperators<MultiDateOnlyRange, MultiDateOnlyRange, bool>
#endif
{
    private readonly HashSet<DateOnlyRange> _ranges;

    /// <summary> 
    /// A <see cref="MultiDateOnlyRange"/> that contains no <see cref="DateOnlyRange"/>.
    /// </summary>
    public static MultiDateOnlyRange Empty => [];

    /// <summary>
    /// A <see cref="MultiDateOnlyRange"/> that overlaps any other <see cref="MultiDateOnlyRange"/>.
    /// </summary>
    public static MultiDateOnlyRange Infinite => new(DateOnlyRange.Infinite);

    /// <summary>
    /// Builds a new <see cref="MultiDateOnlyRange"/> instance
    /// </summary>
    /// <param name="ranges"></param>
    public MultiDateOnlyRange(params DateOnlyRange[] ranges)
    {
        _ranges = new HashSet<DateOnlyRange>(ranges.Length);
        foreach (DateOnlyRange range in ranges.OrderBy(x => x.Start))
        {
            Add(range);
        }
    }

    /// <inheritdoc />
    public IEnumerator<DateOnlyRange> GetEnumerator() => _ranges.OrderBy(x => x.Start).GetEnumerator();

    /// <inheritdoc />
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    /// <summary>
    /// Adds <paramref name="range"/>.
    /// </summary>
    /// <remarks>
    /// The algorithm will first try to find if any other <see cref="DateOnlyRange"/> overlaps or abuts with <paramref name="range"/> and if so,
    /// will swap that element with the result of <c>range.Union(element)</c>
    /// </remarks>
    /// <param name="range">a range to add to the current instance</param>
    /// <exception cref="ArgumentNullException">if <paramref name="range"/> is <see langword="null"/>.</exception>
    public void Add(DateOnlyRange range)
    {
        ArgumentNullException.ThrowIfNull(range);

        if (range.IsEmpty())
        {
            return;
        }

        if (range.IsInfinite())
        {
            _ranges.Clear();
            _ranges.Add(range);
        }
        else
        {
            DateOnlyRange[] previous = _ranges.Where(item => item.IsContiguousWith(range) || item.Overlaps(range))
                                              .OrderBy(x => x.Start)
                                              .ToArray();
            if (previous.Length != 0)
            {
                previous.ForEach(item => _ranges.Remove(item));
                DateOnlyRange union = previous.Aggregate(range, (a, b) => a.Merge(b));
                _ranges.Add(union);
            }
            else
            {
                _ranges.Add(range);
            }
        }
    }

    ///<inheritdoc/>
    public static MultiDateOnlyRange operator +(MultiDateOnlyRange left, DateOnlyRange range)
    {
        left.Add(range);

        return left;
    }

    /// <summary>
    /// Computes a <see cref="MultiDateOnlyRange"/> that represents the union of the current instance with <paramref name="other"/>.
    /// </summary>
    /// <param name="other">The other instance to add</param>
    /// <exception cref="ArgumentNullException">if <paramref name="other"/> is <see langword="null"/></exception>
    /// <returns>a <see cref="MultiDateOnlyRange"/> that represents the union of the current instance with <paramref name="other"/>.</returns>
    public MultiDateOnlyRange Merge(MultiDateOnlyRange other)
    {
        ArgumentNullException.ThrowIfNull(other);
        return new MultiDateOnlyRange([.. _ranges.Union(other._ranges)]);
    }

#if !NET7_0_OR_GREATER
    /// <summary>
    /// Performs a "union" operation between <paramref name="left"/> and <paramref name="right"/> elements.
    /// </summary>
    /// <param name="left">The left element of the operator</param>
    /// <param name="right">The right element of the operator</param>
    /// <returns>a <see cref="MultiDateOnlyRange"/> that represents <paramref name="left"/> and <paramref name="right"/> values.</returns>
#else
    ///<inheritdoc/>
#endif
    public static MultiDateOnlyRange operator +(MultiDateOnlyRange left, MultiDateOnlyRange right)
    {
        ArgumentNullException.ThrowIfNull(left);
        ArgumentNullException.ThrowIfNull(right);

        return left.Merge(right);
    }

    /// <summary>
    /// Checks if the current instance contains one or more <see cref="DateOnlyRange"/>s which, once combined, overlap the specified <paramref name="range"/>.
    /// </summary>
    /// <param name="range">The range to test</param>
    /// <returns><see langword="true"/> if the current instance contains <see cref="DateOnlyRange"/>s which, once combined, overlap <paramref name="range"/> and <see langword="false"/> otherwise.</returns>
    public bool Overlaps(DateOnlyRange range)
    {
        return _ranges.Count != 0
                      && _ranges.AsParallel()
                                .Any(item => item == range || (item.Overlaps(range) && item.Start <= range.Start && range.End <= item.End));
    }

    /// <summary>
    /// Checks if the current instance contains one or more <see cref="TimeOnlyRange"/>s which, once combined, cover the specified <paramref name="other"/>.
    /// </summary>
    /// <param name="other">The range to test</param>
    /// <returns><see langword="true"/> if the current instance contains <see cref="TimeOnlyRange"/>s which, once combined, cover <paramref name="other"/> and <see langword="false"/> otherwise.</returns>
    public bool Overlaps(MultiDateOnlyRange other) => other is not null
                                                    && _ranges.AsParallel().All(other.Overlaps);

    ///<inheritdoc/>
    public override string ToString()
    {
        string representation = "{infinite}";

        if (IsEmpty())
        {
            representation = "{empty}";
        }
        else if (!IsInfinite())
        {
            StringBuilder sb = new();

            foreach (DateOnlyRange item in _ranges)
            {
                if (sb.Length > 0)
                {
                    sb.Append(',');
                }
                sb.Append(item);
            }

            representation = sb.Insert(0, "{").Append('}').ToString();
        }

        return representation;
    }

    /// <summary>
    /// Computes the complement of the current instance.
    /// </summary>
    public MultiDateOnlyRange Complement()
    {
        MultiDateOnlyRange complement;

        if (IsInfinite())
        {
            complement = Empty;
        }
        else if (IsEmpty())
        {
            complement = Infinite;
        }
        else
        {
            complement = new();
            switch (_ranges)
            {
                case { Count: 1 }:
                    {
                        DateOnlyRange current = _ranges.ElementAt(0);
                        complement.Add(DateOnlyRange.UpTo(current.Start));
                        complement.Add(DateOnlyRange.DownTo(current.End));
                    }
                    break;
                default:
                    {
                        DateOnlyRange[] ranges = _ranges.OrderBy(range => range.Start)
                                                        .ToArray();
                        for (int i = 0; i < ranges.Length; i++)
                        {
                            DateOnlyRange current = ranges[i];
                            switch (i)
                            {
                                case 0:
                                    complement.Add(DateOnlyRange.UpTo(current.Start));
                                    break;
                                case int _ when i <= ranges.Length - 2:
                                    {
                                        DateOnlyRange previous = ranges[i- 1];
                                        DateOnlyRange next = ranges[i + 1];
                                        complement.Add(new DateOnlyRange(previous.End, current.Start));
                                        complement.Add(new DateOnlyRange(current.End, next.Start));
                                    }
                                    break;
                                default:
                                    {
                                        DateOnlyRange previous = ranges[i - 1];
                                        complement.Add(new DateOnlyRange(previous.End, current.Start));
                                        complement.Add(DateOnlyRange.DownTo(current.End));
                                    }
                                    break;
                            }
                        }
                    }
                    break;
            }
        }

        return complement;
    }

    ///<inheritdoc/>
    public static MultiDateOnlyRange operator -(MultiDateOnlyRange range) => range.Complement();

    /// <summary>
    /// Checks if the current instance is empty.
    /// </summary>
    /// <returns><see langword="true"/> when the current instance cannot cover any other </returns>
    public bool IsEmpty() => _ranges.Count == 0 || _ranges.All(range => range.IsEmpty());

    /// <summary>
    /// Checks if the current instance is "infinite" which, if <see langword="true" />, means that it overlaps any other <see cref="DateOnlyRange"/>.
    /// </summary>
    /// <returns></returns>
    public bool IsInfinite() => _ranges.AtLeastOnce() && _ranges.All(range => range.IsInfinite());

    ///<inheritdoc/>
    public bool Equals(MultiDateOnlyRange other)
    {
        bool equals = false;
        if (other is not null)
        {
            equals = ReferenceEquals(this, other) || (IsEmpty() && other.IsEmpty()) || (Overlaps(other) && other.Overlaps(this));
        }
        return equals;
    }

    ///<inheritdoc/>
    public override bool Equals(object obj) => Equals(obj as MultiDateOnlyRange);

    ///<inheritdoc/>
    public override int GetHashCode()
    {
        HashCode hashCode = new();

        foreach (DateOnlyRange range in _ranges)
        {
            hashCode.Add(range);
        }

        return hashCode.ToHashCode();
    }

#if !NET8_0_OR_GREATER
    ///<summary>
    /// Compares two values to determine equality
    /// </summary>
    /// <param name="left">The value to compare to <paramref name="right"/></param>
    /// <param name="right">The value to compare to <paramref name="left"/></param>
    /// <returns><see langword="true"/> if <paramref name="left"/> is equal to <paramref name="right"/>; otherwise, <see langword="false"/></returns>
#else
    /// <inheritdoc /> 
#endif
    public static bool operator ==(MultiDateOnlyRange left, MultiDateOnlyRange right)
        => ( left, right ) switch
        {
            (null, null) => true,
            (null, not null) => false,
            _ => left.Equals(right),
        };

#if !NET8_0_OR_GREATER
    ///<summary>
    /// Compares two values to determine inequality
    /// </summary>
    /// <param name="left">The value to compare to <paramref name="right"/></param>
    /// <param name="right">The value to compare to <paramref name="left"/></param>
    /// <returns><see langword="true"/> if <paramref name="left"/> is not equal to <paramref name="right"/>; otherwise, <see langword="false"/></returns>
#else
    /// <inheritdoc /> 
#endif
    public static bool operator !=(MultiDateOnlyRange left, MultiDateOnlyRange right) => !(left == right);
}

#endif