LaDOSE/LaDOSE.Src/LaDOSE.Service/Service/TournamentService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LaDOSE.Business.Interface;
using LaDOSE.Entity.Challonge;
using LaDOSE.Entity.Context;
using LaDOSE.Entity.Wordpress;
using Microsoft.EntityFrameworkCore.Internal;

namespace LaDOSE.Business.Service
{
    public class TournamentService : ITournamentService
    {
        private class Rules
        {
            public int PlayerMin { get; set; }
            public int PlayerMax { get; set; }
            public int FirstPoint { get; set; }
            public int SecondPoint { get; set; }
            public int ThirdFourthPoint { get; set; }
            public int Top8Point { get; set; }
            public int Top16Point { get; set; }

            public int Participation => 1;

            public Rules(int playerMin, int playerMax, int firstPoint, int secondPoint, int thirdFourthPoint,
                int top8Point, int top16Point)
            {
                PlayerMin = playerMin;
                PlayerMax = playerMax;
                FirstPoint = firstPoint;
                SecondPoint = secondPoint;
                ThirdFourthPoint = thirdFourthPoint;
                Top8Point = top8Point;
                Top16Point = top16Point;
            }
        }

        private LaDOSEDbContext _context;
        private IChallongeProvider _challongeProvider;

        private List<Rules> TournamentRules = new List<Rules>()
        {
            new Rules(0, 8, 5, 3, 2, 0, 0),
            new Rules(8, 16, 8, 5, 3, 2, 0),
            new Rules(16, 32, 12, 8, 5, 3, 2),
            new Rules(32, Int32.MaxValue, 18, 12, 8, 5, 3),
        };

        public TournamentService(LaDOSEDbContext context, IChallongeProvider challongeProvider)
        {
            this._context = context;
            this._challongeProvider = challongeProvider;
        }

        public async Task<List<Tournament>> GetTournaments(DateTime? start, DateTime? end)
        {
            List<WPUser> wpUsers = _context.WPUser.ToList();
            var tournaments = await _challongeProvider.GetTournaments(start, end);

            foreach (var tournament in tournaments)
            {
                List<Participent> participents = await _challongeProvider.GetParticipents(tournament.Id);
                tournament.Participents = participents;
            }

            return tournaments;
        }

        public async Task<TournamentsResult> GetTournamentsResult(List<int> ids)
        {
            TournamentsResult result = new TournamentsResult();
            result.Results = new List<Result>();
            var tournaments = new List<Tournament>();
            foreach (var idTournament in ids)
            {
                var tournament = await _challongeProvider.GetTournament(idTournament);
                tournament.Participents = await _challongeProvider.GetParticipents(tournament.Id);
                tournaments.Add(tournament);
            }

            var games = _context.Game.ToList();
            var players = _context.WPUser.ToList();

            var allParticipent = tournaments.SelectMany(e => e.Participents).Distinct((a, b) => a.Name == b.Name)
                .ToList();
            foreach (var participent in allParticipent)
            {
                var player = players.FirstOrDefault(e => e.Name.Contains(participent.Name));
                if (player != null)
                {
                    participent.IsMember = true;
                }
            }

            result.Participents = allParticipent;

            foreach (var tournament in tournaments)
            {
                var game = games.First(g => tournament.Name.Contains(g.Name));
                tournament.Game = game;

                var playerCount = tournament.Participents.Count;
                var lesSacs = tournament.Participents;
                var currentRule = TournamentRules.FirstOrDefault(rules =>
                    rules.PlayerMin < playerCount && rules.PlayerMax >= playerCount
                );
                if (currentRule == null)
                {
                    throw new Exception("Unable to find rules");
                }

                var first = tournament.Participents.First(p => p.Rank == 1);
                var second = tournament.Participents.First(p => p.Rank == 2);
                var thirdFourth = tournament.Participents.Where(p => p.Rank == 3 || p.Rank == 4).ToList();
                var Top8 = tournament.Participents.Where(p => p.Rank > 4 && p.Rank < 9).ToList();
                var Top16 = tournament.Participents.Where(p => p.Rank > 8 && p.Rank <= 16).ToList();

                result.Results.Add(new Result(first.Name, tournament.Game.Id, tournament.Id, tournament.Url, currentRule.FirstPoint));
                lesSacs.Remove(first);
                result.Results.Add(new Result(second.Name, tournament.Game.Id, tournament.Id, tournament.Url, currentRule.SecondPoint));
                lesSacs.Remove(second);
                thirdFourth.ForEach(r =>
                    result.Results.Add(new Result(r.Name, tournament.Game.Id, tournament.Id, tournament.Url,
                        currentRule.ThirdFourthPoint)));
                thirdFourth.ForEach(p => lesSacs.Remove(p));
                if (currentRule.Top8Point != 0)
                {
                    Top8.ForEach(r =>
                        result.Results.Add(new Result(r.Name, tournament.Game.Id, tournament.Id, tournament.Url, currentRule.Top8Point)));
                    Top8.ForEach(p => lesSacs.Remove(p));
                }

                if (currentRule.Top16Point != 0)
                {
                    Top16.ForEach(r =>
                        result.Results.Add(
                            new Result(r.Name, tournament.Game.Id, tournament.Id, tournament.Url, currentRule.Top16Point)));
                    Top16.ForEach(p => lesSacs.Remove(p));
                }

                lesSacs.ForEach(r =>
                    result.Results.Add(new Result(r.Name, tournament.Game.Id, tournament.Id, tournament.Url,
                        currentRule.Participation)));
            }

            result.Games = tournaments.Select(e => e.Game).Distinct((game, game1) => game.Name == game1.Name).ToList();

            return result;
        }
    }
}