KoogleV4/GameHandler/ExpenseHandler.cs

using GameHandler.Extensions;
using GameModel;
using GameModel.Contract;
using GameModel.DeathGame;
using GameModel.Exceptions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;

namespace GameHandler
{
    public class ExpenseHandler
    {
        //public delegate void OnExpense(MemberExpense memberExpense);

        IExpenseRepository _expenseRepository;

        public ExpenseHandler(IExpenseRepository expenseRepository)
        {
            _expenseRepository = expenseRepository;
        }

        public async Task<ExpenseModel> HandleGameExenseEventArgs(GameExenseEventArgs gameExenseEventArgs, ExpenseModel expenseModelToAppend)
        {
            if (!gameExenseEventArgs.PlayerIds.Any(_ => _ == gameExenseEventArgs.PlayerId))
            {
                throw new InvalidPinThrowException($"Player {gameExenseEventArgs.PlayerId} not found");
            }

            List<PlayerExpense> memberExpenses = PrepareResult(ref expenseModelToAppend);
            var triggers = gameExenseEventArgs.Triggers;

            await AssignExpenses(gameExenseEventArgs.PlayerId, gameExenseEventArgs.PlayerIds, memberExpenses, triggers,
                gameExenseEventArgs.GameStateId);

            return expenseModelToAppend with { MemberExpenses = memberExpenses.ToArray() };
        }

        private async Task AssignExpenses(int playerId, int[] playerIds, 
            List<PlayerExpense> memberExpenses, ExpenseTrigger[] triggers,
            Guid gameStateId)
        { 
            var list = await _expenseRepository.GetAll();
            var destExpenses = list
                .Where(_ => _.ExpenseTriggers.Any(et => triggers.Any(et2 => et2 == et)));

            var inversePlayers = playerIds.Where(_ => _ != playerId);
            foreach (var expense in destExpenses)
            {
                if (expense.IsInverse)
                {
                    foreach (var player in inversePlayers)
                    {
                        memberExpenses.Add(PlayerExpense.Create(player, expense, gameStateId));
                    }
                }
                else
                {
                    memberExpenses.Add(PlayerExpense.Create(playerId, expense, gameStateId));
                }
            }
        }

        public async Task<ExpenseModel> CheckThrow(BoardState currentState, PinThrow pinThrow, int[] PlayerIds, 
            Guid gameStateId,
            ExpenseModel expenseModelToAppend = null)
        {
            if (!PlayerIds.Any(_ => _ == pinThrow.PlayerId))
            {
                throw new InvalidPinThrowException($"Player {pinThrow.PlayerId} not found");
            }

            List<PlayerExpense> memberExpenses = PrepareResult(ref expenseModelToAppend);

            var triggers = pinThrow.GetExpenseTriggers(currentState);
            await AssignExpenses(pinThrow.PlayerId, PlayerIds, memberExpenses, triggers, gameStateId);

            return expenseModelToAppend with { MemberExpenses = memberExpenses.ToArray() };
        }

        private static List<PlayerExpense> PrepareResult(ref ExpenseModel expenseModelToAppend)
        {
            if (expenseModelToAppend == null)
            {
                expenseModelToAppend = new ExpenseModel(Array.Empty<PlayerExpense>());
            }
            var memberExpenses = new List<PlayerExpense>(expenseModelToAppend.MemberExpenses);
            return memberExpenses;
        }
    }
}