using GameModel;
using GameModel.Contract;
using GameModel.Contracts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace GameHandler
{
    class GameStateHandlerItem<T>
    {
        internal Guid GameStateId;
        internal bool Saved;
        internal T Data;
        public GameStateHandlerItem(Guid gameStateId, T data, bool saved)
        {
            GameStateId = gameStateId;
            Saved = saved;
            Data = data;
        }
    }

    public class GameStateHandler
    {
        private Guid _gameStateId;
        private List<GameStateHandlerItem<GameState>> gameStates = new List<GameStateHandlerItem<GameState>>();
        private List<GameStateHandlerItem<ExpenseModel>> expenseModels = new List<GameStateHandlerItem<ExpenseModel>>();
        private List<GameStateHandlerItem<MemberExpense>> memberExpenses = new List<GameStateHandlerItem<MemberExpense>>();

        private IGameRepository _gameRepository;
        private IExpenseRepository _expenseRepository;

        public GameStateHandler(IGameRepository gameRepository, IExpenseRepository expenseRepository) 
        {
            _gameRepository = gameRepository;
            _expenseRepository = expenseRepository;
        }

        public ExpenseModel ExpenseModel
        {
            get
            {
                var res = expenseModels.LastOrDefault();
                if (res != null)
                {
                    return res.Data;
                }
                return null;
            }
        }

        public GameState GameState 
        { 
            get
            {
                var res = gameStates.LastOrDefault();
                if (res != null)
                {
                    return res.Data;
                }
                return null;
            }
        }

        internal async Task Add(ExpenseModel expenseModel)
        {
            if (ExpenseModel != null)
            {
                if (!expenseModel.Equals(ExpenseModel))
                {
                    expenseModels.Add(new GameStateHandlerItem<ExpenseModel>(_gameStateId, expenseModel, false));
                    await Save();
                }
            } 
            else 
            { 
                expenseModels.Add(new GameStateHandlerItem<ExpenseModel>(_gameStateId, expenseModel, false));
                await Save();
            }


            foreach(var memberExpense in expenseModel.MemberExpenses.Where(_ => memberExpenses.Any(me => me.Data.Id.Equals(_.Id))))
            {
                memberExpenses.Add(new GameStateHandlerItem<MemberExpense>(_gameStateId,memberExpense,false));
            }
        }

        internal async Task Add(GameState newState, Game game)
        {
            if (!newState.Equals(GameState))
            {
                _gameStateId = Guid.NewGuid();
                gameStates.Add(new GameStateHandlerItem<GameState>(_gameStateId, newState, false));
                await Save();
            }
        }

        private async Task Save()
        {
            await Task.WhenAll(gameStates.Where(_ => !_.Saved)
                .Select(_ => _gameRepository.Save(_.Data)))
                .ContinueWith(_ => {
                    gameStates.ForEach(gs => { gs.Saved = true; });
                });

            await Task.WhenAll(memberExpenses.Where(_ => !_.Saved)
                .Select(_ => _expenseRepository.Save(_.Data)))
                .ContinueWith(_ => {
                    memberExpenses.ForEach(me => { me.Saved = true; });
                });
        }

        public void Undo()
        {
            
        }

        internal async Task<Game> CreateNewGame()
        {
            return await _gameRepository.Create(null);
        }
    }
}