using System;

using System.Linq;

using System.Collections.Generic;

using System.Text;

public class Program

{

    private static Random r;

    public static void Main()

    {

        Console.WriteLine("Welcome to Coin Toss Tournament!");

        Console.WriteLine("64 Teams, 16 groups of 4, 4 rounds to find a winner");

        Console.WriteLine("... Purpose is to highlight how different Swiss techniques result in players of similar skill playing each other");

        Console.WriteLine("    We use the Team number in this case to represent the 'Skill' level. Lower number means more skill #1 is the highest skill.");

        Console.WriteLine("    In this first case we are using a pre-computed matrix, at the end the lowest team numbers (highest skill) should be in the highest skill groups (lowest group numbers)");

        // hardcode random seed for consistent output, 10 has #1 in the last group.

        r = new Random(10);

        int [] teams = Enumerable.Range(1,64).ToArray();

​

        teams = SeedTeams(teams);

        Console.WriteLine();

        Console.WriteLine("Initial Seeding:");

        Console.WriteLine(String.Join(",", teams));

        Console.WriteLine();

        List<Grouping> round1 = DrawRoundOne(teams);

        RecordResults(round1);

        PrintResults(round1);

        Console.WriteLine();

        List<Grouping> round2 = DrawNextRoundUsingMatrix(round1);

        RecordResults(round2);

        PrintResults(round2);

        Console.WriteLine();

        List<Grouping> round3 = DrawNextRoundUsingMatrix(round2);

        RecordResults(round3);

        PrintResults(round3);

        Console.WriteLine();

        List<Grouping> round4 = DrawNextRoundUsingMatrix(round3);

        RecordResults(round4);

        Console.WriteLine();

        PrintResults(round4);

        // collate all results

        var overall = CollateAllResults(round1, round2, round3, round4);

        PrintRoundByRound(overall);

        // DONE! Now try Brute Force Swiss

        Console.WriteLine();

        Console.WriteLine();

        Console.WriteLine("Now try brute force or dynamic SWISS draw");

        Console.WriteLine("Same Seeding and Win Rules");

        Console.WriteLine();

        List<Grouping> round1D = DrawRoundOne(teams);

        RecordResults(round1D);

        PrintResults(round1D);

        Console.WriteLine();

        List<Grouping> round2D = DrawNextRoundDynamic(CollateAllResults(round1D));

        RecordResults(round2D);

        PrintResults(round2D);

        Console.WriteLine();

        List<Grouping> round3D = DrawNextRoundDynamic(CollateAllResults(round1D, round2D));

        RecordResults(round3D);

        PrintResults(round3D);

        Console.WriteLine();

        List<Grouping> round4D = DrawNextRoundDynamic(CollateAllResults(round1D, round2D, round3D));

        RecordResults(round4D);

        Console.WriteLine();

        PrintResults(round4D);

        // collate all results

        var overallD = CollateAllResults(round1D, round2D, round3D, round4D);

        PrintRoundByRound(overallD);

        // Show a comparison

        PrintComparison(CollateAllResults(round1, round2, round3, round4), CollateAllResults(round1D, round2D, round3D, round4D));

    }

    /// <summary> Ranks the teams before drawing </summary>

    private static int[] SeedTeams(int[] teams)

    {

        // Randomising today, you might use other logic for your application    

        return teams.OrderBy(x => r.NextDouble()).ToArray();

    }

    private static List<Grouping> DrawRoundOne(int[] teams)

    {

        List<Grouping> groups = new ();

        int roundNo = 1;

        // 16 groups of 4

        for(int g = 0 ; g < 16 ; g++)

        {

            var grp = new Grouping

            {

                Round = roundNo,

                Group = g + 1

            };

            var groupTeams = teams.AsEnumerable().Skip(g*4).Take(4).ToArray();

            // Round Robin - 4 teams 0-3

            // 0 v 1    0 v 3    0 v 2

            // 2 v 3    2 v 1    1 v 3

            grp.Matches = grp.BuildRoundRobin(groupTeams);

            groups.Add(grp);

        }

        return groups;

    }

    private static List<Grouping> DrawNextRoundUsingMatrix(List<Grouping> previousRound)

    {

        List<Grouping> groups = new ();

        int roundNo = previousRound.First().Round + 1;

        var results = previousRound.OrderBy(x => x.Group).Select(x => x.GetRanking()).ToArray();

        for(int g = 0 ; g < 16 ; g++)

        {

            var grp = new Grouping

            {

                Round = roundNo,

                Group = g + 1

            };

            //Console.WriteLine();

            //Console.WriteLine($"Group {g+1}");

            List<int> teams = new();

            int rank = (g/4) + 1;

            //Console.WriteLine($"Rank: {rank}");

            int from = (g * 4) % 16;

            int to = ((g+1) * 4) % 16;

            if (to == 0) to = 16;

            for(int x = from; x < to; x++)

            {

                //Console.WriteLine($"#{rank} from Group {x+1}");

                teams.Add(results[x][rank-1]);

            }

            grp.Matches = grp.BuildRoundRobin(teams.ToArray());

            groups.Add(grp);

        }

        return groups;

    }

    private static List<Grouping> DrawNextRoundDynamic(Draw[] results)

    {

        List<Grouping> groups = new ();

        int roundNo = results.Max(x => x.Round) + 1;

        var rankedTeams = results.GroupBy(x => x.Team).Select(x => new { Team = x.Key, Score = x.Sum(y => (int)y.Result), Opps = x.Select(m => m.Opponent).ToList()}).OrderByDescending(x => x.Score).ToList();

        var holding = rankedTeams.Take(0).ToList(); // hack to get a list of the same anonymous type ;)

​

        Console.WriteLine(String.Join(",", rankedTeams.Select(x => x.Team)));

        var queue = CreateQueue(rankedTeams);

        for(int g = 0 ; g < 16 ; g++)

        {

            var grp = new Grouping

            {

                Round = roundNo,

                Group = g + 1

            };

            //Console.WriteLine();

            //Console.WriteLine($"Group {g+1}");

            int[] teams = new int [4];

            var top4 = rankedTeams.Take(0).ToList();

            bool exists = false;

            while (top4.Count < 4 && queue.Any())

            {

                exists = false;

                var team = queue.Dequeue();

                foreach(var opp in top4)

                {

                    if (team == opp) continue;

                    if (team.Opps.Contains(team.Team))

                    {

                        Console.WriteLine($"Team {team.Team} already played {opp.Team}");

                        holding.Add(team);

                        exists = true;

                        break;

                    }

                }

                if(!exists)

                {

                    top4.Add(team);

                }

                //Console.WriteLine(String.Join(",", top4.Select(x => x.Team)));

            }

​

            // Now, put back the holding items to the top of the queue

            holding.AddRange(queue.ToList());

            queue = CreateQueue(holding);

            holding.Clear();

            // If not 4, we're into the duplicates, just let them play multiple times for now

            // Nothing special for today, later we can do triangles and fancy stuff, this is just a simple POC

            while (top4.Count < 4 && queue.Any())

                top4.Add(queue.Dequeue());

            grp.Matches = grp.BuildRoundRobin(top4.Select(x => x.Team).ToArray());

            groups.Add(grp);

        }

        return groups;

    }

    public static Stack<T> CreateStack<T>(IEnumerable<T> items)

    {

        var s = new Stack<T>(items);

        return s;

    }

    public static Queue<T> CreateQueue<T>(IEnumerable<T> items)

    {

        var q = new Queue<T>(items);

        return q;

    }

    /// <summary>Generate results for the round, override/replace this method if you have actual results to load</summary>

    private static void RecordResults(List<Grouping> round)

    {

        foreach(var g in round)

        {

            foreach(var m in g.Matches)

            {

                // DO NOT use randome for results, that is too hard to predict, to demonstrate how this swisses the outcome,

                //        we will use the team number to indicate the "skill" and usat as a bias.

                //        Just for fun, if the skill is within 5pts, we will call that a draw

                //        Because two equal opponents should end up in a stalemate in many games

                //m.Result = (Result)r.Next(1, 4);

                var skillDelta = m.Team2.Team - m.Team1.Team;

                if (Math.Abs(skillDelta) < 5) 

                    m.Result = Result.Draw;

                else if (skillDelta > 0)

                    m.Result = Result.Win;

                else

                    m.Result = Result.Loss;

                m.Team1.Result = m.Result;

                // invert the result

                m.Team2.Result = (Result)(4 - (int)m.Result);

            }

        }

    }

    /// <summary>Print the results to the screen</summary>

    private static void PrintResults(List<Grouping> round)

    {

        Console.WriteLine($"Round {round.First().Round}");

        // print 4 across

        for(var g = 0 ; g < 15 ; g += 4)

        {

            var g1Result = round[g].FormatResult().Split(Environment.NewLine);

            var g2Result = round[g+1].FormatResult().Split(Environment.NewLine);

            var g3Result = round[g+2].FormatResult().Split(Environment.NewLine);

            var g4Result = round[g+3].FormatResult().Split(Environment.NewLine);

            for(int l = 0 ; l < g1Result.Count() ; l ++)

            {

                Console.WriteLine(String.Join("      ", new string [] { g1Result[l].PadRight(50), g2Result[l].PadRight(50), g3Result[l].PadRight(50), g4Result[l].PadRight(50) }));

            }

​

            Console.WriteLine();

        }

    }

    private static Draw[] CollateAllResults(params List<Grouping>[] rounds)

    {

        return rounds.SelectMany(round => round).SelectMany(x => x.Matches.Select(x => x.Team1))

       .Concat(rounds.SelectMany(round => round).SelectMany(x => x.Matches.Select(x => x.Team2)))

       .ToArray();

    }

    private static void PrintRoundByRound(Draw[] results)

    {

        var round1 = results.Where(x => x.Round == 1).GroupBy(x => x.Team).Select(x => new { Team = x.Key, Score = x.Sum(y => (int)y.Result), Group = x.OrderBy(y=> y.Round).Last().Group, Round = x.Max(y=> y.Round)}).OrderByDescending(x => x.Score).ToArray();  

        var round2 = results.Where(x => x.Round <= 2).GroupBy(x => x.Team).Select(x => new { Team = x.Key, Score = x.Sum(y => (int)y.Result), Group = x.OrderBy(y=> y.Round).Last().Group, Round = x.Max(y=> y.Round)}).OrderByDescending(x => x.Score).ToArray();  

        var round3 = results.Where(x => x.Round <= 3).GroupBy(x => x.Team).Select(x => new { Team = x.Key, Score = x.Sum(y => (int)y.Result), Group = x.OrderBy(y=> y.Round).Last().Group, Round = x.Max(y=> y.Round)}).OrderByDescending(x => x.Score).ToArray();  

        var round4 = results.Where(x => x.Round <= 4).GroupBy(x => x.Team).Select(x => new { Team = x.Key, Score = x.Sum(y => (int)y.Result), Group = x.OrderBy(y=> y.Round).Last().Group, Round = x.Max(y=> y.Round)}).OrderByDescending(x => x.Score).ToArray();

        Console.WriteLine("Key: Team (score) G[group]");

        Console.WriteLine();

        Console.WriteLine("Ranked Results:");

        Console.WriteLine("RANK    Round 1           Round 2            Round 3            Round 4");

        Console.WriteLine("        -------------     -------------      -------------      -------------");

        for(int l = 0 ; l < round1.Length ; l ++)

        {

            Console.WriteLine($"#{(l+1).ToString().PadRight(2)}     {round1[l].Team.ToString().PadLeft(2)} ({round1[l].Score.ToString().PadLeft(2)}) G[{round1[l].Group.ToString().PadLeft(2)}]     {round2[l].Team.ToString().PadLeft(2)} ({round2[l].Score.ToString().PadLeft(2)}) G[{round2[l].Group.ToString().PadLeft(2)}]      {round3[l].Team.ToString().PadLeft(2)} ({round3[l].Score.ToString().PadLeft(2)}) G[{round3[l].Group.ToString().PadLeft(2)}]      {round4[l].Team.ToString().PadLeft(2)} ({round4[l].Score.ToString().PadLeft(2)}) G[{round4[l].Group.ToString().PadLeft(2)}] ");

        }

        var teamsRound1 = round1.Select((result, index) => new { result.Round, result.Group, result.Team, result.Score, Rank = index}).OrderBy(x => x.Team).ToArray();

        var teamsRound2 = round2.Select((result, index) => new { result.Round, result.Group, result.Team, result.Score, Rank = index}).OrderBy(x => x.Team).ToArray();

        var teamsRound3 = round3.Select((result, index) => new { result.Round, result.Group, result.Team, result.Score, Rank = index}).OrderBy(x => x.Team).ToArray();

        var teamsRound4 = round4.Select((result, index) => new { result.Round, result.Group, result.Team, result.Score, Rank = index}).OrderBy(x => x.Team).ToArray();

​

        Console.WriteLine();

        Console.WriteLine("By Teams:");

        Console.WriteLine("TEAM    Round 1           Round 2            Round 3            Round 4");

        Console.WriteLine("        -------------     -------------      -------------      -------------");

        for(int l = 0 ; l < round1.Length ; l ++)

        {

            Console.WriteLine($"#{(l+1).ToString().PadRight(2)}     {teamsRound1[l].Team.ToString().PadLeft(2)} ({teamsRound1[l].Score.ToString().PadLeft(2)}) G[{teamsRound1[l].Group.ToString().PadLeft(2)}]     {teamsRound2[l].Team.ToString().PadLeft(2)} ({teamsRound2[l].Score.ToString().PadLeft(2)}) G[{teamsRound2[l].Group.ToString().PadLeft(2)}]      {teamsRound3[l].Team.ToString().PadLeft(2)} ({teamsRound3[l].Score.ToString().PadLeft(2)}) G[{teamsRound3[l].Group.ToString().PadLeft(2)}]      {teamsRound4[l].Team.ToString().PadLeft(2)} ({teamsRound4[l].Score.ToString().PadLeft(2)}) G[{teamsRound4[l].Group.ToString().PadLeft(2)}] ");

        }   

        Console.WriteLine();

        Console.WriteLine("Matchups:");

        Console.WriteLine("TEAM    Round 1           Round 2           Round 3           Round 4");

        Console.WriteLine("        -------------     -------------     -------------     -------------");

        for(int l = 0 ; l < round1.Length ; l ++)

        {

            Console.Write($"#{(l+1).ToString().PadRight(2)}     ");

            Console.Write($"{(String.Join(",", results.Where(x => x.Round == 1 && x.Team == l+1).Select(x => $"{(x.Opponent).ToString().PadLeft(2)}{x.Result.ToString().ToCharArray()[0]}")))}       ");

            Console.Write($"{(String.Join(",", results.Where(x => x.Round == 2 && x.Team == l+1).Select(x => $"{(x.Opponent).ToString().PadLeft(2)}{x.Result.ToString().ToCharArray()[0]}")))}       ");

            Console.Write($"{(String.Join(",", results.Where(x => x.Round == 3 && x.Team == l+1).Select(x => $"{(x.Opponent).ToString().PadLeft(2)}{x.Result.ToString().ToCharArray()[0]}")))}       ");

            Console.Write($"{(String.Join(",", results.Where(x => x.Round == 4 && x.Team == l+1).Select(x => $"{(x.Opponent).ToString().PadLeft(2)}{x.Result.ToString().ToCharArray()[0]}")))}       ");

            Console.WriteLine();

        }   

    }

    private static void PrintComparison(Draw[] results, Draw[] resultsD)

    {

        var round4 = results.Where(x => x.Round <= 4).GroupBy(x => x.Team).Select(x => new { Team = x.Key, Score = x.Sum(y => (int)y.Result), Group = x.OrderBy(y=> y.Round).Last().Group, Round = x.Max(y=> y.Round)}).OrderByDescending(x => x.Score).ToArray();

        var round4D = resultsD.Where(x => x.Round <= 4).GroupBy(x => x.Team).Select(x => new { Team = x.Key, Score = x.Sum(y => (int)y.Result), Group = x.OrderBy(y=> y.Round).Last().Group, Round = x.Max(y=> y.Round)}).OrderByDescending(x => x.Score).ToArray();

​

        Console.WriteLine();

        Console.WriteLine("Compare Ranked Results:");

        Console.WriteLine("RANK    Round 4 Matrix    Round 4 Dynamic");

        Console.WriteLine("        -------------     -------------  ");

        for(int l = 0 ; l < round4.Length ; l ++)

        {

            Console.Write($"#{(l+1).ToString().PadRight(2)}     ");

            Console.Write($"{round4[l].Team.ToString().PadLeft(2)} ({round4[l].Score.ToString().PadLeft(2)}) G[{round4[l].Group.ToString().PadLeft(2)}]     ");

            Console.Write($"{round4D[l].Team.ToString().PadLeft(2)} ({round4D[l].Score.ToString().PadLeft(2)}) G[{round4D[l].Group.ToString().PadLeft(2)}]      ");

            Console.WriteLine();

        }

    }

    public class Grouping

    {

        public int Round { get; set; }

        public int Group { get; set; }

        public Matching[] Matches { get;set; }

        public string FormatResult()

        {

            StringBuilder output = new();

            output.AppendLine($"Group {Group}:   {String.Join(", ", GetRanking())}");

            output.AppendLine("--------------------------------------------------");

            output.AppendLine($" {Matches[0].FormatResult()}    {Matches[2].FormatResult()}    {Matches[4].FormatResult()} ");

            output.AppendLine($" {Matches[1].FormatResult()}    {Matches[3].FormatResult()}    {Matches[5].FormatResult()} ");

            return output.ToString();

        }

        public int[] GetRanking()

        {

            return Matches.Select(x => x.Team1).Concat(Matches.Select(x => x.Team2)).GroupBy(x => x.Team).OrderByDescending(x => x.Sum(y => (int)y.Result)).Select(x => x.Key).ToArray();

        }

        public Matching[] BuildRoundRobin(int[] teams)

        {

            if (teams.Length != 4) throw new NotSupportedException("Hardcoded for 4 teams in a group only!");

            return

                new List<Matching> {

                new Matching(Round, Group, 1, 1, teams[0], teams[1]),

                new Matching(Round, Group, 2, 1, teams[2], teams[3]),

                new Matching(Round, Group, 3, 2, teams[0], teams[3]),

                new Matching(Round, Group, 4, 2, teams[2], teams[1]),

                new Matching(Round, Group, 5, 3, teams[0], teams[2]),

                new Matching(Round, Group, 6, 3, teams[1], teams[3])

            }.ToArray();

        }

    }

    public class Matching

    {

        public Matching() {}

        public Matching(int round, int group, int match, int draw, int team1, int team2)

        {

            Round = round; 

            Group = group;

            Match = match;

            Draw = draw;

            Team1 = new Draw {

                    Round = round,

                    Group = group,

                    Team = team1,

                    Opponent = team2

                };

                Team2 = new Draw {

                    Round = round,

                    Group = group,

                    Team = team2,

                    Opponent = team1

                };      

        }

        public int Round { get;set; }

        public int Group { get;set; }

        public int Match { get;set; }

        public int Draw { get;set; }

        /// <summary> result in terms of Team 1, Team 2 is the opposite </summary>

        public Result Result { get;set;}

        public Draw Team1 { get;set; }

        public Draw Team2 { get;set; }

        public string FormatResult()

        {

            return $"{Team1.Team.ToString().PadLeft(2)}({Team1.Result.ToString().First()}) v {Team2.Team.ToString().PadLeft(2)}({Team2.Result.ToString().First()})";

        }

    }

    public class Draw

    {

        public int Round { get;set; }

        public int Group { get;set; }

        public int Team { get;set; }

        public int Opponent { get;set; }

        /// <summary> result in terms of Team 1 </summary>

        public Result Result { get;set;}

    }

    public enum Result : int 

    {

        NotPLayed = 0,

        Loss = 1,

        Draw = 2,

        Win = 3

    }

}