EvoCalculator.Core/EvoCalculator.Core.Tools/GroupColumns/Sum.cs

using System;
using System.Collections.Generic;
using System.Linq;
using EvoCalculator.Core.Tools.GroupColumns.Models;

namespace EvoCalculator.Core.Tools.GroupColumns;

public class GroupDate
{
    public int? Day { get; set; }
    public int Month { get; set; }
    public int Year { get; set; }
}

public static partial class GroupColumns
{
    public static List<KeyValuePair<DateTime, decimal>> SumToMainGroupWithCompression(
        List<KeyValuePair<DateTime, decimal>> mainGroupColumn,
        params List<KeyValuePair<DateTime, decimal>>[] groupColumns
    )
    {
        var mergedGroupColumns = Merge(groupColumns);

        return mainGroupColumn.Select((mainGroupPair, i) =>
        {
            var prevMainGroupDate = mainGroupColumn.ElementAtOrDefault(i - 1).Key;
            var currentMainGroupDate = mainGroupColumn.ElementAt(i).Key;

            var newValue = mergedGroupColumns
                .Select(x =>
                    // Для сравнения дат
                    new KeyValuePair<DateTime, decimal>(new DateTime(x.Key.Year, x.Key.Month, 1), x.Value))
                .Where(x => x.Key > prevMainGroupDate.Date && x.Key <= currentMainGroupDate.Date)
                .Sum(pair => pair.Value);

            return new KeyValuePair<DateTime, decimal>(mainGroupPair.Key, newValue);
        }).ToList();
    }

    public static List<KeyValuePair<DateTime, decimal>> SumToMainGroup(
        List<KeyValuePair<DateTime, decimal>> mainGroupColumn,
        params List<KeyValuePair<DateTime, decimal>>[] groupColumns)
    {
        return mainGroupColumn.Select(mainGroupPair =>
        {
            var secondarySum = Merge(groupColumns)
                .Where(x => x.Key >= mainGroupPair.Key)
                .Sum(x => x.Value);


            return new KeyValuePair<DateTime, decimal>(mainGroupPair.Key, mainGroupPair.Value + secondarySum);
        }).ToList();
    }

    public static List<KeyValuePair<DateTime, decimal>> SumToMainGroup(SumRules sumRules,
        List<KeyValuePair<DateTime, decimal>> mainGroupColumn,
        params List<KeyValuePair<DateTime, decimal>>[] groupColumns)
    {
        var groupedColumns = sumRules.GroupBy switch
        {
            GroupByRule.Day => Merge(groupColumns)
                .GroupBy(x => new GroupDate
                {
                    Day = x.Key.Day, Month = x.Key.Month, Year = x.Key.Year
                }),
            _ => Merge(groupColumns)
                .GroupBy(x => new GroupDate
                {
                    Month = x.Key.Month, Year = x.Key.Year
                })
        };


        return mainGroupColumn.Select((mainGroupPair, _) =>
        {
            var secondarySum = groupedColumns
                .Where(x => sumRules.GroupBy switch
                {
                    GroupByRule.Day => x.Key.Day == mainGroupPair.Key.Day
                                       && x.Key.Month == mainGroupPair.Key.Month
                                       && x.Key.Year == mainGroupPair.Key.Year,
                    _ => x.Key.Month == mainGroupPair.Key.Month
                         && x.Key.Year == mainGroupPair.Key.Year
                })
                .SelectMany(g => g)
                .Sum(x => x.Value);

            return new KeyValuePair<DateTime, decimal>(mainGroupPair.Key, mainGroupPair.Value + secondarySum);
        }).ToList();
    }

    public static List<KeyValuePair<DateTime, decimal>> Sum(SumRules sumRules,
        params List<KeyValuePair<DateTime, decimal>>[] groupColumns)
    {
        var groupedColumns = Merge(groupColumns)
            .GroupBy(x => new {x.Key.Month, x.Key.Year});

        return groupedColumns.Select((group, i) =>
            {
                var dates = group.Select(pair => pair.Key);
                var day = sumRules.Day switch
                {
                    (int) DayRule.Min => 1,
                    (int) DayRule.Max => DateTime.DaysInMonth(group.Key.Year, group.Key.Month),
                    (int) DayRule.MinInGroup => dates.Min(date => date.Day),
                    (int) DayRule.MaxInGroup => dates.Max(date => date.Day),
                    _ => sumRules.Day
                };
                var date = new DateTime(group.Key.Year, group.Key.Month, day);

                var values = group.Select(pair => pair.Value);
                var value = sumRules.Value switch
                {
                    ValueRule.Min => values.Min(),
                    ValueRule.Max => values.Max(),
                    ValueRule.Average => values.Average(),
                    _ => values.Sum(x => x)
                };

                return new KeyValuePair<DateTime, decimal>(date, value);
            })
            .OrderBy(x => x.Key)
            .ToList();
    }
}