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<IEnumerable<PlayerExpense>> HandleGameExenseEventArgs(GameExenseEventArgs gameExenseEventArgs)
        {
            if (!gameExenseEventArgs.PlayerIds.Any(_ => _ == gameExenseEventArgs.PlayerId))
            {
                throw new InvalidPinThrowException($"Player {gameExenseEventArgs.PlayerId} not found");
            }

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

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

            return memberExpenses;
        }

        private async Task AssignExpenses(int playerId, int[] playerIds, List<PlayerExpense> memberExpenses, ExpenseTrigger[] triggers)
        { 
            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));
                    }
                }
                else
                {
                    memberExpenses.Add(PlayerExpense.Create(playerId, expense));
                }
            }
        }

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

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

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

            return memberExpenses;
        }

        //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;
        //}
    }
}